func (s *S) TestCheckout(c *gocheck.C) {
p := testing.NewFakeProvisioner()
p.PrepareOutput([]byte("updated"))
app := testing.NewFakeApp("moon", "python", 1)
out, err := checkout(p, app, "5734f0042844fdeb5bbc1b72b18f2dc1779cade7")
c.Assert(err, gocheck.IsNil)
c.Assert(out, gocheck.IsNil)
path, _ := repository.GetPath()
expectedCommand := fmt.Sprintf("cd %s && git checkout 5734f0042844fdeb5bbc1b72b18f2dc1779cade7", path)
c.Assert(p.GetCmds(expectedCommand, app), gocheck.HasLen, 1)
}
func (s *S) TestPullRepository(c *gocheck.C) {
p := testing.NewFakeProvisioner()
p.PrepareOutput([]byte("pulled"))
app := testing.NewFakeApp("your", "python", 1)
out, err := fetch(p, app)
c.Assert(err, gocheck.IsNil)
c.Assert(string(out), gocheck.Equals, "pulled")
path, _ := repository.GetPath()
expectedCommand := fmt.Sprintf("cd %s && git fetch origin", path)
c.Assert(p.GetCmds(expectedCommand, app), gocheck.HasLen, 1)
}
// Clone runs a git clone to clone the app repository in an ap.
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.Printf(`"git clone" output: %s`, b)
return b, err
}
func (s *S) TestCloneRepository(c *gocheck.C) {
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)
}
// Pull runs a git pull to update the code in an app
//
// It works like Clone, pulling from the app bare repository.
func pull(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("cd %s && git pull origin master", path)
err = p.ExecuteCommand(&buf, &buf, app, cmd)
b := buf.Bytes()
log.Printf(`"git pull" output: %s`, b)
return b, err
}
// checkout updates the Git repository of the app to the given version.
func checkout(p provision.Provisioner, app provision.App, version string) ([]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("cd %s && git checkout %s", path, version)
if err := p.ExecuteCommand(&buf, &buf, app, cmd); err != nil {
return buf.Bytes(), err
}
return nil, nil
}
func (r *yamlHookRunner) loadConfig(app *App) error {
if r.config != nil {
return nil
}
repoPath, err := repository.GetPath()
if err != nil {
return err
}
err = r.loadConfigFromFile(app, path.Join(repoPath, "app.yaml"))
if err != nil {
err = r.loadConfigFromFile(app, path.Join(repoPath, "app.yml"))
}
return err
}
func (s *S) TestDeploy(c *gocheck.C) {
provisioner := testing.NewFakeProvisioner()
provisioner.PrepareOutput([]byte("cloned"))
provisioner.PrepareOutput([]byte("updated"))
app := testing.NewFakeApp("cribcaged", "python", 1)
provisioner.Provision(app)
w := &bytes.Buffer{}
err := Git(provisioner, app, "5734f0042844fdeb5bbc1b72b18f2dc1779cade7", w)
c.Assert(err, gocheck.IsNil)
c.Assert(app.Commands, gocheck.DeepEquals, []string{"restart"})
c.Assert(provisioner.InstalledDeps(app), gocheck.Equals, 1)
cloneCommand := "git clone git://tsuruhost.com/cribcaged.git test/dir --depth 1"
c.Assert(provisioner.GetCmds(cloneCommand, app), gocheck.HasLen, 1)
path, _ := repository.GetPath()
checkoutCommand := fmt.Sprintf("cd %s && git checkout 5734f0042844fdeb5bbc1b72b18f2dc1779cade7", path)
c.Assert(provisioner.GetCmds(checkoutCommand, app), gocheck.HasLen, 1)
}
// loadConf loads app configuration from app.yaml.
func (app *App) loadConf() error {
if app.conf != nil {
return nil
}
app.conf = new(conf)
uRepo, err := repository.GetPath()
if err != nil {
app.Log(fmt.Sprintf("Got error while getting repository path: %s", err), "tsuru")
return err
}
cmd := "cat " + path.Join(uRepo, "app.yaml")
var outStream, errStream bytes.Buffer
if err := Provisioner.ExecuteCommand(&outStream, &errStream, app, cmd); err != nil {
return nil
}
err = goyaml.Unmarshal(outStream.Bytes(), app.conf)
if err != nil {
app.Log(fmt.Sprintf("Got error while parsing yaml: %s", err), "tsuru")
return err
}
return nil
}
// Loads restart hooks from app.conf.
func (a *App) loadHooks() error {
if a.hooks != nil {
return nil
}
a.hooks = new(conf)
uRepo, err := repository.GetPath()
if err != nil {
a.Log(fmt.Sprintf("Got error while getting repository path: %s", err), "tsuru")
return err
}
cmd := "cat " + path.Join(uRepo, "app.conf")
var buf bytes.Buffer
err = a.run(cmd, &buf)
if err != nil {
a.Log(fmt.Sprintf("Got error while executing command: %s... Skipping hooks execution", err), "tsuru")
return nil
}
err = goyaml.Unmarshal(buf.Bytes(), a.hooks)
if err != nil {
a.Log(fmt.Sprintf("Got error while parsing yaml: %s", err), "tsuru")
return err
}
return nil
}
// loadHooks loads app configuration from app.yaml.
func (app *App) loadConf() error {
if app.conf != nil {
return nil
}
app.conf = new(conf)
uRepo, err := repository.GetPath()
if err != nil {
app.Log(fmt.Sprintf("Got error while getting repository path: %s", err), "tsuru")
return err
}
cmd := "cat " + path.Join(uRepo, "app.yaml")
var buf bytes.Buffer
err = app.run(cmd, &buf)
if err != nil {
app.Log(fmt.Sprintf("Got error while reading app.yaml: %s...\nSkipping hooks execution", err), "tsuru")
return nil
}
err = goyaml.Unmarshal(buf.Bytes(), app.conf)
if err != nil {
app.Log(fmt.Sprintf("Got error while parsing yaml: %s", err), "tsuru")
return err
}
return nil
}