func (s *JujuHomeSuite) TestErrorHome(c *C) {
// Invalid juju home leads to panic when retrieving.
f := func() { _ = config.JujuHome() }
c.Assert(f, PanicMatches, "juju home hasn't been initialized")
f = func() { _ = config.JujuHomePath("environments.yaml") }
c.Assert(f, PanicMatches, "juju home hasn't been initialized")
}
// MakeFakeHomeNoEnvironments creates a new temporary directory through the
// test checker, and overrides the HOME environment variable to point to this
// new temporary directory.
//
// No ~/.juju/environments.yaml exists, but CAKeys are written for each of the
// 'certNames' specified, and the id_rsa.pub file is written to to the .ssh
// dir.
func MakeFakeHomeNoEnvironments(c *C, certNames ...string) *FakeHome {
fake := MakeEmptyFakeHome(c)
for _, name := range certNames {
err := ioutil.WriteFile(config.JujuHomePath(name+"-cert.pem"), []byte(CACert), 0600)
c.Assert(err, IsNil)
err = ioutil.WriteFile(config.JujuHomePath(name+"-private-key.pem"), []byte(CAKey), 0600)
c.Assert(err, IsNil)
}
err := os.Mkdir(HomePath(".ssh"), 0777)
c.Assert(err, IsNil)
err = ioutil.WriteFile(HomePath(".ssh", "id_rsa.pub"), []byte("auth key\n"), 0666)
c.Assert(err, IsNil)
return fake
}
// MakeFakeHome creates a new temporary directory through the test checker,
// and overrides the HOME environment variable to point to this new temporary
// directory.
//
// A new ~/.juju/environments.yaml file is created with the content of the
// `envConfig` parameter, and CAKeys are written for each of the 'certNames'
// specified.
func MakeFakeHome(c *C, envConfig string, certNames ...string) *FakeHome {
fake := MakeFakeHomeNoEnvironments(c, certNames...)
envs := config.JujuHomePath("environments.yaml")
err := ioutil.WriteFile(envs, []byte(envConfig), 0644)
c.Assert(err, IsNil)
return fake
}
func (s *JujuConnSuite) setUpConn(c *C) {
if s.RootDir != "" {
panic("JujuConnSuite.setUpConn without teardown")
}
s.RootDir = c.MkDir()
s.oldHome = os.Getenv("HOME")
home := filepath.Join(s.RootDir, "/home/ubuntu")
err := os.MkdirAll(home, 0777)
c.Assert(err, IsNil)
os.Setenv("HOME", home)
dataDir := filepath.Join(s.RootDir, "/var/lib/juju")
err = os.MkdirAll(dataDir, 0777)
c.Assert(err, IsNil)
yaml := []byte(fmt.Sprintf(envConfig, version.Current.Number))
err = ioutil.WriteFile(config.JujuHomePath("environments.yaml"), yaml, 0600)
c.Assert(err, IsNil)
err = ioutil.WriteFile(config.JujuHomePath("dummyenv-cert.pem"), []byte(testing.CACert), 0666)
c.Assert(err, IsNil)
err = ioutil.WriteFile(config.JujuHomePath("dummyenv-private-key.pem"), []byte(testing.CAKey), 0600)
c.Assert(err, IsNil)
environ, err := environs.NewFromName("dummyenv")
c.Assert(err, IsNil)
// sanity check we've got the correct environment.
c.Assert(environ.Name(), Equals, "dummyenv")
c.Assert(environs.Bootstrap(environ, constraints.Value{}), IsNil)
s.BackingState = environ.(GetStater).GetStateInAPIServer()
conn, err := juju.NewConn(environ)
c.Assert(err, IsNil)
s.Conn = conn
s.State = conn.State
apiConn, err := juju.NewAPIConn(environ, api.DialOpts{})
c.Assert(err, IsNil)
s.APIConn = apiConn
s.APIState = apiConn.State
s.environ = environ
}
// WriteConfig writes a juju config file to the "home" directory.
func (s *JujuConnSuite) WriteConfig(configData string) {
if s.RootDir == "" {
panic("SetUpTest has not been called; will not overwrite $JUJU_HOME/environments.yaml")
}
path := config.JujuHomePath("environments.yaml")
err := ioutil.WriteFile(path, []byte(configData), 0600)
if err != nil {
panic(err)
}
}
// ensureCertOwner checks to make sure that the cert files created
// by the bootstrap command are owned by the user and not root.
func (env *localEnviron) ensureCertOwner() error {
files := []string{
config.JujuHomePath(env.name + "-cert.pem"),
config.JujuHomePath(env.name + "-private-key.pem"),
}
uid, gid, err := sudoCallerIds()
if err != nil {
return err
}
if uid != 0 || gid != 0 {
for _, filename := range files {
if err := os.Chown(filename, uid, gid); err != nil {
return err
}
}
}
return nil
}
func (s *ValidateMetadataSuite) TestEc2LocalMetadataUsingEnvironment(c *gc.C) {
s.setupEc2LocalMetadata(c, "us-east-1")
ctx := coretesting.Context(c)
metadataDir := config.JujuHomePath("")
code := cmd.Main(
&ValidateImageMetadataCommand{}, ctx, []string{"-e", "ec2", "-d", metadataDir},
)
c.Assert(code, gc.Equals, 0)
errOut := ctx.Stdout.(*bytes.Buffer).String()
strippedOut := strings.Replace(errOut, "\n", "", -1)
c.Check(strippedOut, gc.Matches, `matching image ids for region "us-east-1":.*`)
}
func (*EnvironsCertSuite) TestWriteCertAndKey(c *C) {
defer testing.MakeEmptyFakeHome(c).Restore()
// Ensure that the juju home path is different
// from $HOME/.juju to check that WriteCertAndKey
// isn't just using $HOME.
config.SetJujuHome(c.MkDir())
cert, key := []byte("a cert"), []byte("a key")
err := environs.WriteCertAndKey("foo", cert, key)
c.Assert(err, IsNil)
// Check that the generated CA key has been written correctly.
caCertPEM, err := ioutil.ReadFile(config.JujuHomePath("foo-cert.pem"))
c.Assert(err, IsNil)
c.Assert(caCertPEM, DeepEquals, cert)
caKeyPEM, err := ioutil.ReadFile(config.JujuHomePath("foo-private-key.pem"))
c.Assert(err, IsNil)
c.Assert(caKeyPEM, DeepEquals, key)
}
func writeJsonFile(imparams imageMetadataParams, filename, boilerplate string) error {
t := template.Must(template.New("").Parse(boilerplate))
var metadata bytes.Buffer
if err := t.Execute(&metadata, imparams); err != nil {
panic(fmt.Errorf("cannot generate %s metdata: %v", filename, err))
}
data := metadata.Bytes()
path := config.JujuHomePath(filename)
if err := ioutil.WriteFile(path, data, 0666); err != nil {
return err
}
return nil
}
func (s *ValidateSuite) TestNoMatch(c *gc.C) {
s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url")
metadataDir := config.JujuHomePath("")
params := &MetadataLookupParams{
Region: "region-2",
Series: "precise",
Architectures: []string{"amd64"},
Endpoint: "some-auth-url",
BaseURLs: []string{"file://" + metadataDir},
}
_, err := ValidateImageMetadata(params)
c.Assert(err, gc.Not(gc.IsNil))
}
func (s *ValidateMetadataSuite) TestEc2LocalMetadataWithManualParams(c *gc.C) {
s.setupEc2LocalMetadata(c, "us-west-1")
ctx := coretesting.Context(c)
metadataDir := config.JujuHomePath("")
code := cmd.Main(
&ValidateImageMetadataCommand{}, ctx, []string{
"-p", "ec2", "-s", "precise", "-r", "us-west-1",
"-u", "https://ec2.us-west-1.amazonaws.com", "-d", metadataDir},
)
c.Assert(code, gc.Equals, 0)
errOut := ctx.Stdout.(*bytes.Buffer).String()
strippedOut := strings.Replace(errOut, "\n", "", -1)
c.Check(strippedOut, gc.Matches, `matching image ids for region "us-west-1":.*`)
}
func (s *ValidateMetadataSuite) TestOpenstackLocalMetadataWithManualParams(c *gc.C) {
s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url")
ctx := coretesting.Context(c)
metadataDir := config.JujuHomePath("")
code := cmd.Main(
&ValidateImageMetadataCommand{}, ctx, []string{
"-p", "openstack", "-s", "raring", "-r", "region-2",
"-u", "some-auth-url", "-d", metadataDir},
)
c.Assert(code, gc.Equals, 0)
errOut := ctx.Stdout.(*bytes.Buffer).String()
strippedOut := strings.Replace(errOut, "\n", "", -1)
c.Check(strippedOut, gc.Matches, `matching image ids for region "region-2":.*`)
}
func (s *ValidateMetadataSuite) TestEc2LocalMetadataNoMatch(c *gc.C) {
s.setupEc2LocalMetadata(c, "us-east-1")
ctx := coretesting.Context(c)
metadataDir := config.JujuHomePath("")
code := cmd.Main(
&ValidateImageMetadataCommand{}, ctx, []string{
"-p", "ec2", "-s", "raring", "-r", "us-west-1",
"-u", "https://ec2.us-west-1.amazonaws.com", "-d", metadataDir},
)
c.Assert(code, gc.Equals, 1)
code = cmd.Main(
&ValidateImageMetadataCommand{}, ctx, []string{
"-p", "ec2", "-s", "precise", "-r", "region",
"-u", "https://ec2.region.amazonaws.com", "-d", metadataDir},
)
c.Assert(code, gc.Equals, 1)
}
func (s *ValidateMetadataSuite) TestOpenstackLocalMetadataNoMatch(c *gc.C) {
s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url")
ctx := coretesting.Context(c)
metadataDir := config.JujuHomePath("")
code := cmd.Main(
&ValidateImageMetadataCommand{}, ctx, []string{
"-p", "openstack", "-s", "precise", "-r", "region-2",
"-u", "some-auth-url", "-d", metadataDir},
)
c.Assert(code, gc.Equals, 1)
code = cmd.Main(
&ValidateImageMetadataCommand{}, ctx, []string{
"-p", "openstack", "-s", "raring", "-r", "region-3",
"-u", "some-auth-url", "-d", metadataDir},
)
c.Assert(code, gc.Equals, 1)
}
// MakeBoilerplate exists so it can be called by tests. See Boilerplate above. It provides an option to retain
// the streams directories when writing the generated metadata files.
func MakeBoilerplate(name, series string, im *ImageMetadata, cloudSpec *CloudSpec, flattenPath bool) ([]string, error) {
indexFileName := defaultIndexFileName
imageFileName := defaultImageFileName
if name != "" {
indexFileName = fmt.Sprintf("%s-%s", name, indexFileName)
imageFileName = fmt.Sprintf("%s-%s", name, imageFileName)
}
now := time.Now()
imparams := imageMetadataParams{
Id: im.Id,
Arch: im.Arch,
Region: cloudSpec.Region,
URL: cloudSpec.Endpoint,
Path: streamsDir,
ImageFileName: imageFileName,
Updated: now.Format(time.RFC1123Z),
VersionKey: now.Format("20060102"),
}
var err error
imparams.Version, err = seriesVersion(series)
if err != nil {
return nil, fmt.Errorf("invalid series %q", series)
}
if !flattenPath {
streamsPath := config.JujuHomePath(streamsDir)
if err = os.MkdirAll(streamsPath, 0755); err != nil {
return nil, err
}
indexFileName = filepath.Join(streamsDir, indexFileName)
imageFileName = filepath.Join(streamsDir, imageFileName)
}
err = writeJsonFile(imparams, indexFileName, indexBoilerplate)
if err != nil {
return nil, err
}
err = writeJsonFile(imparams, imageFileName, productBoilerplate)
if err != nil {
return nil, err
}
return []string{indexFileName, imageFileName}, nil
}
// Validate implements environs.EnvironProvider.Validate.
func (provider environProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {
// Check for valid changes for the base config values.
if err := config.Validate(cfg, old); err != nil {
return nil, err
}
validated, err := cfg.ValidateUnknownAttrs(configFields, configDefaults)
if err != nil {
return nil, err
}
localConfig := newEnvironConfig(cfg, validated)
// Before potentially creating directories, make sure that the
// root directory has not changed.
if old != nil {
oldLocalConfig, err := provider.newConfig(old)
if err != nil {
return nil, fmt.Errorf("old config is not a valid local config: %v", old)
}
if localConfig.rootDir() != oldLocalConfig.rootDir() {
return nil, fmt.Errorf("cannot change root-dir from %q to %q",
oldLocalConfig.rootDir(),
localConfig.rootDir())
}
if localConfig.storagePort() != oldLocalConfig.storagePort() {
return nil, fmt.Errorf("cannot change storage-port from %v to %v",
oldLocalConfig.storagePort(),
localConfig.storagePort())
}
if localConfig.sharedStoragePort() != oldLocalConfig.sharedStoragePort() {
return nil, fmt.Errorf("cannot change shared-storage-port from %v to %v",
oldLocalConfig.sharedStoragePort(),
localConfig.sharedStoragePort())
}
}
dir := utils.NormalizePath(localConfig.rootDir())
if dir == "." {
dir = config.JujuHomePath(cfg.Name())
localConfig.attrs["root-dir"] = dir
}
// Apply the coerced unknown values back into the config.
return cfg.Apply(localConfig.attrs)
}
// breakJuju writes a dummy environment with incomplete configuration.
// environMethod is called.
func breakJuju(c *C, environMethod string) (msg string) {
path := config.JujuHomePath("environments.yaml")
err := ioutil.WriteFile(path, []byte(brokenConfig), 0666)
c.Assert(err, IsNil)
return fmt.Sprintf("environment configuration has no admin-secret")
}
func environsPath(path string) string {
if path == "" {
path = config.JujuHomePath("environments.yaml")
}
return path
}
func (s *JujuHomeSuite) TestHomePath(c *C) {
testJujuHome := c.MkDir()
defer config.SetJujuHome(config.SetJujuHome(testJujuHome))
envPath := config.JujuHomePath("environments.yaml")
c.Assert(envPath, Equals, filepath.Join(testJujuHome, "environments.yaml"))
}
