// getDisks builds the raw spec for the disks that should be attached to
// the new instances and returns it. This will always include a root
// disk with characteristics determined by the provides args and
// constraints.
func getDisks(spec *instances.InstanceSpec, cons constraints.Value, ser, eUUID string) ([]google.DiskSpec, error) {
size := common.MinRootDiskSizeGiB(ser)
if cons.RootDisk != nil && *cons.RootDisk > size {
size = common.MiBToGiB(*cons.RootDisk)
}
var imageURL string
os, err := series.GetOSFromSeries(ser)
if err != nil {
return nil, errors.Trace(err)
}
switch os {
case jujuos.Ubuntu:
imageURL = ubuntuImageBasePath
case jujuos.Windows:
imageURL = windowsImageBasePath
default:
return nil, errors.Errorf("os %s is not supported on the gce provider", os.String())
}
dSpec := google.DiskSpec{
Series: ser,
SizeHintGB: size,
ImageURL: imageURL + spec.Image.Id,
Boot: true,
AutoDelete: true,
Description: eUUID,
}
if cons.RootDisk != nil && dSpec.TooSmall() {
msg := "Ignoring root-disk constraint of %dM because it is smaller than the GCE image size of %dG"
logger.Infof(msg, *cons.RootDisk, google.MinDiskSizeGB(ser))
}
return []google.DiskSpec{dSpec}, nil
}
func (s *environBrokerSuite) TestStartInstanceDefaultDiskSizeIsUsedForSmallConstraintValue(c *gc.C) {
s.PrepareStartInstanceFakes(c)
startInstArgs := s.CreateStartInstanceArgs(c)
rootDisk := uint64(1000)
startInstArgs.Constraints.RootDisk = &rootDisk
res, err := s.Env.StartInstance(startInstArgs)
c.Assert(err, jc.ErrorIsNil)
c.Assert(*res.Hardware.RootDisk, gc.Equals, common.MinRootDiskSizeGiB("trusty")*uint64(1024))
}
func (s *environBrokerSuite) TestStartInstanceDefaultConstraintsApplied(c *gc.C) {
s.PrepareStartInstanceFakes(c)
startInstArgs := s.CreateStartInstanceArgs(c)
res, err := s.Env.StartInstance(startInstArgs)
c.Assert(err, jc.ErrorIsNil)
c.Assert(*res.Hardware.CpuCores, gc.Equals, vsphere.DefaultCpuCores)
c.Assert(*res.Hardware.CpuPower, gc.Equals, vsphere.DefaultCpuPower)
c.Assert(*res.Hardware.Mem, gc.Equals, vsphere.DefaultMemMb)
c.Assert(*res.Hardware.RootDisk, gc.Equals, common.MinRootDiskSizeGiB("trusty")*uint64(1024))
}
func (s *DiskSuite) TestMinRootDiskSizeGiB(c *gc.C) {
var diskTests = []struct {
series string
expectedSize uint64
}{
{"trusty", 8},
{"win2012r2", 40},
{"centos7", 8},
{"fake-series", 8},
}
for _, t := range diskTests {
actualSize := common.MinRootDiskSizeGiB(t.series)
c.Assert(t.expectedSize, gc.Equals, actualSize)
}
}
func minRootDiskSizeMiB(ser string) uint64 {
return gibToMib(common.MinRootDiskSizeGiB(ser))
}
// newRawInstance is where the new physical instance is actually
// provisioned, relative to the provided args and spec. Info for that
// low-level instance is returned.
func (env *environ) newRawInstance(args environs.StartInstanceParams, img *OvaFileMetadata) (*mo.VirtualMachine, *instance.HardwareCharacteristics, error) {
machineID, err := env.namespace.Hostname(args.InstanceConfig.MachineId)
if err != nil {
return nil, nil, errors.Trace(err)
}
cloudcfg, err := cloudinit.New(args.Tools.OneSeries())
if err != nil {
return nil, nil, errors.Trace(err)
}
cloudcfg.AddPackage("open-vm-tools")
cloudcfg.AddPackage("iptables-persistent")
userData, err := providerinit.ComposeUserData(args.InstanceConfig, cloudcfg, VsphereRenderer{})
if err != nil {
return nil, nil, errors.Annotate(err, "cannot make user data")
}
logger.Debugf("Vmware user data; %d bytes", len(userData))
rootDisk := common.MinRootDiskSizeGiB(args.InstanceConfig.Series) * 1024
if args.Constraints.RootDisk != nil && *args.Constraints.RootDisk > rootDisk {
rootDisk = *args.Constraints.RootDisk
}
cpuCores := DefaultCpuCores
if args.Constraints.CpuCores != nil {
cpuCores = *args.Constraints.CpuCores
}
cpuPower := DefaultCpuPower
if args.Constraints.CpuPower != nil {
cpuPower = *args.Constraints.CpuPower
}
mem := DefaultMemMb
if args.Constraints.Mem != nil {
mem = *args.Constraints.Mem
}
hwc := &instance.HardwareCharacteristics{
Arch: &img.Arch,
Mem: &mem,
CpuCores: &cpuCores,
CpuPower: &cpuPower,
RootDisk: &rootDisk,
}
zones, err := env.parseAvailabilityZones(args)
if err != nil {
return nil, nil, errors.Trace(err)
}
var inst *mo.VirtualMachine
for _, zone := range zones {
var availZone *vmwareAvailZone
availZone, err = env.availZone(zone)
if err != nil {
logger.Warningf("Error while getting availability zone %s: %s", zone, err)
continue
}
apiPort := 0
if args.InstanceConfig.Controller != nil {
apiPort = args.InstanceConfig.Controller.Config.APIPort()
}
spec := &instanceSpec{
machineID: machineID,
zone: availZone,
hwc: hwc,
img: img,
userData: userData,
sshKey: args.InstanceConfig.AuthorizedKeys,
isController: args.InstanceConfig.Controller != nil,
controllerUUID: args.ControllerUUID,
apiPort: apiPort,
}
inst, err = env.client.CreateInstance(env.ecfg, spec)
if err != nil {
logger.Warningf("Error while trying to create instance in %s availability zone: %s", zone, err)
continue
}
break
}
if err != nil {
return nil, nil, errors.Annotate(err, "Can't create instance in any of availability zones, last error")
}
return inst, hwc, err
}