Added LogDir to agent conf, upgrade steps

worker/deployer/simple_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package deployer_test
 
 import (
         "encoding/json"
         "fmt"
         "io/ioutil"
         "os"
@@ skipping 117 matching lines @@
         // Verify they're no longer discoverable.
         units, err = manager.DeployedUnits()
         c.Assert(err, gc.IsNil)
         c.Assert(units, gc.HasLen, 0)
 }
 
 type SimpleToolsFixture struct {
         testbase.LoggingSuite
         dataDir         string
         initDir         string
-        logDir          string
         origPath        string
         binDir          string
         syslogConfigDir string
 }
 
 var fakeJujud = "#!/bin/bash --norc\n# fake-jujud\nexit 0\n"
 
 func (fix *SimpleToolsFixture) SetUp(c *gc.C, dataDir string) {
         fix.LoggingSuite.SetUpTest(c)
         fix.dataDir = dataDir
         fix.initDir = c.MkDir()
-        fix.logDir = c.MkDir()
         fix.syslogConfigDir = c.MkDir()
         toolsDir := tools.SharedToolsDir(fix.dataDir, version.Current)
         err := os.MkdirAll(toolsDir, 0755)
         c.Assert(err, gc.IsNil)
         jujudPath := filepath.Join(toolsDir, "jujud")
         err = ioutil.WriteFile(jujudPath, []byte(fakeJujud), 0755)
         c.Assert(err, gc.IsNil)
         toolsPath := filepath.Join(toolsDir, "downloaded-tools.txt")
         testTools := coretools.Tools{Version: version.Current, URL: "http://testing.invalid/tools"}
         data, err := json.Marshal(testTools)
@@ skipping 21 matching lines @@
         c.Assert(err, gc.IsNil)
 }
 
 func (fix *SimpleToolsFixture) assertUpstartCount(c *gc.C, count int) {
         fis, err := ioutil.ReadDir(fix.initDir)
         c.Assert(err, gc.IsNil)
         c.Assert(fis, gc.HasLen, count)
 }
 
 func (fix *SimpleToolsFixture) getContext(c *gc.C) *deployer.SimpleContext {
-        config := agentConfig("machine-tag", fix.dataDir)
-        return deployer.NewTestSimpleContext(config, fix.initDir, fix.logDir, fix.syslogConfigDir)
+        config := agentConfig("machine-tag", fix.dataDir, agent.DefaultLogDir)
+        return deployer.NewTestSimpleContext(config, fix.initDir, fix.syslogConfigDir)
 }
 
 func (fix *SimpleToolsFixture) getContextForMachine(c *gc.C, machineTag string) *deployer.SimpleContext {
-        config := agentConfig(machineTag, fix.dataDir)
-        return deployer.NewTestSimpleContext(config, fix.initDir, fix.logDir, fix.syslogConfigDir)
+        config := agentConfig(machineTag, fix.dataDir, agent.DefaultLogDir)
+        return deployer.NewTestSimpleContext(config, fix.initDir, fix.syslogConfigDir)
 }
 
 func (fix *SimpleToolsFixture) paths(tag string) (confPath, agentDir, toolsDir, syslogConfPath string) {
         confName := fmt.Sprintf("jujud-%s.conf", tag)
         confPath = filepath.Join(fix.initDir, confName)
         agentDir = agent.Dir(fix.dataDir, tag)
         toolsDir = tools.ToolsDir(fix.dataDir, tag)
         syslogConfPath = filepath.Join(fix.syslogConfigDir, fmt.Sprintf("26-juju-%s.conf", tag))
         return
 }
 
 var expectedSyslogConf = `
 $ModLoad imfile
 
 $InputFilePersistStateInterval 50
 $InputFilePollInterval 5
-$InputFileName /var/log/juju/%s.log
+$InputFileName %s/%s.log
 $InputFileTag juju-%s:
 $InputFileStateFile %s
 $InputRunFileMonitor
 
 $template LongTagForwardFormat,"<%%PRI%%>%%TIMESTAMP:::date-rfc3339%% %%HOSTNAME%% %%syslogtag%%%%msg:::sp-if-no-1st-sp%%%%msg%%"
 
 :syslogtag, startswith, "juju-" @s1:2345;LongTagForwardFormat
 & ~
 `
 
 func (fix *SimpleToolsFixture) checkUnitInstalled(c *gc.C, name, password string) {
         tag := names.UnitTag(name)
         uconfPath, _, toolsDir, syslogConfPath := fix.paths(tag)
         uconfData, err := ioutil.ReadFile(uconfPath)
         c.Assert(err, gc.IsNil)
         uconf := string(uconfData)
         var execLine string
         for _, line := range strings.Split(uconf, "\n") {
                 if strings.HasPrefix(line, "exec ") {
                         execLine = line
                         break
                 }
         }
         if execLine == "" {
                 c.Fatalf("no command found in %s:\n%s", uconfPath, uconf)
         }
-        logPath := filepath.Join(fix.logDir, tag+".log")
+        logPath := filepath.Join(agent.DefaultLogDir, tag+".log")
         jujudPath := filepath.Join(toolsDir, "jujud")
         for _, pat := range []string{
                 "^exec " + jujudPath + " unit ",
                 " --unit-name " + name + " ",
                 " >> " + logPath + " 2>&1$",
         } {
                 match, err := regexp.MatchString(pat, execLine)
                 c.Assert(err, gc.IsNil)
                 if !match {
                         c.Fatalf("failed to match:\n%s\nin:\n%s", pat, execLine)
                 }
         }
 
         conf, err := agent.ReadConf(fix.dataDir, tag)
         c.Assert(err, gc.IsNil)
         c.Assert(conf.Tag(), gc.Equals, tag)
         c.Assert(conf.DataDir(), gc.Equals, fix.dataDir)
 
         jujudData, err := ioutil.ReadFile(jujudPath)
         c.Assert(err, gc.IsNil)
         c.Assert(string(jujudData), gc.Equals, fakeJujud)
 
         syslogConfData, err := ioutil.ReadFile(syslogConfPath)
         c.Assert(err, gc.IsNil)
         parts := strings.SplitN(name, "/", 2)
         unitTag := fmt.Sprintf("unit-%s-%s", parts[0], parts[1])
-        expectedSyslogConfReplaced := fmt.Sprintf(expectedSyslogConf, unitTag, unitTag, unitTag)
+        expectedSyslogConfReplaced := fmt.Sprintf(expectedSyslogConf, agent.DefaultLogDir, unitTag, unitTag, unitTag)
         c.Assert(string(syslogConfData), gc.Equals, expectedSyslogConfReplaced)
 
 }
 
 func (fix *SimpleToolsFixture) checkUnitRemoved(c *gc.C, name string) {
         tag := names.UnitTag(name)
         confPath, agentDir, toolsDir, syslogConfPath := fix.paths(tag)
         for _, path := range []string{confPath, agentDir, toolsDir, syslogConfPath} {
                 _, err := ioutil.ReadFile(path)
                 if err == nil {
@@ skipping 10 matching lines @@
         c.Assert(err, gc.IsNil)
         toolsDir := filepath.Join(fix.dataDir, "tools", unitTag)
         err = os.MkdirAll(toolsDir, 0755)
         c.Assert(err, gc.IsNil)
 }
 
 type mockConfig struct {
         agent.Config
         tag     string
         datadir string
+        logDir  string
 }
 
 func (mock *mockConfig) Tag() string {
         return mock.tag
 }
 
 func (mock *mockConfig) DataDir() string {
         return mock.datadir
 }
 
+func (mock *mockConfig) LogDir() string {
+        return mock.logDir
+}
+
 func (mock *mockConfig) CACert() []byte {
         return []byte(testing.CACert)
 }
 
 func (mock *mockConfig) Value(_ string) string {
         return ""
 }
 
-func agentConfig(tag, datadir string) agent.Config {
-        return &mockConfig{tag: tag, datadir: datadir}
+func agentConfig(tag, datadir, logDir string) agent.Config {
+        return &mockConfig{tag: tag, datadir: datadir, logDir: logDir}
 }