github.com/altoros/juju-vmware@v0.0.0-20150312064031-f19ae857ccca/upgrades/agentconfig_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package upgrades_test
     5  
     6  import (
     7  	"io/ioutil"
     8  	"os"
     9  	"path/filepath"
    10  
    11  	"github.com/juju/names"
    12  	jc "github.com/juju/testing/checkers"
    13  	gc "gopkg.in/check.v1"
    14  	goyaml "gopkg.in/yaml.v1"
    15  
    16  	"github.com/juju/juju/agent"
    17  	"github.com/juju/juju/environs/config"
    18  	jujutesting "github.com/juju/juju/juju/testing"
    19  	"github.com/juju/juju/state"
    20  	"github.com/juju/juju/state/multiwatcher"
    21  	"github.com/juju/juju/testing"
    22  	"github.com/juju/juju/testing/factory"
    23  	"github.com/juju/juju/upgrades"
    24  	"github.com/juju/juju/version"
    25  )
    26  
    27  type migrateLocalProviderAgentConfigSuite struct {
    28  	jujutesting.JujuConnSuite
    29  
    30  	config agent.ConfigSetterWriter
    31  	ctx    upgrades.Context
    32  }
    33  
    34  var _ = gc.Suite(&migrateLocalProviderAgentConfigSuite{})
    35  
    36  func (s *migrateLocalProviderAgentConfigSuite) SetUpTest(c *gc.C) {
    37  	s.JujuConnSuite.SetUpTest(c)
    38  	// Make sure we fallback to SUDO_USER if USER is root.
    39  	s.PatchEnvironment("USER", "root")
    40  	s.PatchEnvironment("SUDO_USER", "user")
    41  	s.PatchValue(upgrades.RootLogDir, c.MkDir())
    42  	s.PatchValue(upgrades.RootSpoolDir, c.MkDir())
    43  	s.PatchValue(&agent.DefaultDataDir, c.MkDir())
    44  	s.PatchValue(upgrades.ChownPath, func(_, _ string) error { return nil })
    45  	s.PatchValue(upgrades.IsLocalEnviron, func(_ *config.Config) bool { return true })
    46  }
    47  
    48  func (s *migrateLocalProviderAgentConfigSuite) primeConfig(c *gc.C, st *state.State, job state.MachineJob, tag names.Tag) {
    49  	rootDir := c.MkDir()
    50  	sharedStorageDir := filepath.Join(rootDir, "shared-storage")
    51  	c.Assert(os.MkdirAll(sharedStorageDir, 0755), gc.IsNil)
    52  	localLogDir := filepath.Join(rootDir, "log")
    53  	c.Assert(os.MkdirAll(localLogDir, 0755), gc.IsNil)
    54  
    55  	initialConfig, err := agent.NewAgentConfig(agent.AgentConfigParams{
    56  		Tag:               tag,
    57  		Password:          "blah",
    58  		CACert:            testing.CACert,
    59  		StateAddresses:    []string{"localhost:1111"},
    60  		DataDir:           agent.DefaultDataDir,
    61  		LogDir:            agent.DefaultLogDir,
    62  		UpgradedToVersion: version.MustParse("1.16.0"),
    63  		Environment:       s.State.EnvironTag(),
    64  		Values: map[string]string{
    65  			"SHARED_STORAGE_ADDR": "blah",
    66  			"SHARED_STORAGE_DIR":  sharedStorageDir,
    67  		},
    68  	})
    69  	c.Assert(err, jc.ErrorIsNil)
    70  	s.config = initialConfig
    71  	c.Assert(s.config.Write(), gc.IsNil)
    72  
    73  	apiState, _ := s.OpenAPIAsNewMachine(c, job)
    74  	s.ctx = &mockContext{
    75  		realAgentConfig: initialConfig,
    76  		apiState:        apiState,
    77  		state:           st,
    78  	}
    79  
    80  	newCfg := (map[string]interface{}{
    81  		"root-dir": rootDir,
    82  	})
    83  	err = s.State.UpdateEnvironConfig(newCfg, nil, nil)
    84  	c.Assert(err, jc.ErrorIsNil)
    85  }
    86  
    87  func (s *migrateLocalProviderAgentConfigSuite) assertConfigProcessed(c *gc.C) {
    88  	envConfig, err := s.State.EnvironConfig()
    89  	c.Assert(err, jc.ErrorIsNil)
    90  	allAttrs := envConfig.AllAttrs()
    91  
    92  	namespace, _ := allAttrs["namespace"].(string)
    93  	c.Assert(namespace, gc.Equals, "user-dummyenv")
    94  	container, _ := allAttrs["container"].(string)
    95  	c.Assert(container, gc.Equals, "lxc")
    96  
    97  	expectedDataDir, _ := allAttrs["root-dir"].(string)
    98  	expectedSharedStorageDir := filepath.Join(expectedDataDir, "shared-storage")
    99  	_, err = os.Lstat(expectedSharedStorageDir)
   100  	c.Assert(err, gc.NotNil)
   101  	c.Assert(err, jc.Satisfies, os.IsNotExist)
   102  	expectedLogDir := filepath.Join(*upgrades.RootLogDir, "juju-"+namespace)
   103  	expectedJobs := []multiwatcher.MachineJob{multiwatcher.JobManageEnviron}
   104  	tag := s.ctx.AgentConfig().Tag()
   105  
   106  	// We need to read the actual migrated agent config.
   107  	configFilePath := agent.ConfigPath(expectedDataDir, tag)
   108  	agentConfig, err := agent.ReadConfig(configFilePath)
   109  	c.Assert(err, jc.ErrorIsNil)
   110  
   111  	c.Assert(agentConfig.DataDir(), gc.Equals, expectedDataDir)
   112  	c.Assert(agentConfig.LogDir(), gc.Equals, expectedLogDir)
   113  	c.Assert(agentConfig.Jobs(), gc.DeepEquals, expectedJobs)
   114  	c.Assert(agentConfig.Value("SHARED_STORAGE_ADDR"), gc.Equals, "")
   115  	c.Assert(agentConfig.Value("SHARED_STORAGE_DIR"), gc.Equals, "")
   116  	c.Assert(agentConfig.Value(agent.Namespace), gc.Equals, namespace)
   117  	agentService := "juju-agent-user-dummyenv"
   118  	c.Assert(agentConfig.Value(agent.AgentServiceName), gc.Equals, agentService)
   119  	c.Assert(agentConfig.Value(agent.ContainerType), gc.Equals, "")
   120  }
   121  
   122  func (s *migrateLocalProviderAgentConfigSuite) assertConfigNotProcessed(c *gc.C) {
   123  	envConfig, err := s.State.EnvironConfig()
   124  	c.Assert(err, jc.ErrorIsNil)
   125  	allAttrs := envConfig.AllAttrs()
   126  
   127  	namespace, _ := allAttrs["namespace"].(string)
   128  	c.Assert(namespace, gc.Equals, "")
   129  	container, _ := allAttrs["container"].(string)
   130  	c.Assert(container, gc.Equals, "")
   131  
   132  	rootDir, _ := allAttrs["root-dir"].(string)
   133  	expectedSharedStorageDir := filepath.Join(rootDir, "shared-storage")
   134  	_, err = os.Lstat(expectedSharedStorageDir)
   135  	c.Assert(err, jc.ErrorIsNil)
   136  	tag := s.ctx.AgentConfig().Tag()
   137  
   138  	// We need to read the actual migrated agent config.
   139  	configFilePath := agent.ConfigPath(agent.DefaultDataDir, tag)
   140  	agentConfig, err := agent.ReadConfig(configFilePath)
   141  	c.Assert(err, jc.ErrorIsNil)
   142  
   143  	c.Assert(agentConfig.DataDir(), gc.Equals, agent.DefaultDataDir)
   144  	c.Assert(agentConfig.LogDir(), gc.Equals, agent.DefaultLogDir)
   145  	c.Assert(agentConfig.Jobs(), gc.HasLen, 0)
   146  	c.Assert(agentConfig.Value("SHARED_STORAGE_ADDR"), gc.Equals, "blah")
   147  	c.Assert(agentConfig.Value("SHARED_STORAGE_DIR"), gc.Equals, expectedSharedStorageDir)
   148  	c.Assert(agentConfig.Value(agent.Namespace), gc.Equals, "")
   149  	c.Assert(agentConfig.Value(agent.AgentServiceName), gc.Equals, "")
   150  	c.Assert(agentConfig.Value(agent.ContainerType), gc.Equals, "")
   151  }
   152  func (s *migrateLocalProviderAgentConfigSuite) TestMigrateStateServer(c *gc.C) {
   153  	s.primeConfig(c, s.State, state.JobManageEnviron, names.NewMachineTag("0"))
   154  	err := upgrades.MigrateLocalProviderAgentConfig(s.ctx)
   155  	c.Assert(err, jc.ErrorIsNil)
   156  	err = s.config.Write()
   157  	c.Assert(err, jc.ErrorIsNil)
   158  	s.assertConfigProcessed(c)
   159  }
   160  
   161  func (s *migrateLocalProviderAgentConfigSuite) TestMigrateNonLocalEnvNotDone(c *gc.C) {
   162  	s.PatchValue(upgrades.IsLocalEnviron, func(_ *config.Config) bool { return false })
   163  	s.primeConfig(c, s.State, state.JobManageEnviron, names.NewMachineTag("0"))
   164  	err := upgrades.MigrateLocalProviderAgentConfig(s.ctx)
   165  	c.Assert(err, jc.ErrorIsNil)
   166  	err = s.config.Write()
   167  	c.Assert(err, jc.ErrorIsNil)
   168  	s.assertConfigNotProcessed(c)
   169  }
   170  
   171  func (s *migrateLocalProviderAgentConfigSuite) TestMigrateWithoutStateConnectionNotDone(c *gc.C) {
   172  	s.primeConfig(c, nil, state.JobManageEnviron, names.NewMachineTag("0"))
   173  	err := upgrades.MigrateLocalProviderAgentConfig(s.ctx)
   174  	c.Assert(err, jc.ErrorIsNil)
   175  	err = s.config.Write()
   176  	c.Assert(err, jc.ErrorIsNil)
   177  	s.assertConfigNotProcessed(c)
   178  }
   179  
   180  func (s *migrateLocalProviderAgentConfigSuite) TestIdempotent(c *gc.C) {
   181  	s.primeConfig(c, s.State, state.JobManageEnviron, names.NewMachineTag("0"))
   182  	err := upgrades.MigrateLocalProviderAgentConfig(s.ctx)
   183  	c.Assert(err, jc.ErrorIsNil)
   184  	err = s.config.Write()
   185  	c.Assert(err, jc.ErrorIsNil)
   186  	s.assertConfigProcessed(c)
   187  
   188  	err = upgrades.MigrateLocalProviderAgentConfig(s.ctx)
   189  	c.Assert(err, jc.ErrorIsNil)
   190  	err = s.config.Write()
   191  	c.Assert(err, jc.ErrorIsNil)
   192  	s.assertConfigProcessed(c)
   193  }
   194  
   195  type migrateAgentEnvUUIDSuite struct {
   196  	jujutesting.JujuConnSuite
   197  	machine  *state.Machine
   198  	password string
   199  	ctx      *mockContext
   200  }
   201  
   202  var _ = gc.Suite(&migrateAgentEnvUUIDSuite{})
   203  
   204  func (s *migrateAgentEnvUUIDSuite) SetUpTest(c *gc.C) {
   205  	s.JujuConnSuite.SetUpTest(c)
   206  	s.PatchValue(&agent.DefaultLogDir, c.MkDir())
   207  	s.PatchValue(&agent.DefaultDataDir, c.MkDir())
   208  	s.primeConfig(c)
   209  }
   210  
   211  func (s *migrateAgentEnvUUIDSuite) primeConfig(c *gc.C) {
   212  	s.machine, s.password = s.Factory.MakeMachineReturningPassword(c, &factory.MachineParams{
   213  		Nonce: "a nonce",
   214  	})
   215  	initialConfig, err := agent.NewAgentConfig(agent.AgentConfigParams{
   216  		Tag:               s.machine.Tag(),
   217  		Password:          s.password,
   218  		CACert:            testing.CACert,
   219  		StateAddresses:    []string{"localhost:1111"},
   220  		DataDir:           agent.DefaultDataDir,
   221  		LogDir:            agent.DefaultLogDir,
   222  		UpgradedToVersion: version.MustParse("1.22.0"),
   223  		Environment:       s.State.EnvironTag(),
   224  	})
   225  	c.Assert(err, jc.ErrorIsNil)
   226  	c.Assert(initialConfig.Write(), gc.IsNil)
   227  
   228  	apiState, _ := s.OpenAPIAsNewMachine(c)
   229  	s.ctx = &mockContext{
   230  		realAgentConfig: initialConfig,
   231  		apiState:        apiState,
   232  		state:           s.State,
   233  	}
   234  }
   235  
   236  func (s *migrateAgentEnvUUIDSuite) removeEnvUUIDFromAgentConfig(c *gc.C) {
   237  	// Read the file in as simple map[string]interface{} and delete
   238  	// the element, and write it back out again.
   239  
   240  	// First step, read the file contents.
   241  	filename := agent.ConfigPath(agent.DefaultDataDir, s.machine.Tag())
   242  	data, err := ioutil.ReadFile(filename)
   243  	c.Assert(err, jc.ErrorIsNil)
   244  	c.Logf("Data in:\n\n%s\n", data)
   245  
   246  	// Parse it into the map.
   247  	var content map[string]interface{}
   248  	err = goyaml.Unmarshal(data, &content)
   249  	c.Assert(err, jc.ErrorIsNil)
   250  
   251  	// Remove the environment value, and marshal back into bytes.
   252  	delete(content, "environment")
   253  	data, err = goyaml.Marshal(content)
   254  	c.Assert(err, jc.ErrorIsNil)
   255  
   256  	// Write the yaml back out remembering to add the format prefix.
   257  	data = append([]byte("# format 1.18\n"), data...)
   258  	c.Logf("Data out:\n\n%s\n", data)
   259  	err = ioutil.WriteFile(filename, data, 0644)
   260  	c.Assert(err, jc.ErrorIsNil)
   261  
   262  	// Reset test attributes.
   263  	cfg, err := agent.ReadConfig(filename)
   264  	c.Assert(err, jc.ErrorIsNil)
   265  	s.ctx.realAgentConfig = cfg
   266  }
   267  
   268  func (s *migrateAgentEnvUUIDSuite) TestAgentEnvironmentUUID(c *gc.C) {
   269  	c.Assert(s.ctx.realAgentConfig.Environment(), gc.Equals, s.State.EnvironTag())
   270  }
   271  
   272  func (s *migrateAgentEnvUUIDSuite) TestRemoveFuncWorks(c *gc.C) {
   273  	s.removeEnvUUIDFromAgentConfig(c)
   274  	c.Assert(s.ctx.realAgentConfig.Environment().Id(), gc.Equals, "")
   275  }
   276  
   277  func (s *migrateAgentEnvUUIDSuite) TestMigrationStep(c *gc.C) {
   278  	s.removeEnvUUIDFromAgentConfig(c)
   279  	upgrades.AddEnvironmentUUIDToAgentConfig(s.ctx)
   280  	c.Assert(s.ctx.realAgentConfig.Environment(), gc.Equals, s.State.EnvironTag())
   281  }
   282  
   283  func (s *migrateAgentEnvUUIDSuite) TestMigrationStepIdempotent(c *gc.C) {
   284  	s.removeEnvUUIDFromAgentConfig(c)
   285  	upgrades.AddEnvironmentUUIDToAgentConfig(s.ctx)
   286  	upgrades.AddEnvironmentUUIDToAgentConfig(s.ctx)
   287  	c.Assert(s.ctx.realAgentConfig.Environment(), gc.Equals, s.State.EnvironTag())
   288  }