func (ctx *SimpleContext) RecallUnit(unitName string) error {
svc := ctx.findUpstartJob(unitName)
if svc == nil || !svc.Installed() {
return fmt.Errorf("unit %q is not deployed", unitName)
}
if err := svc.Remove(); err != nil {
return err
}
tag := state.UnitTag(unitName)
agentDir := agent.Dir(ctx.dataDir, tag)
if err := os.RemoveAll(agentDir); err != nil {
return err
}
if err := os.Remove(ctx.syslogConfigPath); err != nil && !os.IsNotExist(err) {
logger.Warningf("installer: cannot remove %q: %v", ctx.syslogConfigPath, err)
}
// Defer this so a failure here does not impede the cleanup (as in tests).
defer func() {
if err := syslog.Restart(); err != nil {
logger.Warningf("installer: cannot restart syslog daemon: %v", err)
}
}()
toolsDir := agent.ToolsDir(ctx.dataDir, tag)
return os.Remove(toolsDir)
}
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 = agent.ToolsDir(fix.dataDir, tag)
syslogConfPath = filepath.Join(fix.syslogConfigDir, fmt.Sprintf("26-juju-%s.conf", tag))
return
}
func (s *ToolsSuite) SetUpTest(c *C) {
s.dataDir = c.MkDir()
s.toolsDir = agent.SharedToolsDir(s.dataDir, version.Current)
err := os.MkdirAll(s.toolsDir, 0755)
c.Assert(err, IsNil)
err = os.Symlink(s.toolsDir, agent.ToolsDir(s.dataDir, "unit-u-123"))
c.Assert(err, IsNil)
}
func (t *ToolsSuite) TestChangeAgentTools(c *C) {
files := []*testing.TarFile{
testing.NewTarFile("jujuc", 0755, "juju executable"),
testing.NewTarFile("jujud", 0755, "jujuc executable"),
}
tools := &state.Tools{
URL: "http://foo/bar1",
Binary: version.MustParseBinary("1.2.3-foo-bar"),
}
err := agent.UnpackTools(t.dataDir, tools, bytes.NewReader(testing.TarGz(files...)))
c.Assert(err, IsNil)
gotTools, err := agent.ChangeAgentTools(t.dataDir, "testagent", tools.Binary)
c.Assert(err, IsNil)
c.Assert(*gotTools, Equals, *tools)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-foo-bar", "testagent"})
assertDirNames(c, agent.ToolsDir(t.dataDir, "testagent"), []string{"jujuc", "jujud", urlFile})
// Upgrade again to check that the link replacement logic works ok.
files2 := []*testing.TarFile{
testing.NewTarFile("foo", 0755, "foo content"),
testing.NewTarFile("bar", 0755, "bar content"),
}
tools2 := &state.Tools{
URL: "http://foo/bar2",
Binary: version.MustParseBinary("1.2.4-foo-bar"),
}
err = agent.UnpackTools(t.dataDir, tools2, bytes.NewReader(testing.TarGz(files2...)))
c.Assert(err, IsNil)
gotTools, err = agent.ChangeAgentTools(t.dataDir, "testagent", tools2.Binary)
c.Assert(err, IsNil)
c.Assert(*gotTools, Equals, *tools2)
assertDirNames(c, t.toolsDir(), []string{"1.2.3-foo-bar", "1.2.4-foo-bar", "testagent"})
assertDirNames(c, agent.ToolsDir(t.dataDir, "testagent"), []string{"foo", "bar", urlFile})
}
func (s *UpgraderSuite) TestUpgraderReadyErrorUpgrade(c *C) {
currentTools := s.primeTools(c, version.MustParseBinary("2.0.2-foo-bar"))
ug := &UpgradeReadyError{
AgentName: "foo",
OldTools: &state.Tools{Binary: version.MustParseBinary("2.0.0-foo-bar")},
NewTools: currentTools,
DataDir: s.DataDir(),
}
err := ug.ChangeAgentTools()
c.Assert(err, IsNil)
d := agent.ToolsDir(s.DataDir(), "foo")
data, err := ioutil.ReadFile(filepath.Join(d, "jujud"))
c.Assert(err, IsNil)
c.Assert(string(data), Equals, "jujud contents 2.0.2-foo-bar")
}
func (s *UniterSuite) SetUpSuite(c *C) {
s.JujuConnSuite.SetUpSuite(c)
s.HTTPSuite.SetUpSuite(c)
s.dataDir = c.MkDir()
toolsDir := agent.ToolsDir(s.dataDir, "unit-u-0")
err := os.MkdirAll(toolsDir, 0755)
c.Assert(err, IsNil)
cmd := exec.Command("go", "build", "launchpad.net/juju-core/cmd/jujud")
cmd.Dir = toolsDir
out, err := cmd.CombinedOutput()
c.Logf(string(out))
c.Assert(err, IsNil)
s.oldLcAll = os.Getenv("LC_ALL")
os.Setenv("LC_ALL", "en_US")
s.unitDir = filepath.Join(s.dataDir, "agents", "unit-u-0")
}
func (cfg *MachineConfig) addMachineAgentToBoot(c *cloudinit.Config, tag, machineId, logConfig string) error {
// Make the agent run via a symbolic link to the actual tools
// directory, so it can upgrade itself without needing to change
// the upstart script.
toolsDir := agent.ToolsDir(cfg.DataDir, tag)
// TODO(dfc) ln -nfs, so it doesn't fail if for some reason that the target already exists
addScripts(c, fmt.Sprintf("ln -s %v %s", cfg.Tools.Binary, shquote(toolsDir)))
name := "jujud-" + tag
conf := upstart.MachineAgentUpstartService(name, toolsDir, cfg.DataDir, "/var/log/juju/", tag, machineId, logConfig, cfg.ProviderType)
cmds, err := conf.InstallCommands()
if err != nil {
return fmt.Errorf("cannot make cloud-init upstart script for the %s agent: %v", tag, err)
}
addScripts(c, cmds...)
return nil
}
func (u *Uniter) init(name string) (err error) {
defer utils.ErrorContextf(&err, "failed to initialize uniter for unit %q", name)
u.unit, err = u.st.Unit(name)
if err != nil {
return err
}
if err = u.setupLocks(); err != nil {
return err
}
ename := u.unit.Tag()
u.toolsDir = agent.ToolsDir(u.dataDir, ename)
if err := EnsureJujucSymlinks(u.toolsDir); err != nil {
return err
}
u.baseDir = filepath.Join(u.dataDir, "agents", ename)
u.relationsDir = filepath.Join(u.baseDir, "state", "relations")
if err := os.MkdirAll(u.relationsDir, 0755); err != nil {
return err
}
u.service, err = u.st.Service(u.unit.ServiceName())
if err != nil {
return err
}
var env *state.Environment
env, err = u.st.Environment()
if err != nil {
return err
}
u.uuid = env.UUID()
u.relationers = map[int]*Relationer{}
u.relationHooks = make(chan hook.Info)
u.charm = charm.NewGitDir(filepath.Join(u.baseDir, "charm"))
u.bundles = charm.NewBundlesDir(filepath.Join(u.baseDir, "state", "bundles"))
u.deployer = charm.NewDeployer(filepath.Join(u.baseDir, "state", "deployer"))
u.sf = NewStateFile(filepath.Join(u.baseDir, "state", "uniter"))
u.rand = rand.New(rand.NewSource(time.Now().Unix()))
return nil
}
func (ctx *SimpleContext) DeployUnit(unitName, initialPassword string) (err error) {
// Check sanity.
svc := ctx.upstartService(unitName)
if svc.Installed() {
return fmt.Errorf("unit %q is already deployed", unitName)
}
// Link the current tools for use by the new agent.
tag := state.UnitTag(unitName)
_, err = agent.ChangeAgentTools(ctx.dataDir, tag, version.Current)
toolsDir := agent.ToolsDir(ctx.dataDir, tag)
defer removeOnErr(&err, toolsDir)
// Retrieve addresses from state.
stateAddrs, err := ctx.addresser.Addresses()
if err != nil {
return err
}
apiAddrs, err := ctx.addresser.APIAddresses()
if err != nil {
return err
}
stateInfo := state.Info{
Addrs: stateAddrs,
Tag: tag,
CACert: ctx.caCert,
}
apiInfo := api.Info{
Addrs: apiAddrs,
Tag: tag,
CACert: ctx.caCert,
}
// Prepare the agent's configuration data.
conf := &agent.Conf{
DataDir: ctx.dataDir,
OldPassword: initialPassword,
StateInfo: &stateInfo,
APIInfo: &apiInfo,
}
if err := conf.Write(); err != nil {
return err
}
defer removeOnErr(&err, conf.Dir())
// Install an upstart job that runs the unit agent.
logPath := path.Join(ctx.logDir, tag+".log")
syslogConfigRenderer := syslog.NewForwardConfig(tag, stateAddrs)
syslogConfigRenderer.ConfigDir = ctx.syslogConfigDir
syslogConfigRenderer.ConfigFileName = fmt.Sprintf("26-juju-%s.conf", tag)
if err := syslogConfigRenderer.Write(); err != nil {
return err
}
ctx.syslogConfigPath = syslogConfigRenderer.ConfigFilePath()
if err := syslog.Restart(); err != nil {
logger.Warningf("installer: cannot restart syslog daemon: %v", err)
}
defer removeOnErr(&err, ctx.syslogConfigPath)
cmd := strings.Join([]string{
path.Join(toolsDir, "jujud"), "unit",
"--data-dir", conf.DataDir,
"--unit-name", unitName,
"--debug", // TODO: propagate debug state sensibly
}, " ")
uconf := &upstart.Conf{
Service: *svc,
Desc: "juju unit agent for " + unitName,
Cmd: cmd,
Out: logPath,
// Propagate the provider type enviroment variable.
Env: map[string]string{
"JUJU_PROVIDER_TYPE": os.Getenv("JUJU_PROVIDER_TYPE"),
},
}
return uconf.Install()
}
