func pullRepo(location string, alreadyAsked bool) error {
if alreadyAsked || askToPull(location) {
prevDir, _ := os.Getwd()
if err := os.Chdir(location); err != nil {
return fmt.Errorf("Error:\tCould not move into the directory (%s)\n", location)
}
logger.Printf("Pulling origin master.\n")
c := exec.Command("git", "pull", "origin", "master")
// XXX [csk]: we squelch this output to provide a nicer newb interface... may need to change later
//c.Stdout = config.GlobalConfig.Writer
c.Stderr = config.GlobalConfig.ErrorWriter
if err := c.Run(); err != nil {
logger.Printf("err: %v\n", err)
return err
}
if err := os.Chdir(prevDir); err != nil {
return fmt.Errorf("Error:\tCould not move into the directory (%s)\n", prevDir)
}
}
return nil
}
func camputMany() error {
if *fast {
gofast(1)
return nil
}
err := os.Chdir(camliRoot)
if err != nil {
log.Fatal(err)
}
defer func() {
err := os.Chdir(defaultDir)
if err != nil {
panic(err)
}
}()
// upload the full camli pkg tree
setCurrentTask(NameToCmd["camput3"])
tsk := getCurrentTask()
_, err = runCmd(tsk.Cmd)
addRun(tsk, err)
if err != nil {
return err
}
return nil
}
func TestFmt_workingDirectory(t *testing.T) {
tempDir, err := fmtFixtureWriteDir()
if err != nil {
t.Fatalf("err: %s", err)
}
defer os.RemoveAll(tempDir)
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
err = os.Chdir(tempDir)
if err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
ui := new(cli.MockUi)
c := &FmtCommand{
Meta: Meta{
ContextOpts: testCtxConfig(testProvider()),
Ui: ui,
},
}
args := []string{}
if code := c.Run(args); code != 0 {
t.Fatalf("wrong exit code. errors: \n%s", ui.ErrorWriter.String())
}
expected := fmt.Sprintf("%s\n", fmtFixture.filename)
if actual := ui.OutputWriter.String(); actual != expected {
t.Fatalf("got: %q\nexpected: %q", actual, expected)
}
}
func TestShow_noArgsNoState(t *testing.T) {
// Create the default state
td, err := ioutil.TempDir("", "tf")
if err != nil {
t.Fatalf("err: %s", err)
}
statePath := filepath.Join(td, DefaultStateFilename)
// Change to the temporary directory
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(filepath.Dir(statePath)); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
ui := new(cli.MockUi)
c := &ShowCommand{
Meta: Meta{
ContextOpts: testCtxConfig(testProvider()),
Ui: ui,
},
}
args := []string{}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: \n%s", ui.OutputWriter.String())
}
}
// Test the reverse-Polish notation calculator rp.{nex,y}.
func TestNexPlusYacc(t *testing.T) {
tmpdir, err := ioutil.TempDir("", "nex")
dieErr(t, err, "TempDir")
defer func() {
dieErr(t, os.RemoveAll(tmpdir), "RemoveAll")
}()
run := func(s string) {
v := strings.Split(s, " ")
err := exec.Command(v[0], v[1:]...).Run()
dieErr(t, err, s)
}
run("cp rp.nex rp.y " + tmpdir)
wd, err := os.Getwd()
dieErr(t, err, "Getwd")
dieErr(t, os.Chdir(tmpdir), "Chdir")
defer func() {
dieErr(t, os.Chdir(wd), "Chdir")
}()
run(nexBin + " rp.nex")
run("go tool yacc rp.y")
run("go build y.go rp.nn.go")
cmd := exec.Command("./y")
cmd.Stdin = strings.NewReader(
`1 2 3 4 + * -
9 8 * 7 * 3 2 * 1 * / n
`)
want := "-13\n-84\n"
got, err := cmd.CombinedOutput()
dieErr(t, err, "CombinedOutput")
if want != string(got) {
t.Fatalf("want %q, got %q", want, string(got))
}
}
func TestAbs(t *testing.T) {
oldwd, err := os.Getwd()
if err != nil {
t.Fatal("Getwd failed: ", err)
}
defer os.Chdir(oldwd)
root, err := ioutil.TempDir("", "TestAbs")
if err != nil {
t.Fatal("TempDir failed: ", err)
}
defer os.RemoveAll(root)
wd, err := os.Getwd()
if err != nil {
t.Fatal("getwd failed: ", err)
}
err = os.Chdir(root)
if err != nil {
t.Fatal("chdir failed: ", err)
}
defer os.Chdir(wd)
for _, dir := range absTestDirs {
err = os.Mkdir(dir, 0777)
if err != nil {
t.Fatal("Mkdir failed: ", err)
}
}
err = os.Chdir(absTestDirs[0])
if err != nil {
t.Fatal("chdir failed: ", err)
}
for _, path := range absTests {
path = strings.Replace(path, "$", root, -1)
info, err := os.Stat(path)
if err != nil {
t.Errorf("%s: %s", path, err)
continue
}
abspath, err := filepath.Abs(path)
if err != nil {
t.Errorf("Abs(%q) error: %v", path, err)
continue
}
absinfo, err := os.Stat(abspath)
if err != nil || !os.SameFile(absinfo, info) {
t.Errorf("Abs(%q)=%q, not the same file", path, abspath)
}
if !filepath.IsAbs(abspath) {
t.Errorf("Abs(%q)=%q, not an absolute path", path, abspath)
}
if filepath.IsAbs(path) && abspath != filepath.Clean(path) {
t.Errorf("Abs(%q)=%q, isn't clean", path, abspath)
}
}
}
func (b *buildSuite) SetUpTest(c *gc.C) {
b.BaseSuite.SetUpTest(c)
dir1 := c.MkDir()
dir2 := c.MkDir()
c.Log(dir1)
c.Log(dir2)
path := os.Getenv("PATH")
os.Setenv("PATH", fmt.Sprintf("%s:%s:%s", dir1, dir2, path))
// Make an executable file called "juju-test" in dir2.
b.filePath = filepath.Join(dir2, "juju-test")
err := ioutil.WriteFile(
b.filePath,
[]byte("doesn't matter, we don't execute it"),
0755)
c.Assert(err, gc.IsNil)
cwd, err := os.Getwd()
c.Assert(err, gc.IsNil)
b.cwd = c.MkDir()
err = os.Chdir(b.cwd)
c.Assert(err, gc.IsNil)
b.restore = func() {
os.Setenv("PATH", path)
os.Chdir(cwd)
}
}
func downloadComicBook(bookName, url string) {
os.Mkdir(bookName, 0755|os.ModeDir)
os.Chdir(bookName)
urlArray := getImageUrls(url)
if urlArray == nil {
return
}
fmt.Printf("Downloading %s\n", bookName)
channel := make(chan int)
i := 0
for i < len(urlArray) && i < 10 {
imageUrl := urlArray[i]
i++
go downloadImage(imageUrl, getImageFilePath(imageUrl), channel)
}
successCount := 0
for successCount < len(urlArray) {
success := <-channel
if success == 1 {
successCount++
fmt.Printf("%d/%d\r", successCount, len(urlArray))
if i < len(urlArray) {
imageUrl := urlArray[i]
i++
go downloadImage(imageUrl, getImageFilePath(imageUrl), channel)
}
}
}
fmt.Printf("Complete downloading %s\n", bookName)
os.Chdir("..")
}
func compress(src string) {
archiver, _ := wpress.NewWriter(fmt.Sprintf("%s.wpress", src))
// Get current working folder
cwd, _ := os.Getwd()
// Go to destination folder
os.Chdir(src)
// List folder
folder := ""
files, _ := ioutil.ReadDir(".")
for _, f := range files {
if folder != "" {
folder = ""
break
} else {
folder = f.Name()
}
}
// Go to nested directory if necessary
if folder != "" {
os.Chdir(folder)
}
// Add directory recursively
archiver.AddDirectory(".")
archiver.Close()
// Go to previous folder
os.Chdir(cwd)
}
func TestZGlobAbs(t *testing.T) {
tmpdir := setup(t)
defer os.RemoveAll(tmpdir)
curdir, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
err = os.Chdir(tmpdir)
if err != nil {
t.Fatal(err)
}
defer os.Chdir(curdir)
for _, test := range testZGlobs {
test.pattern = filepath.ToSlash(filepath.Join(tmpdir, test.pattern))
for i, expected := range test.expected {
test.expected[i] = filepath.ToSlash(filepath.Join(tmpdir, expected))
}
got, err := Glob(test.pattern)
if err != nil {
if test.err != err {
t.Error(err)
}
continue
}
if !check(test.expected, got) {
t.Errorf(`zglob failed: pattern %q: expected %v but got %v`, test.pattern, test.expected, got)
}
}
}
func (diskio *DiskIO) Init() {
log.Println("DiskIO : Init : Started")
defer log.Println("DiskIO : Init : Completed")
if len(diskio.metaInfo.Info.Files) > 0 {
// Multiple File Mode
directory := diskio.metaInfo.Info.Name
// Create the directory if it doesn't exist
if _, err := os.Stat(directory); os.IsNotExist(err) {
err = os.Mkdir(directory, os.ModeDir|os.ModePerm)
checkError(err)
}
err := os.Chdir(directory)
checkError(err)
for _, file := range diskio.metaInfo.Info.Files {
// Create any sub-directories if required
if len(file.Path) > 1 {
directory = filepath.Join(file.Path[1:]...)
if _, err := os.Stat(directory); os.IsNotExist(err) {
err = os.MkdirAll(directory, os.ModeDir|os.ModePerm)
checkError(err)
}
}
// Create the file if it doesn't exist
name := filepath.Join(file.Path...)
diskio.files = append(diskio.files, openOrCreateFile(name))
}
err = os.Chdir("..")
checkError(err)
} else {
// Single File Mode
diskio.files = append(diskio.files, openOrCreateFile(diskio.metaInfo.Info.Name))
}
}
func TestZGlob(t *testing.T) {
tmpdir := setup(t)
defer os.RemoveAll(tmpdir)
curdir, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
err = os.Chdir(tmpdir)
if err != nil {
t.Fatal(err)
}
defer os.Chdir(curdir)
tmpdir = "."
for _, test := range testZGlobs {
got, err := Glob(test.pattern)
if err != nil {
if test.err != err {
t.Error(err)
}
continue
}
if !check(test.expected, got) {
t.Errorf(`zglob failed: pattern %q: expected %v but got %v`, test.pattern, test.expected, got)
}
}
}
func TestInit_cwd(t *testing.T) {
dir := tempDir(t)
if err := os.MkdirAll(dir, 0755); err != nil {
t.Fatalf("err: %s", err)
}
// Change to the temporary directory
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(dir); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
ui := new(cli.MockUi)
c := &InitCommand{
Meta: Meta{
ContextOpts: testCtxConfig(testProvider()),
Ui: ui,
},
}
args := []string{
testFixturePath("init"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
if _, err := os.Stat("hello.tf"); err != nil {
t.Fatalf("err: %s", err)
}
}
func TestPlan_stateDefault(t *testing.T) {
originalState := &terraform.State{
Resources: map[string]*terraform.ResourceState{
"test_instance.foo": &terraform.ResourceState{
ID: "bar",
Type: "test_instance",
},
},
}
// Write the state file in a temporary directory with the
// default filename.
td, err := ioutil.TempDir("", "tf")
if err != nil {
t.Fatalf("err: %s", err)
}
statePath := filepath.Join(td, DefaultStateFilename)
f, err := os.Create(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
err = terraform.WriteState(originalState, f)
f.Close()
if err != nil {
t.Fatalf("err: %s", err)
}
// Change to that directory
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(filepath.Dir(statePath)); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
p := testProvider()
ui := new(cli.MockUi)
c := &PlanCommand{
Meta: Meta{
ContextOpts: testCtxConfig(p),
Ui: ui,
},
}
args := []string{
testFixturePath("plan"),
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter.String())
}
// Verify that the provider was called with the existing state
expectedState := originalState.Resources["test_instance.foo"]
if !reflect.DeepEqual(p.DiffState, expectedState) {
t.Fatalf("bad: %#v", p.DiffState)
}
}
func extractTarball(r io.Reader, base string) error {
cwd, err := os.Getwd()
if err != nil {
return err
}
defer os.Chdir(cwd)
err = os.MkdirAll(base, 0755)
if err != nil {
return err
}
err = os.Chdir(base)
if err != nil {
return err
}
cmd := exec.Command("tar", "xz")
cmd.Stdin = r
err = cmd.Run()
if err != nil {
return err
}
return nil
}
func (this *hlsFile) write(data []byte) {
if this.fileHandler == nil {
this.fileName = this.generateFileName()
var err error
wd, _ := os.Getwd()
os.Chdir("../../")
this.fileHandler, err = os.OpenFile(this.fileName, os.O_CREATE|os.O_RDWR, 0777)
os.Chdir(wd)
if err != nil {
fmt.Println("write", err)
return
}
}
if this.begTime == 0 {
this.begTime = uint32(time.Now().UnixNano() / 1000 / 1000 / 1000)
}
now := uint32(time.Now().UnixNano() / 1000 / 1000 / 1000)
this.fileHandler.Write(data)
this.fileSize += uint32(len(data))
now -= this.begTime
if now >= TSFILEMAX_DURATION {
this.fileHandler.Close()
this.fileHandler = nil
this.begTime = 0
this.m3u8.Update(m3u8Tag{duration: now, url: this.fileName})
}
}
// Run is used to run the static website generator
func Run(c *config.Config) {
cwd, err := os.Getwd()
if err != nil {
log.Print("Can't get working directory.")
}
err = os.Chdir(c.Path)
if err != nil {
log.Print("Can't get working directory.")
}
viper.Reset()
commands.HugoCmd.ParseFlags(c.Args)
err = commands.HugoCmd.RunE(nil, nil)
if err != nil {
log.Print(err)
}
err = os.Chdir(cwd)
if err != nil {
log.Print("Can't get working directory.")
}
}
func (b *Buildpack) Run(appdir string) error {
b.env = newBuildEnv(appdir)
wd, _ := os.Getwd()
os.Chdir(b.env.buildDir)
detectCmd := exec.Command(b.detect, b.env.buildDir)
if err := execCmd(detectCmd, os.Stdout, os.Stderr); err != nil {
return nil
}
compileCmd := exec.Command(b.compile, b.env.buildDir, b.env.cacheDir, b.env.envFile)
if err := execCmd(compileCmd, os.Stdout, os.Stderr); err != nil {
return err
}
releaseCmd := exec.Command(b.release, b.env.buildDir)
releaseOut := new(bytes.Buffer)
if err := execCmd(releaseCmd, releaseOut, os.Stderr); err != nil {
return err
}
writeProcfile(b.env, releaseOut.Bytes())
os.Chdir(wd)
return nil
}
func runChroot(cmd *cobra.Command, args []string) {
runtime.LockOSThread()
err := syscall.Chroot(flagChroot)
if err != nil {
errAndExit("couldn't chroot: %v", err)
}
err = os.Chdir("/")
if err != nil {
errAndExit("couldn't cd: %v", err)
}
if flagWorkingDir != "" {
err = os.Chdir(flagWorkingDir)
if err != nil {
errAndExit("couldn't cd: %v", err)
}
}
execCmd := exec.Command(flagCmd, flagArgs...)
execCmd.Env = flagEnv
execCmd.Stdin = os.Stdin
execCmd.Stdout = os.Stdout
execCmd.Stderr = os.Stderr
err = execCmd.Run()
if err != nil {
if exitErr, ok := err.(*exec.ExitError); ok {
code := exitErr.Sys().(syscall.WaitStatus).ExitStatus()
os.Exit(code)
}
errAndExit("%v", err)
}
}
func (s *DockerSuite) TestCpToDot(c *check.C) {
out, exitCode := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "echo lololol > /test")
if exitCode != 0 {
c.Fatal("failed to create a container", out)
}
cleanedContainerID := strings.TrimSpace(out)
out, _ = dockerCmd(c, "wait", cleanedContainerID)
if strings.TrimSpace(out) != "0" {
c.Fatal("failed to set up container", out)
}
tmpdir, err := ioutil.TempDir("", "docker-integration")
if err != nil {
c.Fatal(err)
}
defer os.RemoveAll(tmpdir)
cwd, err := os.Getwd()
if err != nil {
c.Fatal(err)
}
defer os.Chdir(cwd)
if err := os.Chdir(tmpdir); err != nil {
c.Fatal(err)
}
_, _ = dockerCmd(c, "cp", cleanedContainerID+":/test", ".")
content, err := ioutil.ReadFile("./test")
if string(content) != "lololol\n" {
c.Fatalf("Wrong content in copied file %q, should be %q", content, "lololol\n")
}
}
func TestGraph_noArgs(t *testing.T) {
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(testFixturePath("graph")); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
ui := new(cli.MockUi)
c := &GraphCommand{
Meta: Meta{
ContextOpts: testCtxConfig(testProvider()),
Ui: ui,
},
}
args := []string{}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
output := ui.OutputWriter.String()
if !strings.Contains(output, "provider.test") {
t.Fatalf("doesn't look like digraph: %s", output)
}
}
func goTests(output string) error {
// Change directory to artifact directory root
if err := os.Chdir(output); err != nil {
return err
}
defer func() {
// Back to src directory
if err := os.Chdir(".."); err != nil {
// Should not reach here
panic(err)
}
}()
funcs := []func(output string) error{
goGet,
goBuild,
goTest,
goVet,
}
for _, gf := range funcs {
err := gf(output)
if err != nil {
return err
}
}
return nil
}
func TestAbs(t *testing.T) {
oldwd, err := os.Getwd()
if err != nil {
t.Fatal("Getwd failed: " + err.String())
}
defer os.Chdir(oldwd)
goroot := os.Getenv("GOROOT")
cwd := filepath.Join(goroot, "src")
os.Chdir(cwd)
for _, path := range abstests {
path = strings.Replace(path, "$GOROOT", goroot, -1)
abspath, err := filepath.Abs(path)
if err != nil {
t.Errorf("Abs(%q) error: %v", path, err)
}
info, err := os.Stat(path)
if err != nil {
t.Errorf("%s: %s", path, err)
}
absinfo, err := os.Stat(abspath)
if err != nil || absinfo.Ino != info.Ino {
t.Errorf("Abs(%q)=%q, not the same file", path, abspath)
}
if !filepath.IsAbs(abspath) {
t.Errorf("Abs(%q)=%q, not an absolute path", path, abspath)
}
if filepath.IsAbs(path) && abspath != filepath.Clean(path) {
t.Errorf("Abs(%q)=%q, isn't clean", path, abspath)
}
}
}
func At(there string, fn func() error) (err []error) {
origin, err_ := os.Getwd()
if err_ != nil {
origin = ""
return []error{err_, nil}
}
err_ = os.Chdir(there)
if err_ != nil {
origin = ""
return []error{err_, nil}
}
defer func() {
if origin != "" {
err_ = os.Chdir(origin)
if err != nil {
err[0] = err_
} else {
err = []error{err_, nil}
}
}
}()
err_ = fn()
if err_ != nil {
return []error{nil, err_}
}
return nil
}
func TestOutput_stateDefault(t *testing.T) {
originalState := &terraform.State{
Modules: []*terraform.ModuleState{
&terraform.ModuleState{
Path: []string{"root"},
Outputs: map[string]string{
"foo": "bar",
},
},
},
}
// Write the state file in a temporary directory with the
// default filename.
td, err := ioutil.TempDir("", "tf")
if err != nil {
t.Fatalf("err: %s", err)
}
statePath := filepath.Join(td, DefaultStateFilename)
f, err := os.Create(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
err = terraform.WriteState(originalState, f)
f.Close()
if err != nil {
t.Fatalf("err: %s", err)
}
// Change to that directory
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(filepath.Dir(statePath)); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
ContextOpts: testCtxConfig(testProvider()),
Ui: ui,
},
}
args := []string{
"foo",
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
if actual != "bar" {
t.Fatalf("bad: %#v", actual)
}
}
// load the packets for a file
func (f *FileHeader) LoadPackets() {
curDir, _ := os.Getwd()
// calculate number of packets
numPackets := int(f.Info.FileSize) / gPacketSize
f.Packets = make(map[ID]Packet, numPackets+1)
// open the directory containing the packet files
dir, err := os.Open(gShareDirectory + "/" + f.PacketDir)
if err != nil {
log.Fatal("Open: ", err)
}
packet_files, err := dir.Readdir(0)
if err != nil {
log.Fatal("Readdir: ", err)
}
os.Chdir(f.PacketDir)
// fill each packet with the appropriate data
for i := 0; i < len(packet_files); i++ {
fi := packet_files[i]
var p Packet
// read the file into a byte array
fbytes, err := ioutil.ReadFile(fi.Name())
if err != nil {
log.Fatal("ReadFile: ", err)
}
copy(p.Data, fbytes)
p.PacketID = p.sha1hash()
p.PacketSize = len(fbytes)
f.Packets[p.PacketID] = p
}
os.Chdir(curDir)
return
}
func TestVendor(t *testing.T) {
td, err := filepath.Abs(testdata)
if err != nil {
t.Fatal(err)
}
wd, _ := os.Getwd()
os.Chdir(filepath.Join(td, "a/b/c"))
res, err := Vendor()
if err != nil {
t.Errorf("Failed to resolve vendor directory: %s", err)
}
expect := filepath.Join(td, "a", "vendor")
if res != expect {
t.Errorf("Failed to find vendor: expected %s got %s", expect, res)
}
os.Chdir(filepath.Join(td, "x/y/z"))
res, err = Vendor()
if err != nil {
t.Errorf("Failed to resolve vendor directory: %s", err)
}
expect = filepath.Join(td, "x", "symlinked_vendor")
if res != expect {
t.Errorf("Failed to find vendor: expected %s got %s", expect, res)
}
os.Chdir(wd)
}
func UpgradeTest(args string) bool {
old, err := os.Getwd()
if err != nil {
log.Printf("Failed to os.Getwd(): %v", err)
return false
}
defer os.Chdir(old)
err = os.Chdir("../kubernetes_skew")
if err != nil {
log.Printf("Failed to cd ../kubernetes_skew: %v", err)
return false
}
previous, present := os.LookupEnv("E2E_REPORT_PREFIX")
if present {
defer os.Setenv("E2E_REPORT_PREFIX", previous)
} else {
defer os.Unsetenv("E2E_REPORT_PREFIX")
}
os.Setenv("E2E_REPORT_PREFIX", "upgrade")
return finishRunning("Upgrade Ginkgo tests",
exec.Command(
"go", "run", "./hack/e2e.go",
"--test",
"--test_args="+args,
fmt.Sprintf("--v=%t", *verbose),
fmt.Sprintf("--check_version_skew=%t", *checkVersionSkew)))
}
func doRelease(commit string) error {
if err := os.Chdir("working"); err != nil {
errors.New("Failed to chdir to working\n")
return err
}
// Deploy.
out, err := exec.Command("git", "pull", "origin", branch).Output()
if err != nil {
log("Failed to update working copy.")
return err
}
log(string(out))
if err := os.Chdir("../"); err != nil {
log("Failed to chdir to working\n")
return err
}
t := time.Now()
releasedir := "releases/" + fmt.Sprintf("%d-%02d-%02d.%02d%02d%02d.%s", t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), commit)
log("Release to: " + releasedir + "\n")
err = CopyDir("working", releasedir)
if err != nil {
return err
}
os.Remove("current")
err = os.Symlink(releasedir, "current")
if err != nil {
return err
}
return nil
}
func makeTestDir(t *testing.T) string {
cwd, err := os.Getwd()
TestExpectSuccess(t, err)
AddTestFinalizer(func() {
TestExpectSuccess(t, os.Chdir(cwd))
})
dir := TempDir(t)
TestExpectSuccess(t, os.Chdir(dir))
mode := os.FileMode(0755)
os.Mkdir(cwd, mode) //Don't care about return value. For some reason CWD is not created by go test on all systems.
TestExpectSuccess(t, os.Mkdir("a", mode))
TestExpectSuccess(t, os.Mkdir("a/b", mode))
TestExpectSuccess(t, os.Mkdir("a/b/c", mode))
TestExpectSuccess(t, os.Mkdir("a/b/c/d", mode))
TestExpectSuccess(t, os.Mkdir("a/b/i", mode))
TestExpectSuccess(t, os.Mkdir("a/b/i/j", mode))
TestExpectSuccess(t, ioutil.WriteFile("a/b/c/d/e", []byte{}, mode))
TestExpectSuccess(t, ioutil.WriteFile("a/b/c/f", []byte{}, mode))
TestExpectSuccess(t, ioutil.WriteFile("a/b/g", []byte{}, mode))
TestExpectSuccess(t, ioutil.WriteFile("a/b/i/j/k", []byte{}, mode))
TestExpectSuccess(t, os.Symlink("/bin/bash", "a/b/bash"))
TestExpectSuccess(t, os.Symlink("../i", "a/b/c/l"))
TestExpectSuccess(t, os.Symlink("g", "a/b/h"))
TestExpectSuccess(t, os.Symlink("k", "a/b/i/j/l"))
TestExpectSuccess(t, os.Symlink("../../g", "a/b/i/j/m"))
return dir
}
