Fix load balancer backendset creation without certificates. Closes #85

Author: mikejihbe

crud/helpers.go

@@ -68,14 +68,16 @@ func (s *BaseCrud) State() string {
 }
 
 func handleMissingResourceError(sync ResourceVoider, err *error) {
-	if err != nil && (
-		strings.Contains((*err).Error(), "does not exist") ||
+
+	if err != nil {
+		if strings.Contains((*err).Error(), "does not exist") ||
 		strings.Contains((*err).Error(), " not present in ") ||
 		strings.Contains((*err).Error(), "resource not found") ||
-			(strings.Contains((*err).Error(), "Load balancer") && strings.Contains((*err).Error(), " has no "))) {
-		log.Println("[DEBUG] Object does not exist, voiding resource and nullifying error")
-		sync.VoidState()
-		*err = nil
+		(strings.Contains((*err).Error(), "Load balancer") && strings.Contains((*err).Error(), " has no ")) {
+			log.Println("[DEBUG] Object does not exist, voiding resource and nullifying error")
+			sync.VoidState()
+			*err = nil
+		}
 	}
 }
 
@@ -116,7 +118,6 @@ func LoadBalancerResourceID(res interface{}, workReq *baremetal.WorkRequest) (id
 
 func LoadBalancerResourceGet(s BaseCrud, workReq *baremetal.WorkRequest) (id string, stillWorking bool, err error) {
 	id = s.D.Id()
-	log.Printf("================== ID in LoadbalancerResourceGet: %s\n", id)
 	// NOTE: if the id is for a work request, refresh its state and loadBalancerID.
 	if strings.HasPrefix(id, "ocid1.loadbalancerworkrequest.") {
 		updatedWorkReq, err := s.Client.GetWorkRequest(id, nil)
@@ -169,8 +170,20 @@ func ReadResource(sync ResourceReader) (e error) {
 		handleMissingResourceError(sync, &e)
 		return
 	}
+
 	sync.SetData()
 
+	/* Attempt at #113, but this breaks everything. Probably because this is used internally by other state checking mechanisms.
+
+	if dr, ok := sync.(StatefullyDeletedResource); ok {
+		for _, target := range dr.DeletedTarget() {
+			if dr.State() == target {
+				dr.VoidState()
+				return
+			}
+		}
+	}*/
+
 	return
 }
 
@@ -191,12 +204,14 @@ func UpdateResource(d *schema.ResourceData, sync ResourceUpdater) (e error) {
 // Finally, sets the ResourceData state to empty.
 func DeleteResource(d *schema.ResourceData, sync ResourceDeleter) (e error) {
 	if e = sync.Delete(); e != nil {
-		return
+		handleMissingResourceError(sync, &e)
+		if e != nil {
+			return
+		}
 	}
 
 	if stateful, ok := sync.(StatefullyDeletedResource); ok {
 		e = waitForStateRefresh(stateful, d.Timeout(schema.TimeoutDelete), stateful.DeletedPending(), stateful.DeletedTarget())
-
 	}
 
 	if ew, waitOK := sync.(ExtraWaitPostCreateDelete); waitOK {

resource_obmcs_loadbalancer_backend_set.go

@@ -158,23 +158,11 @@ func (s *LoadBalancerBackendSetResourceCrud) Get() (e error) {
 }
 
 func (s *LoadBalancerBackendSetResourceCrud) Update() (e error) {
-	healthChecker := baremetal.HealthChecker{
-		IntervalInMS:      s.D.Get("health_checker.interval_ms").(int),
-		Port:              s.D.Get("health_checker.port").(int),
-		Protocol:          s.D.Get("health_checker.protocol").(string),
-		ResponseBodyRegex: s.D.Get("health_checker.response_body_regex").(string),
-		URLPath: 	   s.D.Get("health_checker.url_path").(string),
-	}
-	sslConfig := baremetal.SSLConfiguration{
-		CertificateName:       s.D.Get("ssl_configuration.certificate_name").(string),
-		VerifyDepth:           s.D.Get("ssl_configuration.verify_depth").(int),
-		VerifyPeerCertificate: s.D.Get("ssl_configuration.verify_peer_certificate").(bool),
-	}
-	opts := &baremetal.UpdateLoadBalancerBackendSetOptions{
-		Policy:        s.D.Get("policy").(string),
-		SSLConfig:     sslConfig,
-		HealthChecker: healthChecker,
-	}
+	opts := &baremetal.UpdateLoadBalancerBackendSetOptions{}
+
+	opts.HealthChecker = s.healthChecker()
+	opts.SSLConfig = s.sslConfig()
+	opts.Policy = s.D.Get("policy").(string)
 
 	var workReqID string
 	workReqID, e = s.Client.UpdateBackendSet(s.D.Get("load_balancer_id").(string), s.D.Id(), opts)
@@ -191,18 +179,24 @@ func (s *LoadBalancerBackendSetResourceCrud) SetData() {
 	}
 	s.D.Set("policy", s.Resource.Policy)
 	s.D.Set("name", s.Resource.Name)
-	s.D.Set("health_checker", map[string]interface{}{
-		"interval_ms":         s.Resource.HealthChecker.IntervalInMS,
-		"port":                s.Resource.HealthChecker.Port,
-		"protocol":            s.Resource.HealthChecker.Protocol,
-		"response_body_regex": s.Resource.HealthChecker.ResponseBodyRegex,
-		"url_path": 	       s.Resource.HealthChecker.URLPath,
-	})
-	s.D.Set("ssl_configuration", map[string]interface{}{
-		"certificate_name":        s.Resource.SSLConfig.CertificateName,
-		"verify_depth":            s.Resource.SSLConfig.VerifyDepth,
-		"verify_peer_certificate": s.Resource.SSLConfig.VerifyPeerCertificate,
-	})
+	if s.Resource.HealthChecker != nil {
+		s.D.Set("health_checker", map[string]interface{}{
+			"interval_ms":         s.Resource.HealthChecker.IntervalInMS,
+			"port":                s.Resource.HealthChecker.Port,
+			"protocol":            s.Resource.HealthChecker.Protocol,
+			"response_body_regex": s.Resource.HealthChecker.ResponseBodyRegex,
+			"url_path":               s.Resource.HealthChecker.URLPath,
+		})
+	}
+
+	if s.Resource.SSLConfig != nil {
+		s.D.Set("ssl_configuration", map[string]interface{}{
+			"certificate_name":        s.Resource.SSLConfig.CertificateName,
+			"verify_depth":            s.Resource.SSLConfig.VerifyDepth,
+			"verify_peer_certificate": s.Resource.SSLConfig.VerifyPeerCertificate,
+		})
+	}
+
 	backends := make([]map[string]interface{}, len(s.Resource.Backends))
 	for i, v := range s.Resource.Backends {
 		backends[i] = map[string]interface{}{
@@ -229,30 +223,33 @@ func (s *LoadBalancerBackendSetResourceCrud) Delete() (e error) {
 }
 
 func (s *LoadBalancerBackendSetResourceCrud) sslConfig() (sslConfig *baremetal.SSLConfiguration) {
-	sslConfig = new(baremetal.SSLConfiguration)
 	vs := s.D.Get("ssl_configuration").([]interface{})
 	if len(vs) == 1 {
+		sslConfig = new(baremetal.SSLConfiguration)
 		v := vs[0].(map[string]interface{})
 		sslConfig.CertificateName = v["certificate_name"].(string)
 		sslConfig.VerifyDepth = v["verify_depth"].(int)
 		sslConfig.VerifyPeerCertificate = v["verify_peer_certificate"].(bool)
+		return sslConfig
 	}
 
-	return
+	return nil
 }
 
 func (s *LoadBalancerBackendSetResourceCrud) healthChecker() *baremetal.HealthChecker {
-	healthChecker := new(baremetal.HealthChecker)
+
 	vs := s.D.Get("health_checker").([]interface{})
 	if len(vs) == 1 {
+		healthChecker := new(baremetal.HealthChecker)
 		v := vs[0].(map[string]interface{})
 		healthChecker.IntervalInMS = v["interval_ms"].(int)
 		healthChecker.Port = v["port"].(int)
 		healthChecker.Protocol = v["protocol"].(string)
 		healthChecker.ResponseBodyRegex = v["response_body_regex"].(string)
 		healthChecker.URLPath = v["url_path"].(string)
+		return healthChecker
 	}
-	return healthChecker
+	return nil
 }
 func (s *LoadBalancerBackendSetResourceCrud) backends() []baremetal.Backend {
 	vs := s.D.Get("backend").([]interface{})

resource_obmcs_loadbalancer_loadbalancer.go

@@ -100,7 +100,6 @@ type LoadBalancerResourceCrud struct {
 // ID delegates to the load balancer ID, falling back to the work request ID
 func (s *LoadBalancerResourceCrud) ID() string {
 	id, workSuccess := crud.LoadBalancerResourceID(s.Resource, s.WorkRequest)
-	log.Printf("==================\n%s,%v\n", *id, workSuccess)
 	if id != nil {
 		return *id
 	}
@@ -175,7 +174,6 @@ func (s *LoadBalancerResourceCrud) Create() (e error) {
 func (s *LoadBalancerResourceCrud) Get() (e error) {
 	// key: {workRequestID} || {loadBalancerID}
 	id, stillWorking, err := crud.LoadBalancerResourceGet(s.BaseCrud, s.WorkRequest)
-	log.Printf("==================\n%s,%v,%v,%v\n", id, stillWorking, err, s.WorkRequest)
 	if err != nil {
 		return err
 	}
@@ -212,7 +210,7 @@ func (s *LoadBalancerResourceCrud) Update() (e error) {
 func (s *LoadBalancerResourceCrud) SetData() {
 	// The first time this is called, we haven't actually fetched the resource yet, we just got a work request
 	if s.Resource != nil && s.Resource.ID != "" {
-		s.D.SetId(s.Resource.ID)
+		//s.D.SetId(s.Resource.ID)
 		s.D.Set("compartment_id", s.Resource.CompartmentID)
 		s.D.Set("display_name", s.Resource.DisplayName)
 		s.D.Set("shape", s.Resource.Shape)

resource_obmcs_loadbalancer_test.go

@@ -36,6 +36,20 @@ func (s *ResourceLoadBalancerTestSuite) SetupTest() {
 	s.ResourceName = "baremetal_load_balancer.t"
 	s.Config = loadbalancerConfig + certificateConfig + `
 
+resource "baremetal_load_balancer_backendset" "no_cert" {
+  load_balancer_id = "${baremetal_load_balancer.t.id}"
+  name             = "stub_backendset_name_no_cert"
+  policy           = "ROUND_ROBIN"
+
+  health_checker {
+    interval_ms         = 30000
+    port                = 1234
+    protocol            = "HTTP"
+    response_body_regex = ".*"
+    url_path = "/"
+  }
+}
+
 resource "baremetal_load_balancer_backendset" "t" {
   load_balancer_id = "${baremetal_load_balancer.t.id}"
   name             = "stub_backendset_name"
@@ -80,7 +94,7 @@ resource "baremetal_load_balancer_backend" "t" {
   offline          = true
   weight           = 1
 }
-	`
+`
 	s.Config += testProviderConfig()
 }
 
@@ -99,18 +113,22 @@ func (s *ResourceLoadBalancerTestSuite) TestCreateResourceLoadBalancerMaximal()
 					resource.TestCheckResourceAttrSet("baremetal_load_balancer.t", "ip_addresses.#"),
 
 					resource.TestCheckResourceAttr("baremetal_load_balancer_listener.t", "ssl_configuration.#", "1"),
-					/*
+
 					// Certificate
-					resource.TestCheckResourceAttrSet("baremetal_load_balancer_certificate.t.certificate_name", "stub_certificate_name"),
+					resource.TestCheckResourceAttr("baremetal_load_balancer_certificate.t", "certificate_name", "stub_certificate_name"),
 
 					// BackendSet
 					resource.TestCheckResourceAttr("baremetal_load_balancer_backendset.t", "name", "stub_backendset_name"),
-					resource.TestCheckResourceAttr("baremetal_load_balancer_backendset.t", "health_checker.port", "1234"),
+					resource.TestCheckResourceAttr("baremetal_load_balancer_backendset.t", "health_checker.0.port", "1234"),
 					resource.TestCheckResourceAttr("baremetal_load_balancer_backendset.t", "ssl_configuration.#", "1"),
 					resource.TestCheckResourceAttr("baremetal_load_balancer_backendset.t", "ssl_configuration.0.certificate_name", "stub_certificate_name"),
 					resource.TestCheckResourceAttr("baremetal_load_balancer_backendset.t", "ssl_configuration.0.verify_depth", "6"),
 					resource.TestCheckResourceAttr("baremetal_load_balancer_backendset.t", "ssl_configuration.0.verify_peer_certificate", "false"),
 
+					resource.TestCheckResourceAttr("baremetal_load_balancer_backendset.no_cert", "name", "stub_backendset_name_no_cert"),
+					resource.TestCheckResourceAttr("baremetal_load_balancer_backendset.no_cert", "health_checker.0.port", "1234"),
+
+
 					// Listener
 					resource.TestCheckResourceAttr("baremetal_load_balancer_listener.t", "name", "stub_listener_name"),
 
@@ -124,7 +142,6 @@ func (s *ResourceLoadBalancerTestSuite) TestCreateResourceLoadBalancerMaximal()
 					resource.TestCheckResourceAttr("baremetal_load_balancer_backend.t", "drain", "true"),
 					resource.TestCheckResourceAttr("baremetal_load_balancer_backend.t", "offline", "true"),
 					resource.TestCheckResourceAttr("baremetal_load_balancer_backend.t", "weight", "1"),
-					*/
 				),
 			},
 		},