func (s *UserdataSuite) TestOpenstackUnix(c *gc.C) {
renderer := openstack.OpenstackRenderer{}
cloudcfg := &cloudinittest.CloudConfig{YAML: []byte("yaml")}
result, err := renderer.Render(cloudcfg, os.Ubuntu)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, utils.Gzip(cloudcfg.YAML))
result, err = renderer.Render(cloudcfg, os.CentOS)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, utils.Gzip(cloudcfg.YAML))
}
func (s *UserdataSuite) TestOpenstackUnix(c *gc.C) {
renderer := openstack.OpenstackRenderer{}
data := []byte("test")
result, err := renderer.EncodeUserdata(data, os.Ubuntu)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, utils.Gzip(data))
data = []byte("test")
result, err = renderer.EncodeUserdata(data, os.CentOS)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, utils.Gzip(data))
}
func (s *UserdataSuite) TestGCEUnix(c *gc.C) {
renderer := gce.GCERenderer{}
data := []byte("test")
result, err := renderer.EncodeUserdata(data, os.Ubuntu)
c.Assert(err, jc.ErrorIsNil)
expected := base64.StdEncoding.EncodeToString(utils.Gzip(data))
c.Assert(string(result), jc.DeepEquals, expected)
data = []byte("test")
result, err = renderer.EncodeUserdata(data, os.CentOS)
c.Assert(err, jc.ErrorIsNil)
expected = base64.StdEncoding.EncodeToString(utils.Gzip(data))
c.Assert(string(result), jc.DeepEquals, expected)
}
func (s *UserdataSuite) TestGCEUnix(c *gc.C) {
renderer := gce.GCERenderer{}
cloudcfg := &cloudinittest.CloudConfig{YAML: []byte("yaml")}
result, err := renderer.Render(cloudcfg, os.Ubuntu)
c.Assert(err, jc.ErrorIsNil)
expected := base64.StdEncoding.EncodeToString(utils.Gzip(cloudcfg.YAML))
c.Assert(string(result), jc.DeepEquals, expected)
result, err = renderer.Render(cloudcfg, os.CentOS)
c.Assert(err, jc.ErrorIsNil)
expected = base64.StdEncoding.EncodeToString(utils.Gzip(cloudcfg.YAML))
c.Assert(string(result), jc.DeepEquals, expected)
}
func (s *RenderersSuite) TestWinEmbedInScript(c *gc.C) {
in := []byte("test")
out := string(renderers.WinEmbedInScript(in))
encUserdata := renderers.ToBase64(utils.Gzip(in))
expected := fmt.Sprintf(cloudconfig.UserDataScript, encUserdata)
c.Assert(out, jc.DeepEquals, expected)
}
func (s *CloudInitSuite) TestWindowsUserdataEncoding(c *gc.C) {
series := "win8"
metricsSpoolDir := must(paths.MetricsSpoolDir("win8"))
toolsList := tools.List{
&tools.Tools{
URL: "http://foo.com/tools/released/juju1.2.3-win8-amd64.tgz",
Version: version.MustParseBinary("1.2.3-win8-amd64"),
Size: 10,
SHA256: "1234",
},
}
dataDir, err := paths.DataDir(series)
c.Assert(err, jc.ErrorIsNil)
logDir, err := paths.LogDir(series)
c.Assert(err, jc.ErrorIsNil)
cfg := instancecfg.InstanceConfig{
ControllerTag: testing.ControllerTag,
MachineId: "10",
AgentEnvironment: map[string]string{agent.ProviderType: "dummy"},
Series: series,
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
MachineNonce: "FAKE_NONCE",
APIInfo: &api.Info{
Addrs: []string{"state-addr.testing.invalid:54321"},
Password: "******",
CACert: "CA CERT\n" + testing.CACert,
Tag: names.NewMachineTag("10"),
ModelTag: testing.ModelTag,
},
MachineAgentServiceName: "jujud-machine-10",
DataDir: dataDir,
LogDir: path.Join(logDir, "juju"),
MetricsSpoolDir: metricsSpoolDir,
CloudInitOutputLog: path.Join(logDir, "cloud-init-output.log"),
}
err = cfg.SetTools(toolsList)
c.Assert(err, jc.ErrorIsNil)
ci, err := cloudinit.New("win8")
c.Assert(err, jc.ErrorIsNil)
udata, err := cloudconfig.NewUserdataConfig(&cfg, ci)
c.Assert(err, jc.ErrorIsNil)
err = udata.Configure()
c.Assert(err, jc.ErrorIsNil)
data, err := ci.RenderYAML()
c.Assert(err, jc.ErrorIsNil)
cicompose, err := cloudinit.New("win8")
c.Assert(err, jc.ErrorIsNil)
base64Data := base64.StdEncoding.EncodeToString(utils.Gzip(data))
got := []byte(fmt.Sprintf(cloudconfig.UserDataScript, base64Data))
expected, err := providerinit.ComposeUserData(&cfg, cicompose, openstack.OpenstackRenderer{})
c.Assert(err, jc.ErrorIsNil)
c.Assert(string(got), gc.Equals, string(expected))
}
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 (AzureRenderer) EncodeUserdata(udata []byte, vers os.OSType) ([]byte, error) {
switch vers {
case os.Ubuntu, os.CentOS:
return renderers.ToBase64(utils.Gzip(udata)), nil
case os.Windows:
return renderers.ToBase64(renderers.WinEmbedInScript(udata)), nil
default:
return nil, errors.Errorf("Cannot encode userdata for OS: %s", vers)
}
}
// ComposeUserData fills out the provided cloudinit configuration structure
// so it is suitable for initialising a machine with the given configuration,
// and then renders it and returns it as a binary (gzipped) blob of user data.
//
// If the provided cloudcfg is nil, a new one will be created internally.
func ComposeUserData(mcfg *cloudinit.MachineConfig, cloudcfg *coreCloudinit.Config) ([]byte, error) {
if cloudcfg == nil {
cloudcfg = coreCloudinit.New()
}
if err := configureCloudinit(mcfg, cloudcfg); err != nil {
return nil, err
}
data, err := cloudcfg.Render()
logger.Tracef("Generated cloud init:\n%s", string(data))
if err != nil {
return nil, err
}
return utils.Gzip(data), nil
}
func (s *clientSuite) TestClientNewInstance(c *gc.C) {
cli, err := testNewClient(c, mock.Endpoint(""), mock.TestUser, mock.TestPassword)
c.Assert(err, gc.IsNil)
cli.conn.OperationTimeout(1 * time.Second)
params := environs.StartInstanceParams{
Constraints: constraints.Value{},
InstanceConfig: &instancecfg.InstanceConfig{
Bootstrap: true,
},
}
err = params.InstanceConfig.SetTools(tools.List{
&tools.Tools{
Version: version.Binary{
Series: "trusty",
},
URL: "https://0.1.2.3:2000/x.y.z.tgz",
},
})
c.Assert(err, jc.ErrorIsNil)
img := &imagemetadata.ImageMetadata{
Id: validImageId,
}
cs := newConstraints(params.InstanceConfig.Bootstrap, params.Constraints, img)
c.Assert(cs, gc.NotNil)
c.Check(err, gc.IsNil)
templateDrive := &data.Drive{
Resource: data.Resource{URI: "uri", UUID: cs.driveTemplate},
LibraryDrive: data.LibraryDrive{
Arch: "64",
ImageType: "image-type",
OS: "os",
Paid: true,
},
Size: 2200 * gosigma.Megabyte,
Status: "unmounted",
}
mock.ResetDrives()
mock.LibDrives.Add(templateDrive)
server, drive, arch, err := cli.newInstance(params, img, utils.Gzip([]byte{}))
c.Check(server, gc.NotNil)
c.Check(drive, gc.NotNil)
c.Check(arch, gc.NotNil)
c.Check(err, gc.IsNil)
}
// ComposeUserData fills out the provided cloudinit configuration structure
// so it is suitable for initialising a machine with the given configuration,
// and then renders it and returns it as a binary (gzipped) blob of user data.
//
// If the provided cloudcfg is nil, a new one will be created internally.
func ComposeUserData(icfg *instancecfg.InstanceConfig, cloudcfg cloudinit.CloudConfig) ([]byte, error) {
if cloudcfg == nil {
var err error
cloudcfg, err = cloudinit.New(icfg.Series)
if err != nil {
return nil, err
}
}
_, err := configureCloudinit(icfg, cloudcfg)
if err != nil {
return nil, err
}
data, err := cloudcfg.RenderYAML()
logger.Tracef("Generated cloud init:\n%s", string(data))
if err != nil {
return nil, err
}
return utils.Gzip(data), nil
}
func (*utilsSuite) TestCompression(c *gc.C) {
data := []byte(strings.Repeat("some data to be compressed\n", 100))
compressedData := []byte{
0x1f, 0x8b, 0x08, 0x00, 0x33, 0xb5, 0xf6, 0x50,
0x00, 0x03, 0xed, 0xc9, 0xb1, 0x0d, 0x00, 0x20,
0x08, 0x45, 0xc1, 0xde, 0x29, 0x58, 0x0d, 0xe5,
0x97, 0x04, 0x23, 0xee, 0x1f, 0xa7, 0xb0, 0x7b,
0xd7, 0x5e, 0x57, 0xca, 0xc2, 0xaf, 0xdb, 0x2d,
0x9b, 0xb2, 0x55, 0xb9, 0x8f, 0xba, 0x15, 0xa3,
0x29, 0x8a, 0xa2, 0x28, 0x8a, 0xa2, 0x28, 0xea,
0x67, 0x3d, 0x71, 0x71, 0x6e, 0xbf, 0x8c, 0x0a,
0x00, 0x00,
}
cdata := utils.Gzip(data)
c.Assert(len(cdata) < len(data), gc.Equals, true)
data1, err := utils.Gunzip(cdata)
c.Assert(err, gc.IsNil)
c.Assert(data1, gc.DeepEquals, data)
data1, err = utils.Gunzip(compressedData)
c.Assert(err, gc.IsNil)
c.Assert(data1, gc.DeepEquals, data)
}
// WinEmbedInScript for now is used on windows and it returns a powershell script
// which has the userdata embedded as base64(gzip(userdata))
func WinEmbedInScript(udata []byte) []byte {
encUserdata := ToBase64(utils.Gzip(udata))
return []byte(fmt.Sprintf(cloudconfig.UserdataScript, encUserdata))
}
// WinEmbedInScript for now is used on windows and it returns a powershell script
// which has the userdata embedded as base64(gzip(userdata))
func WinEmbedInScript(udata []byte) []byte {
encUserdata := ToBase64(utils.Gzip(udata))
// place the encUseData inside the "%s" marked sign
return []byte(fmt.Sprintf(cloudconfig.UserDataScript, encUserdata))
}
