Cleanup Network Segmentation support

builtin/providers/openstack/resource_openstack_networking_network_v2.go

@@ -63,26 +63,22 @@ func resourceNetworkingNetworkV2() *schema.Resource {
  Type: schema.TypeList,
  Optional: true,
  ForceNew: true,
- Computed: true,
  Elem: &schema.Resource{
  Schema: map[string]*schema.Schema{
  "physical_network": &schema.Schema{
  Type: schema.TypeString,
  Optional: true,
  ForceNew: true,
- Computed: true,
  },
  "network_type": &schema.Schema{
  Type: schema.TypeString,
  Optional: true,
  ForceNew: true,
- Computed: true,
  },
  "segmentation_id": &schema.Schema{
- Type: schema.TypeString,
+ Type: schema.TypeInt,
  Optional: true,
  ForceNew: true,
- Computed: true,
  },
  },
  },
@@ -129,33 +125,19 @@ func resourceNetworkingNetworkV2Create(d *schema.ResourceData, meta interface{})
  createOpts.Shared = &shared
  }
 
- segmentDetails, err := getSegments(d)
- if err != nil {
- return err
- }
- segments := make([]provider.Segment, len(segmentDetails))
- for i, segment := range segmentDetails {
- id, err := strconv.Atoi(segment["segmentation_id"].(string))
- if err != nil {
- return err
- }
- segments[i] = provider.Segment{
- PhysicalNetwork: segment["physical_network"].(string),
- NetworkType: segment["network_type"].(string),
- SegmentationID: id,
- }
- }
-
- log.Printf("[DEBUG] Create Options: %#v", createOpts)
+ segments := resourceNetworkingNetworkV2Segments(d)
 
  n := &networks.Network{}
  if len(segments) > 0 {
  providerCreateOpts := provider.CreateOptsExt{
  CreateOptsBuilder: createOpts,
  Segments: segments,
  }
+
+ log.Printf("[DEBUG] Create Options: %#v", providerCreateOpts)
  n, err = networks.Create(networkingClient, providerCreateOpts).Extract()
  } else {
+ log.Printf("[DEBUG] Create Options: %#v", createOpts)
  n, err = networks.Create(networkingClient, createOpts).Extract()
  }
 
@@ -183,27 +165,6 @@ func resourceNetworkingNetworkV2Create(d *schema.ResourceData, meta interface{})
  return resourceNetworkingNetworkV2Read(d, meta)
 }
 
-func getSegments(d *schema.ResourceData) ([]map[string]interface{}, error) {
- rawSegments := d.Get("segments").([]interface{})
- newSegments := make([]map[string]interface{}, 0, len(rawSegments))
-
- for _, raw := range rawSegments {
- if raw == nil {
- continue
- }
-
- rawMap := raw.(map[string]interface{})
-
- newSegments = append(newSegments, map[string]interface{}{
- "physical_network": rawMap["physical_network"].(string),
- "network_type": rawMap["network_type"].(string),
- "segmentation_id": rawMap["segmentation_id"].(string),
- })
-
- }
- return newSegments, nil
-}
-
 func resourceNetworkingNetworkV2Read(d *schema.ResourceData, meta interface{}) error {
  config := meta.(*Config)
  networkingClient, err := config.networkingV2Client(GetRegion(d))
@@ -294,6 +255,31 @@ func resourceNetworkingNetworkV2Delete(d *schema.ResourceData, meta interface{})
  return nil
 }
 
+func resourceNetworkingNetworkV2Segments(d *schema.ResourceData) []provider.Segment {
+ var providerSegments []provider.Segment
+ segments := d.Get("segments").([]interface{})
+ for _, v := range segments {
+ var segment provider.Segment
+ segmentMap := v.(map[string]interface{})
+
+ if v, ok := segmentMap["physical_network"].(string); ok {
+ segment.PhysicalNetwork = v
+ }
+
+ if v, ok := segmentMap["network_type"].(string); ok {
+ segment.NetworkType = v
+ }
+
+ if v, ok := segmentMap["segmentation_id"].(int); ok {
+ segment.SegmentationID = v
+ }
+
+ providerSegments = append(providerSegments, segment)
+ }
+
+ return providerSegments
+}
+
 func waitForNetworkActive(networkingClient *gophercloud.ServiceClient, networkId string) resource.StateRefreshFunc {
  return func() (interface{}, string, error) {
  n, err := networks.Get(networkingClient, networkId).Extract()