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