Add an os-disk constraint

constraints/constraints.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package constraints
 
 import (
         "fmt"
         "math"
         "strconv"
         "strings"
@@ skipping 20 matching lines @@
 
         // CpuPower, if not nil, indicates that a machine must have at least that
         // amount of CPU power available, where 100 CpuPower is considered to be
         // equivalent to 1 Amazon ECU (or, roughly, a single 2007-era Xeon).
         CpuPower *uint64 `json:"cpu-power,omitempty" yaml:"cpu-power,omitempty"`
 
         // Mem, if not nil, indicates that a machine must have at least that many
         // megabytes of RAM.
         Mem *uint64 `json:"mem,omitempty" yaml:"mem,omitempty"`
 
-        // OsDisk, if not nil, indicates that a machine must have at least that
-        // amount of disk space available in the OS disk, aka root
-        // partition. In providers where the OS disk is configurable at
-        // instance startup time, an instance with the specified amount of disk
-        // space in the OS disk will be requested.
-        OsDisk *uint64 `json:"os-disk,omitempty" yaml:"os-disk,omitempty"`

[fwereade, 2013/08/13 17:27:00]

I'm not sure about the name. InstanceDisk, or LocalDisk, perhaps? There are
several EC2 instance types without instance storage.

[sidnei.da.silva, 2013/08/13 18:00:56]

As explained in the bug comments, this constraint about the 'OS Disk', a.k.a.
root disk, which all instance types have regardless of being instance-storage or
ebs. 

Since we default to ebs, we can actually start an instance that matches the
specified constraint regardless of the picked up instance type, as long as we
pass the proper block device mapping to the run instances api call.

+        // RootDisk, if not nil, indicates that a machine must have at least
+        // that many megabytes of disk space available in the root disk. In
+        // providers where the root disk is configurable at instance startup
+        // time, an instance with the specified amount of disk space in the OS
+        // disk might be requested.
+        RootDisk *uint64 `json:"root-disk,omitempty" yaml:"root-disk,omitempty"`
 }
 
 // String expresses a constraints.Value in the language in which it was specified.
 func (v Value) String() string {
         var strs []string
         if v.Arch != nil {
                 strs = append(strs, "arch="+*v.Arch)
         }
         if v.Container != nil {
                 strs = append(strs, "container="+string(*v.Container))
         }
         if v.CpuCores != nil {
                 strs = append(strs, "cpu-cores="+uintStr(*v.CpuCores))
         }
         if v.CpuPower != nil {
                 strs = append(strs, "cpu-power="+uintStr(*v.CpuPower))
         }
         if v.Mem != nil {
                 s := uintStr(*v.Mem)
                 if s != "" {
                         s += "M"
                 }
                 strs = append(strs, "mem="+s)
         }
-        if v.OsDisk != nil {
-                s := uintStr(*v.OsDisk)
+        if v.RootDisk != nil {
+                s := uintStr(*v.RootDisk)
                 if s != "" {
                         s += "M"
                 }
-                strs = append(strs, "os-disk="+s)
+                strs = append(strs, "root-disk="+s)
         }
         return strings.Join(strs, " ")
 }
 
 // WithFallbacks returns a copy of v with nil values taken from v0.
 func (v Value) WithFallbacks(v0 Value) Value {
         v1 := v0
         if v.Arch != nil {
                 v1.Arch = v.Arch
         }
         if v.Container != nil {
                 v1.Container = v.Container
         }
         if v.CpuCores != nil {
                 v1.CpuCores = v.CpuCores
         }
         if v.CpuPower != nil {
                 v1.CpuPower = v.CpuPower
         }
         if v.Mem != nil {
                 v1.Mem = v.Mem
         }
-        if v.OsDisk != nil {
-                v1.OsDisk = v.OsDisk
+        if v.RootDisk != nil {
+                v1.RootDisk = v.RootDisk
         }
         return v1
 }
 
 func uintStr(i uint64) string {
         if i == 0 {
                 return ""
         }
         return fmt.Sprintf("%d", i)
 }
@@ skipping 57 matching lines @@
         case "arch":
                 err = v.setArch(str)
         case "container":
                 err = v.setContainer(str)
         case "cpu-cores":
                 err = v.setCpuCores(str)
         case "cpu-power":
                 err = v.setCpuPower(str)
         case "mem":
                 err = v.setMem(str)
-        case "os-disk":
-                err = v.setOsDisk(str)
+        case "root-disk":
+                err = v.setRootDisk(str)
         default:
                 return fmt.Errorf("unknown constraint %q", name)
         }
         if err != nil {
                 return fmt.Errorf("bad %q constraint: %v", name, err)
         }
         return nil
 }
 
 // SetYAML is required to unmarshall a constraints.Value object
