From 8b2cdc5821fe1cdd14dcedd54ff86b418522c648 Mon Sep 17 00:00:00 2001 From: Marin Salinas Date: Tue, 18 Aug 2020 10:34:02 -0500 Subject: [PATCH] refactor: change step_network_info to new OSC SDK --- builder/osc/common/build_filters.go | 52 +++++++++++++++++ builder/osc/common/step_network_info.go | 74 ++++++++++++++++--------- 2 files changed, 101 insertions(+), 25 deletions(-) diff --git a/builder/osc/common/build_filters.go b/builder/osc/common/build_filters.go index 4b0fb20cd..17a48a1b5 100644 --- a/builder/osc/common/build_filters.go +++ b/builder/osc/common/build_filters.go @@ -34,6 +34,32 @@ func buildNetFilters(input map[string]string) oapi.FiltersNet { return filters } +func buildOscNetFilters(input map[string]string) osc.FiltersNet { + var filters osc.FiltersNet + for k, v := range input { + filterValue := []string{v} + switch name := k; name { + case "ip-range": + filters.IpRanges = filterValue + case "dhcp-options-set-id": + filters.DhcpOptionsSetIds = filterValue + case "is-default": + if isDefault, err := strconv.ParseBool(v); err == nil { + filters.IsDefault = isDefault + } + case "state": + filters.States = filterValue + case "tag-key": + filters.TagKeys = filterValue + case "tag-value": + filters.TagValues = filterValue + default: + log.Printf("[Debug] Unknown Filter Name: %s.", name) + } + } + return filters +} + func buildSubnetFilters(input map[string]string) oapi.FiltersSubnet { var filters oapi.FiltersSubnet for k, v := range input { @@ -60,6 +86,32 @@ func buildSubnetFilters(input map[string]string) oapi.FiltersSubnet { return filters } +func buildOscSubnetFilters(input map[string]string) osc.FiltersSubnet { + var filters osc.FiltersSubnet + for k, v := range input { + filterValue := []string{v} + switch name := k; name { + case "available-ips-counts": + if ipCount, err := strconv.Atoi(v); err == nil { + filters.AvailableIpsCounts = []int32{int32(ipCount)} + } + case "ip-ranges": + filters.IpRanges = filterValue + case "net-ids": + filters.NetIds = filterValue + case "states": + filters.States = filterValue + case "subnet-ids": + filters.SubnetIds = filterValue + case "sub-region-names": + filters.SubregionNames = filterValue + default: + log.Printf("[Debug] Unknown Filter Name: %s.", name) + } + } + return filters +} + func buildOMIFilters(input map[string]string) oapi.FiltersImage { var filters oapi.FiltersImage for k, v := range input { diff --git a/builder/osc/common/step_network_info.go b/builder/osc/common/step_network_info.go index 937758bae..e583348df 100644 --- a/builder/osc/common/step_network_info.go +++ b/builder/osc/common/step_network_info.go @@ -7,9 +7,11 @@ import ( "math/rand" "sort" + "github.com/antihax/optional" "github.com/hashicorp/packer/helper/multistep" "github.com/hashicorp/packer/packer" "github.com/outscale/osc-go/oapi" + "github.com/outscale/osc-sdk-go/osc" ) // StepNetworkInfo queries OUTSCALE for information about @@ -37,6 +39,14 @@ func (a subnetsSort) Less(i, j int) bool { return a[i].AvailableIpsCount < a[j].AvailableIpsCount } +type subnetsOscSort []osc.Subnet + +func (a subnetsOscSort) Len() int { return len(a) } +func (a subnetsOscSort) Swap(i, j int) { a[i], a[j] = a[j], a[i] } +func (a subnetsOscSort) Less(i, j int) bool { + return a[i].AvailableIpsCount < a[j].AvailableIpsCount +} + // Returns the most recent OMI out of a slice of images. func mostFreeSubnet(subnets []oapi.Subnet) oapi.Subnet { sortedSubnets := subnets @@ -44,19 +54,29 @@ func mostFreeSubnet(subnets []oapi.Subnet) oapi.Subnet { return sortedSubnets[len(sortedSubnets)-1] } +// Returns the most recent OMI out of a slice of images. +func mostFreeOscSubnet(subnets []osc.Subnet) osc.Subnet { + sortedSubnets := subnets + sort.Sort(subnetsOscSort(sortedSubnets)) + return sortedSubnets[len(sortedSubnets)-1] +} + +//Run ... func (s *StepNetworkInfo) Run(_ context.Context, state multistep.StateBag) multistep.StepAction { - oapiconn := state.Get("oapi").(*oapi.Client) + oscconn := state.Get("osc").(*osc.APIClient) ui := state.Get("ui").(packer.Ui) // NET if s.NetId == "" && !s.NetFilter.Empty() { - params := oapi.ReadNetsRequest{} - params.Filters = buildNetFilters(s.NetFilter.Filters) + params := osc.ReadNetsRequest{} + params.Filters = buildOscNetFilters(s.NetFilter.Filters) s.NetFilter.Filters["state"] = "available" log.Printf("Using NET Filters %v", params) - vpcResp, err := oapiconn.POST_ReadNets(params) + vpcResp, _, err := oscconn.NetApi.ReadNets(context.Background(), &osc.ReadNetsOpts{ + ReadNetsRequest: optional.NewInterface(params), + }) if err != nil { err := fmt.Errorf("Error querying NETs: %s", err) state.Put("error", err) @@ -64,20 +84,20 @@ func (s *StepNetworkInfo) Run(_ context.Context, state multistep.StateBag) multi return multistep.ActionHalt } - if len(vpcResp.OK.Nets) != 1 { - err := fmt.Errorf("Exactly one NET should match the filter, but %d NET's was found matching filters: %v", len(vpcResp.OK.Nets), params) + if len(vpcResp.Nets) != 1 { + err := fmt.Errorf("Exactly one NET should match the filter, but %d NET's was found matching filters: %v", len(vpcResp.Nets), params) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } - s.NetId = vpcResp.OK.Nets[0].NetId + s.NetId = vpcResp.Nets[0].NetId ui.Message(fmt.Sprintf("Found NET ID: %s", s.NetId)) } // Subnet if s.SubnetId == "" && !s.SubnetFilter.Empty() { - params := oapi.ReadSubnetsRequest{} + params := osc.ReadSubnetsRequest{} s.SubnetFilter.Filters["state"] = "available" if s.NetId != "" { @@ -86,39 +106,41 @@ func (s *StepNetworkInfo) Run(_ context.Context, state multistep.StateBag) multi if s.SubregionName != "" { s.SubnetFilter.Filters["availability-zone"] = s.SubregionName } - params.Filters = buildSubnetFilters(s.SubnetFilter.Filters) + params.Filters = buildOscSubnetFilters(s.SubnetFilter.Filters) log.Printf("Using Subnet Filters %v", params) - subnetsResp, err := oapiconn.POST_ReadSubnets(params) + subnetsResp, _, err := oscconn.SubnetApi.ReadSubnets(context.Background(), &osc.ReadSubnetsOpts{ + ReadSubnetsRequest: optional.NewInterface(params), + }) if err != nil { - err := fmt.Errorf("Error querying Subnets: %s", err) + err := fmt.Errorf("error querying Subnets: %s", err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } - if len(subnetsResp.OK.Subnets) == 0 { + if len(subnetsResp.Subnets) == 0 { err := fmt.Errorf("No Subnets was found matching filters: %v", params) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } - if len(subnetsResp.OK.Subnets) > 1 && !s.SubnetFilter.Random && !s.SubnetFilter.MostFree { - err := fmt.Errorf("Your filter matched %d Subnets. Please try a more specific search, or set random or most_free to true.", len(subnetsResp.OK.Subnets)) + if len(subnetsResp.Subnets) > 1 && !s.SubnetFilter.Random && !s.SubnetFilter.MostFree { + err := fmt.Errorf("your filter matched %d Subnets. Please try a more specific search, or set random or most_free to true", len(subnetsResp.Subnets)) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } - var subnet oapi.Subnet + var subnet osc.Subnet switch { case s.SubnetFilter.MostFree: - subnet = mostFreeSubnet(subnetsResp.OK.Subnets) + subnet = mostFreeOscSubnet(subnetsResp.Subnets) case s.SubnetFilter.Random: - subnet = subnetsResp.OK.Subnets[rand.Intn(len(subnetsResp.OK.Subnets))] + subnet = subnetsResp.Subnets[rand.Intn(len(subnetsResp.Subnets))] default: - subnet = subnetsResp.OK.Subnets[0] + subnet = subnetsResp.Subnets[0] } s.SubnetId = subnet.SubnetId ui.Message(fmt.Sprintf("Found Subnet ID: %s", s.SubnetId)) @@ -127,24 +149,25 @@ func (s *StepNetworkInfo) Run(_ context.Context, state multistep.StateBag) multi // Try to find Subregion and NET Id from Subnet if they are not yet found/given if s.SubnetId != "" && (s.SubregionName == "" || s.NetId == "") { log.Printf("[INFO] Finding Subregion and NetId for the given subnet '%s'", s.SubnetId) - resp, err := oapiconn.POST_ReadSubnets( - oapi.ReadSubnetsRequest{ - Filters: oapi.FiltersSubnet{ + resp, _, err := oscconn.SubnetApi.ReadSubnets(context.Background(), &osc.ReadSubnetsOpts{ + ReadSubnetsRequest: optional.NewInterface(osc.ReadSubnetsRequest{ + Filters: osc.FiltersSubnet{ SubnetIds: []string{s.SubnetId}, }, - }) + }), + }) if err != nil { - err := fmt.Errorf("Describing the subnet: %s returned error: %s.", s.SubnetId, err) + err := fmt.Errorf("describing the subnet: %s returned error: %s", s.SubnetId, err) state.Put("error", err) ui.Error(err.Error()) return multistep.ActionHalt } if s.SubregionName == "" { - s.SubregionName = resp.OK.Subnets[0].SubregionName + s.SubregionName = resp.Subnets[0].SubregionName log.Printf("[INFO] SubregionName found: '%s'", s.SubregionName) } if s.NetId == "" { - s.NetId = resp.OK.Subnets[0].NetId + s.NetId = resp.Subnets[0].NetId log.Printf("[INFO] NetId found: '%s'", s.NetId) } } @@ -155,4 +178,5 @@ func (s *StepNetworkInfo) Run(_ context.Context, state multistep.StateBag) multi return multistep.ActionContinue } +//Cleanup ... func (s *StepNetworkInfo) Cleanup(multistep.StateBag) {}