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 }