// getMetadata builds the raw "user-defined" metadata for the new
// instance (relative to the provided args) and returns it.
func getMetadata(args environs.StartInstanceParams) (map[string]string, error) {
userData, err := providerinit.ComposeUserData(args.InstanceConfig, nil)
if err != nil {
return nil, errors.Annotate(err, "cannot make user data")
}
logger.Debugf("GCE user data; %d bytes", len(userData))
authKeys, err := google.FormatAuthorizedKeys(args.InstanceConfig.AuthorizedKeys, "ubuntu")
if err != nil {
return nil, errors.Trace(err)
}
b64UserData := base64.StdEncoding.EncodeToString([]byte(userData))
metadata := map[string]string{
metadataKeyIsState: metadataValueFalse,
// 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.
metadataKeyCloudInit: b64UserData,
// Valid encoding values are determined by the cloudinit GCE data source.
// See: http://cloudinit.readthedocs.org
metadataKeyEncoding: "base64",
metadataKeySSHKeys: authKeys,
}
if isStateServer(args.InstanceConfig) {
metadata[metadataKeyIsState] = metadataValueTrue
}
return metadata, nil
}
func (s *BaseSuiteUnpatched) initInst(c *gc.C) {
tools := []*tools.Tools{{
Version: version.Binary{Arch: arch.AMD64, Series: "trusty"},
URL: "https://example.org",
}}
cons := constraints.Value{InstanceType: &allInstanceTypes[0].Name}
instanceConfig, err := instancecfg.NewBootstrapInstanceConfig(cons, cons, "trusty", "")
c.Assert(err, jc.ErrorIsNil)
instanceConfig.Tools = tools[0]
instanceConfig.AuthorizedKeys = s.Config.AuthorizedKeys()
userData, err := providerinit.ComposeUserData(instanceConfig, nil, GCERenderer{})
c.Assert(err, jc.ErrorIsNil)
authKeys, err := google.FormatAuthorizedKeys(instanceConfig.AuthorizedKeys, "ubuntu")
c.Assert(err, jc.ErrorIsNil)
s.UbuntuMetadata = map[string]string{
metadataKeyIsState: metadataValueTrue,
metadataKeyCloudInit: string(userData),
metadataKeyEncoding: "base64",
metadataKeySSHKeys: authKeys,
}
s.WindowsMetadata = map[string]string{
metadataKeyWindowsUserdata: string(userData),
metadataKeyWindowsSysprep: fmt.Sprintf(winSetHostnameScript, "juju.*"),
}
s.Addresses = []network.Address{{
Value: "10.0.0.1",
Type: network.IPv4Address,
Scope: network.ScopeCloudLocal,
}}
s.Instance = s.NewInstance(c, "spam")
s.BaseInstance = s.Instance.base
s.InstName = s.Prefix + "machine-spam"
s.StartInstArgs = environs.StartInstanceParams{
InstanceConfig: instanceConfig,
Tools: tools,
Constraints: cons,
//Placement: "",
//DistributionGroup: nil,
}
s.InstanceType = allInstanceTypes[0]
// Storage
eUUID := s.Env.Config().UUID()
s.BaseDisk = &google.Disk{
Id: 1234567,
Name: "home-zone--c930380d-8337-4bf5-b07a-9dbb5ae771e4",
Zone: "home-zone",
Status: google.StatusReady,
Size: 1024,
Description: eUUID,
}
}
func (s *BaseSuiteUnpatched) initInst(c *gc.C) {
tools := []*tools.Tools{{
Version: version.Binary{Arch: arch.AMD64, Series: "trusty"},
URL: "https://example.org",
}}
cons := constraints.Value{InstanceType: &allInstanceTypes[0].Name}
instanceConfig, err := instancecfg.NewBootstrapInstanceConfig(cons, "trusty")
c.Assert(err, jc.ErrorIsNil)
instanceConfig.Tools = tools[0]
instanceConfig.AuthorizedKeys = s.Config.AuthorizedKeys()
userData, err := providerinit.ComposeUserData(instanceConfig, nil)
c.Assert(err, jc.ErrorIsNil)
b64UserData := base64.StdEncoding.EncodeToString([]byte(userData))
authKeys, err := google.FormatAuthorizedKeys(instanceConfig.AuthorizedKeys, "ubuntu")
c.Assert(err, jc.ErrorIsNil)
s.Metadata = map[string]string{
metadataKeyIsState: metadataValueTrue,
metadataKeyCloudInit: b64UserData,
metadataKeyEncoding: "base64",
metadataKeySSHKeys: authKeys,
}
s.Addresses = []network.Address{{
Value: "10.0.0.1",
Type: network.IPv4Address,
Scope: network.ScopeCloudLocal,
}}
s.Instance = s.NewInstance(c, "spam")
s.BaseInstance = s.Instance.base
s.InstName = s.Prefix + "machine-spam"
s.StartInstArgs = environs.StartInstanceParams{
InstanceConfig: instanceConfig,
Tools: tools,
Constraints: cons,
//Placement: "",
//DistributionGroup: nil,
}
s.InstanceType = allInstanceTypes[0]
}
// 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
}
func (s *instanceSuite) TestFormatAuthorizedKeysMultiple(c *gc.C) {
formatted, err := google.FormatAuthorizedKeys("abcd\ndcba\nqwer", "john")
c.Assert(err, jc.ErrorIsNil)
c.Check(formatted, gc.Equals, "john:abcd\njohn:dcba\njohn:qwer\n")
}
func (s *instanceSuite) TestFormatAuthorizedKeysNoUser(c *gc.C) {
_, err := google.FormatAuthorizedKeys("abcd", "")
c.Check(err, gc.ErrorMatches, "empty user")
}
func (s *instanceSuite) TestFormatAuthorizedKeysEmpty(c *gc.C) {
_, err := google.FormatAuthorizedKeys("", "john")
c.Check(err, gc.ErrorMatches, "empty rawAuthorizedKeys")
}