func (p *JujuProvisioner) Provision(app provision.App) error {
var buf bytes.Buffer
charms, err := config.GetString("juju:charms-path")
if err != nil {
return errors.New(`Setting "juju:charms-path" is not defined.`)
}
args := []string{
"deploy", "--repository", charms,
"local:" + app.GetPlatform(), app.GetName(),
}
err = runCmd(false, &buf, &buf, args...)
out := buf.String()
if err != nil {
app.Log("Failed to create machine: "+out, "tsuru")
return cmdError(out, err, args)
}
setOption := []string{
"set", app.GetName(), "app-repo=" + repository.ReadOnlyURL(app.GetName()),
}
runCmd(true, &buf, &buf, setOption...)
if p.elbSupport() {
router, err := Router()
if err != nil {
return err
}
if err = router.AddBackend(app.GetName()); err != nil {
return err
}
p.enqueueUnits(app.GetName())
}
return nil
}
// Clone runs a git clone to clone the app repository in an app.
func clone(p provision.Provisioner, app provision.App) ([]byte, error) {
var buf bytes.Buffer
path, err := repository.GetPath()
if err != nil {
return nil, fmt.Errorf("tsuru is misconfigured: %s", err)
}
cmd := fmt.Sprintf("git clone %s %s --depth 1", repository.ReadOnlyURL(app.GetName()), path)
err = p.ExecuteCommand(&buf, &buf, app, cmd)
b := buf.Bytes()
log.Debugf(`"git clone" output: %s`, b)
return b, err
}
// deployCmds returns the commands that is used when provisioner
// deploy an unit.
func deployCmds(app provision.App, version string) ([]string, error) {
deployCmd, err := config.GetString("docker:deploy-cmd")
if err != nil {
return nil, err
}
appRepo := repository.ReadOnlyURL(app.GetName())
var envs string
for _, env := range app.Envs() {
envs += fmt.Sprintf(`%s=%s `, env.Name, strings.Replace(env.Value, " ", "", -1))
}
cmds := []string{deployCmd, appRepo, version, envs}
return cmds, nil
}
func (s *S) TestCloneRepository(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
p := testing.NewFakeProvisioner()
p.PrepareOutput([]byte("something"))
app := testing.NewFakeApp("your", "python", 1)
out, err := clone(p, app)
c.Assert(err, gocheck.IsNil)
c.Assert(string(out), gocheck.Equals, "something")
url := repository.ReadOnlyURL(app.GetName())
path, _ := repository.GetPath()
expectedCommand := fmt.Sprintf("git clone %s %s --depth 1", url, path)
c.Assert(p.GetCmds(expectedCommand, app), gocheck.HasLen, 1)
}
func (s *S) TestDeployCmds(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
app := testing.NewFakeApp("app-name", "python", 1)
env := bind.EnvVar{
Name: "http_proxy",
Value: "[http://theirproxy.com:3128/, http://teste.com:3111]",
Public: true,
}
app.SetEnv(env)
deployCmd, err := config.GetString("docker:deploy-cmd")
c.Assert(err, gocheck.IsNil)
version := "version"
appRepo := repository.ReadOnlyURL(app.GetName())
expected := []string{deployCmd, appRepo, version, `http_proxy=[http://theirproxy.com:3128/,http://teste.com:3111] `}
cmds, err := deployCmds(app, version)
c.Assert(err, gocheck.IsNil)
c.Assert(cmds, gocheck.DeepEquals, expected)
}
func (s *S) TestProvision(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
fexec := &etesting.FakeExecutor{}
setExecut(fexec)
defer setExecut(nil)
config.Set("juju:charms-path", "/etc/juju/charms")
defer config.Unset("juju:charms-path")
config.Set("host", "somehost")
defer config.Unset("host")
app := testing.NewFakeApp("trace", "python", 0)
p := JujuProvisioner{}
err := p.Provision(app)
c.Assert(err, gocheck.IsNil)
args := []string{
"deploy", "--repository", "/etc/juju/charms", "local:python", "trace",
}
c.Assert(fexec.ExecutedCmd("juju", args), gocheck.Equals, true)
args = []string{
"set", "trace", "app-repo=" + repository.ReadOnlyURL("trace"),
}
c.Assert(fexec.ExecutedCmd("juju", args), gocheck.Equals, true)
}
// gitDeployCmds returns the list of commands that are used when the
// provisioner deploys a unit using the Git repository method.
func gitDeployCmds(app provision.App, version string) ([]string, error) {
appRepo := repository.ReadOnlyURL(app.GetName())
return deployCmds(app, "git", appRepo, version)
}