// 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, os jujuos.OSType) ([]google.DiskSpec, error) {
size := common.MinRootDiskSizeGiB
if cons.RootDisk != nil && *cons.RootDisk > size {
size = common.MiBToGiB(*cons.RootDisk)
}
var imageURL string
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{
SizeHintGB: size,
ImageURL: imageURL + spec.Image.Id,
Boot: true,
AutoDelete: true,
}
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)
}
return []google.DiskSpec{dSpec}, nil
}
func (VsphereRenderer) EncodeUserdata(udata []byte, os jujuos.OSType) ([]byte, error) {
switch os {
case jujuos.Ubuntu, jujuos.CentOS:
return renderers.ToBase64(udata), nil
default:
return nil, errors.Errorf("Cannot encode userdata for OS: %s", os.String())
}
}
func (CloudSigmaRenderer) Render(cfg cloudinit.CloudConfig, os jujuos.OSType) ([]byte, error) {
switch os {
case jujuos.Ubuntu, jujuos.CentOS:
return renderers.RenderYAML(cfg, renderers.ToBase64)
default:
return nil, errors.Errorf("Cannot encode userdata for OS: %s", os.String())
}
}
func (OpenstackRenderer) EncodeUserdata(udata []byte, os jujuos.OSType) ([]byte, error) {
switch os {
case jujuos.Ubuntu, jujuos.CentOS:
return utils.Gzip(udata), nil
case jujuos.Windows:
return renderers.WinEmbedInScript(udata), nil
default:
return nil, errors.Errorf("Cannot encode userdata for OS: %s", os.String())
}
}
func (MAASRenderer) Render(cfg cloudinit.CloudConfig, os jujuos.OSType) ([]byte, error) {
switch os {
case jujuos.Ubuntu, jujuos.CentOS:
return renderers.RenderYAML(cfg, utils.Gzip, renderers.ToBase64)
case jujuos.Windows:
return renderers.RenderYAML(cfg, renderers.WinEmbedInScript, renderers.ToBase64)
default:
return nil, errors.Errorf("Cannot encode userdata for OS: %s", os.String())
}
}
// getMetadata builds the raw "user-defined" metadata for the new
// instance (relative to the provided args) and returns it.
func getMetadata(args environs.StartInstanceParams, os jujuos.OSType) (map[string]string, error) {
userData, err := providerinit.ComposeUserData(args.InstanceConfig, nil, GCERenderer{})
if err != nil {
return nil, errors.Annotate(err, "cannot make user data")
}
logger.Debugf("GCE user data; %d bytes", len(userData))
metadata := make(map[string]string)
if isController(args.InstanceConfig) {
metadata[metadataKeyIsState] = metadataValueTrue
} else {
metadata[metadataKeyIsState] = metadataValueFalse
}
switch os {
case jujuos.Ubuntu:
// We store a gz snapshop of information that is used by
// cloud-init and unpacked in to the /var/lib/cloud/instances folder
// for the instance. Due to a limitation with GCE and binary blobs
// we base64 encode the data before storing it.
metadata[metadataKeyCloudInit] = string(userData)
// Valid encoding values are determined by the cloudinit GCE data source.
// See: http://cloudinit.readthedocs.org
metadata[metadataKeyEncoding] = "base64"
authKeys, err := google.FormatAuthorizedKeys(args.InstanceConfig.AuthorizedKeys, "ubuntu")
if err != nil {
return nil, errors.Trace(err)
}
metadata[metadataKeySSHKeys] = authKeys
case jujuos.Windows:
metadata[metadataKeyWindowsUserdata] = string(userData)
validChars := append(utils.UpperAlpha, append(utils.LowerAlpha, utils.Digits...)...)
// The hostname must have maximum 15 characters
winHostname := "juju" + utils.RandomString(11, validChars)
metadata[metadataKeyWindowsSysprep] = fmt.Sprintf(winSetHostnameScript, winHostname)
default:
return nil, errors.Errorf("cannot pack metadata for os %s on the gce provider", os.String())
}
return metadata, nil
}
