func (s *ConverterSuite) TestNewDeployerCreatesGitDeployerOnceStaged(c *gc.C) {
gitDeployer := charm.NewGitDeployer(s.targetPath, s.dataPath, s.bundles)
info := s.bundles.AddBundle(c, charmURL(1), mockBundle{})
err := gitDeployer.Stage(info, nil)
c.Assert(err, gc.IsNil)
deployer, err := charm.NewDeployer(s.targetPath, s.dataPath, s.bundles)
c.Assert(err, gc.IsNil)
c.Assert(deployer, jc.Satisfies, charm.IsGitDeployer)
}
func (s *ConverterSuite) TestConvertGitDeployerBeforeDeploy(c *gc.C) {
gitDeployer := charm.NewGitDeployer(s.targetPath, s.dataPath, s.bundles)
info := s.bundles.AddBundle(c, charmURL(1), mockBundle{})
err := gitDeployer.Stage(info, nil)
c.Assert(err, gc.IsNil)
deployer, err := charm.NewDeployer(s.targetPath, s.dataPath, s.bundles)
c.Assert(err, gc.IsNil)
err = charm.FixDeployer(&deployer)
c.Assert(err, gc.IsNil)
c.Assert(deployer, jc.Satisfies, charm.IsManifestDeployer)
ft.Removed{"current"}.Check(c, s.dataPath)
err = deployer.Stage(info, nil)
c.Assert(err, gc.IsNil)
err = deployer.Deploy()
c.Assert(err, gc.IsNil)
ft.Removed{".git"}.Check(c, s.targetPath)
}
func (s *ConverterSuite) TestPathological(c *gc.C) {
initial := s.bundles.AddCustomBundle(c, charmURL(1), func(path string) {
ft.File{"common", "initial", 0644}.Create(c, path)
ft.File{"initial", "blah", 0644}.Create(c, path)
})
staged := s.bundles.AddCustomBundle(c, charmURL(2), func(path string) {
ft.File{"common", "staged", 0644}.Create(c, path)
ft.File{"user", "badwrong", 0644}.Create(c, path)
})
final := s.bundles.AddCustomBundle(c, charmURL(3), func(path string) {
ft.File{"common", "final", 0644}.Create(c, path)
ft.File{"final", "blah", 0644}.Create(c, path)
})
gitDeployer := charm.NewGitDeployer(s.targetPath, s.dataPath, s.bundles)
err := gitDeployer.Stage(initial, nil)
c.Assert(err, gc.IsNil)
err = gitDeployer.Deploy()
c.Assert(err, gc.IsNil)
preserveUser := ft.File{"user", "preserve", 0644}.Create(c, s.targetPath)
err = gitDeployer.Stage(staged, nil)
c.Assert(err, gc.IsNil)
deployer, err := charm.NewDeployer(s.targetPath, s.dataPath, s.bundles)
c.Assert(err, gc.IsNil)
err = charm.FixDeployer(&deployer)
c.Assert(err, gc.IsNil)
err = deployer.Stage(final, nil)
c.Assert(err, gc.IsNil)
err = deployer.Deploy()
c.Assert(err, gc.IsNil)
ft.Removed{".git"}.Check(c, s.targetPath)
ft.Removed{"initial"}.Check(c, s.targetPath)
ft.Removed{"staged"}.Check(c, s.targetPath)
ft.File{"common", "final", 0644}.Check(c, s.targetPath)
preserveUser.Check(c, s.targetPath)
}
func (u *Uniter) init(unitTag string) (err error) {
u.unit, err = u.st.Unit(unitTag)
if err != nil {
return err
}
if u.unit.Life() == params.Dead {
// If we started up already dead, we should not progress further. If we
// become Dead immediately after starting up, we may well complete any
// operations in progress before detecting it; but that race is fundamental
// and inescapable, whereas this one is not.
return worker.ErrTerminateAgent
}
if err = u.setupLocks(); err != nil {
return err
}
u.toolsDir = tools.ToolsDir(u.dataDir, unitTag)
if err := EnsureJujucSymlinks(u.toolsDir); err != nil {
return err
}
u.baseDir = filepath.Join(u.dataDir, "agents", unitTag)
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.ServiceTag())
if err != nil {
return err
}
var env *uniter.Environment
env, err = u.st.Environment()
if err != nil {
return err
}
u.uuid = env.UUID()
u.envName = env.Name()
u.relationers = map[int]*Relationer{}
u.relationHooks = make(chan hook.Info)
u.charmPath = filepath.Join(u.baseDir, "charm")
deployerPath := filepath.Join(u.baseDir, "state", "deployer")
bundles := charm.NewBundlesDir(filepath.Join(u.baseDir, "state", "bundles"))
u.deployer, err = charm.NewDeployer(u.charmPath, deployerPath, bundles)
if err != nil {
return fmt.Errorf("cannot create deployer: %v", err)
}
u.sf = NewStateFile(filepath.Join(u.baseDir, "state", "uniter"))
u.rand = rand.New(rand.NewSource(time.Now().Unix()))
// If we start trying to listen for juju-run commands before we have valid
// relation state, surprising things will come to pass.
if err := u.restoreRelations(); err != nil {
return err
}
runListenerSocketPath := filepath.Join(u.baseDir, RunListenerFile)
logger.Debugf("starting juju-run listener on unix:%s", runListenerSocketPath)
u.runListener, err = NewRunListener(u, runListenerSocketPath)
if err != nil {
return err
}
// The socket needs to have permissions 777 in order for other users to use it.
return os.Chmod(runListenerSocketPath, 0777)
}
func (s *ConverterSuite) TestNewDeployerCreatesManifestDeployer(c *gc.C) {
deployer, err := charm.NewDeployer(s.targetPath, s.dataPath, s.bundles)
c.Assert(err, gc.IsNil)
c.Assert(deployer, jc.Satisfies, charm.IsManifestDeployer)
}
