aherman
/
packer
mirror of https://github.com/hashicorp/packer
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor: change step_network_info to new OSC SDK

Browse Source
pull/10056/head
Marin Salinas 6 years ago
parent 8649496c6c
commit 8b2cdc5821
2 changed files with 101 additions and 25 deletions
Show Stats Download Patch File Download Diff File

52
builder/osc/common/build_filters.go
Unescape View File

@ -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 {

74
builder/osc/common/step_network_info.go
Unescape View File

@ -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) {}

Write Preview
Loading…
Cancel
Save