Replace hardcoded volume values by an API call

Some servers need to match a minimum volume size in order to be created. Those
criteria were hardcoded into the server creation. Replace those by a call to
the Products API. Then given the minimum volume size, partition it into
predefined volume sizes.

Author: tbillon

pkg/api/api.go

@@ -300,6 +300,7 @@ type ProductServer struct {
 	Ram               uint64                  `json:"ram,omitempty"`
 	Baremetal         bool                    `json:"baremetal,omitempty"`
 	VolumesConstraint ProductVolumeConstraint `json:"volumes_constraint,omitempty"`
+	AltNames          []string                `json:"alt_names,omitempty"`
 	Network           ProductNetwork          `json:"network,omitempty"`
 }
 

pkg/api/helpers.go

@@ -7,6 +7,7 @@ package api
 import (
 	"errors"
 	"fmt"
+	"math"
 	"os"
 	"sort"
 	"strings"
@@ -94,6 +95,36 @@ func CreateVolumeFromHumanSize(api *ScalewayAPI, size string) (*string, error) {
 	return &volumeID, nil
 }
 
+// VolumesFromSize returns a string of standard sized volumes from a given size
+func VolumesFromSize(size uint64) string {
+	const DefaultVolumeSize float64 = 50000000000
+	StdVolumeSizes := []struct {
+		kind     string
+		capacity float64
+	}{
+		{"150G", 150000000000},
+		{"100G", 100000000000},
+		{"50G", 50000000000},
+	}
+
+	RequiredSize := float64(size) - DefaultVolumeSize
+	Volumes := ""
+	for _, v := range StdVolumeSizes {
+		q := RequiredSize / v.capacity
+		r := math.Mod(RequiredSize, v.capacity)
+		RequiredSize = r
+
+		if q > 0 {
+			Volumes += strings.Repeat(v.kind+" ", int(q))
+		}
+		if r == 0 {
+			break
+		}
+	}
+
+	return strings.TrimSpace(Volumes)
+}
+
 // fillIdentifierCache fills the cache by fetching from the API
 func fillIdentifierCache(api *ScalewayAPI, identifierType int) {
 	log.Debugf("Filling the cache")
@@ -290,6 +321,25 @@ type ConfigCreateServer struct {
 	EnableIPV6        bool
 }
 
+// Return offer from any of the product name or alternate names
+func OfferNameFromName(name string, products *ScalewayProductsServers) (*ProductServer, error) {
+	offer, ok := products.Servers[name]
+	if ok {
+		return &offer, nil
+	}
+
+	for _, v := range products.Servers {
+		for _, alt := range v.AltNames {
+			alt := strings.ToUpper(alt)
+			if alt == name {
+				return &v, nil
+			}
+		}
+	}
+
+	return nil, fmt.Errorf("Unknow commercial type: %v", name)
+}
+
 // CreateServer creates a server using API based on typical server fields
 func CreateServer(api *ScalewayAPI, c *ConfigCreateServer) (string, error) {
 	commercialType := os.Getenv("SCW_COMMERCIAL_TYPE")
@@ -306,7 +356,7 @@ func CreateServer(api *ScalewayAPI, c *ConfigCreateServer) (string, error) {
 
 	var server ScalewayServerDefinition
 
-	server.CommercialType = commercialType
+	server.CommercialType = strings.ToUpper(commercialType)
 	server.Volumes = make(map[string]string)
 	server.DynamicIPRequired = &c.DynamicIPRequired
 	server.EnableIPV6 = c.EnableIPV6
@@ -336,32 +386,19 @@ func CreateServer(api *ScalewayAPI, c *ConfigCreateServer) (string, error) {
 	if c.Env != "" {
 		server.Tags = strings.Split(c.Env, " ")
 	}
-	switch c.CommercialType {
-	case "VC1M", "X64-4GB", "ARM64-4GB":
-		if c.AdditionalVolumes == "" {
-			c.AdditionalVolumes = "50G"
-			log.Debugf("This server needs a least 50G")
-		}
-	case "VC1L", "X64-8GB", "X64-15GB", "ARM64-8GB":
-		if c.AdditionalVolumes == "" {
-			c.AdditionalVolumes = "150G"
-			log.Debugf("This server needs a least 150G")
-		}
-	case "X64-30GB":
-		if c.AdditionalVolumes == "" {
-			c.AdditionalVolumes = "100G 150G"
-			log.Debugf("This server needs a least 300G")
-		}
-	case "X64-60GB":
-		if c.AdditionalVolumes == "" {
-			c.AdditionalVolumes = "50G 150G 150G"
-			log.Debugf("This server needs a least 400G")
-		}
-	case "X64-120GB":
-		if c.AdditionalVolumes == "" {
-			c.AdditionalVolumes = "150G 150G 150G"
-			log.Debugf("This server needs a least 500G")
-		}
+
+	products, err := api.GetProductsServers()
+	if err != nil {
+		return "", fmt.Errorf("Unable to fetch products list from the Scaleway API: %v", err)
+	}
+	offer, err := OfferNameFromName(server.CommercialType, products)
+	if err != nil {
+		return "", fmt.Errorf("Unknow commercial type %v: %v", server.CommercialType, err)
+	}
+	if offer.VolumesConstraint.MinSize > 0 && c.AdditionalVolumes == "" {
+		c.AdditionalVolumes = VolumesFromSize(offer.VolumesConstraint.MinSize)
+		log.Debugf("%s needs at least %s. Automatically creates the following volumes: %s",
+			server.CommercialType, humanize.Bytes(offer.VolumesConstraint.MinSize), c.AdditionalVolumes)
 	}
 	if c.AdditionalVolumes != "" {
 		volumes := strings.Split(c.AdditionalVolumes, " ")
@@ -375,9 +412,9 @@ func CreateServer(api *ScalewayAPI, c *ConfigCreateServer) (string, error) {
 			server.Volumes[volumeIDx] = *volumeID
 		}
 	}
+
 	arch := os.Getenv("SCW_TARGET_ARCH")
 	if arch == "" {
-		server.CommercialType = strings.ToUpper(server.CommercialType)
 		switch server.CommercialType[:2] {
 		case "C1":
 			arch = "arm"
@@ -394,7 +431,7 @@ func CreateServer(api *ScalewayAPI, c *ConfigCreateServer) (string, error) {
 	}
 	server.Name = c.Name
 	inheritingVolume := false
-	_, err := humanize.ParseBytes(c.ImageName)
+	_, err = humanize.ParseBytes(c.ImageName)
 	if err == nil {
 		// Create a new root volume
 		volumeID, errCreateVol := CreateVolumeFromHumanSize(api, c.ImageName)