@@ skipping 11 matching lines @@
                         v.Arch = &vstr
                 case "container":
                         ctype := instance.ContainerType(vstr)
                         v.Container = &ctype
                 case "cpu-cores":
                         v.CpuCores, err = parseUint64(vstr)
                 case "cpu-power":
                         v.CpuPower, err = parseUint64(vstr)
                 case "mem":
                         v.Mem, err = parseUint64(vstr)
-                case "os-disk":
-                        v.OsDisk, err = parseUint64(vstr)
+                case "root-disk":
+                        v.RootDisk, err = parseUint64(vstr)
                 default:
                         return false
                 }
                 if err != nil {
                         return false
                 }
         }
         return true
 }
 
@@ skipping 42 matching lines @@
 }
 
 func (v *Value) setCpuPower(str string) (err error) {
         if v.CpuPower != nil {
                 return fmt.Errorf("already set")
         }
         v.CpuPower, err = parseUint64(str)
         return
 }
 
-func (v *Value) setMem(str string) error {
+func (v *Value) setMem(str string) (err error) {
         if v.Mem != nil {
                 return fmt.Errorf("already set")
         }
-        var value uint64
-        if str != "" {
-                mult := 1.0
-                if m, ok := mbSuffixes[str[len(str)-1:]]; ok {
-                        str = str[:len(str)-1]
-                        mult = m
-                }
-                val, err := strconv.ParseFloat(str, 64)
-                if err != nil || val < 0 {
-                        return fmt.Errorf("must be a non-negative float with optional M/G/T/P suffix")
-                }
-                val *= mult
-                value = uint64(math.Ceil(val))
-        }
-        v.Mem = &value
-        return nil
-}
-
-func (v *Value) setOsDisk(str string) error {
-        if v.OsDisk != nil {
-                return fmt.Errorf("already set")
-        }
-        var value uint64
-        if str != "" {
-                mult := 1.0
-                if m, ok := mbSuffixes[str[len(str)-1:]]; ok {
-                        str = str[:len(str)-1]
-                        mult = m
-                }
-                val, err := strconv.ParseFloat(str, 64)
-                if err != nil || val < 0 {
-                        return fmt.Errorf("must be a non-negative float with optional M/G/T/P suffix")
-                }
-                val *= mult
-                value = uint64(math.Ceil(val))
-        }

[fwereade, 2013/08/13 17:27:00]

Please pull this block out into a common function, it's non-trivial and a
precise duplicate of the code in setMem.

[sidnei.da.silva, 2013/08/13 18:00:56]

Done.

-        v.OsDisk = &value
-        return nil
+        v.Mem, err = parseSize(str)
+        return
+}
+
+func (v *Value) setRootDisk(str string) (err error) {
+        if v.RootDisk != nil {
+                return fmt.Errorf("already set")
+        }
+        v.RootDisk, err = parseSize(str)
+        return
 }
 
 func parseUint64(str string) (*uint64, error) {
         var value uint64
         if str != "" {
                 if val, err := strconv.ParseUint(str, 10, 64); err != nil {
                         return nil, fmt.Errorf("must be a non-negative integer")
                 } else {
                         value = uint64(val)
                 }
         }
         return &value, nil
 }
 
+func parseSize(str string) (*uint64, error) {
+        var value uint64
+        if str != "" {
+                mult := 1.0
+                if m, ok := mbSuffixes[str[len(str)-1:]]; ok {
+                        str = str[:len(str)-1]
+                        mult = m
+                }
+                val, err := strconv.ParseFloat(str, 64)
+                if err != nil || val < 0 {
+                        return nil, fmt.Errorf("must be a non-negative float with optional M/G/T/P suffix")
+                }
+                val *= mult
+                value = uint64(math.Ceil(val))
+        }
+        return &value, nil
+}
+
 var mbSuffixes = map[string]float64{
         "M": 1,
         "G": 1024,
         "T": 1024 * 1024,
         "P": 1024 * 1024 * 1024,
 }