func main() { var err error var res *check.Result // defer exiting so it runs after all other defers defer func() { if err != nil || res != nil && !res.Passed() { os.Exit(1) } }() flynnrc = args.Flynnrc routerIP = args.RouterIP if flynnrc == "" { var rootFS string c := cluster.New(args.BootConfig, os.Stdout) rootFS, err = c.BuildFlynn(args.RootFS, "origin/master", false) if err != nil { c.Shutdown() log.Println("could not build flynn: ", err) return } if args.KeepRootFS { fmt.Println("Built Flynn in rootfs:", rootFS) } else { defer os.RemoveAll(rootFS) } if err = c.Boot(args.Backend, rootFS, 1); err != nil { log.Println("could not boot cluster: ", err) return } if args.Kill { defer c.Shutdown() } if err = createFlynnrc(c); err != nil { log.Println(err) return } defer os.RemoveAll(flynnrc) routerIP = c.RouterIP } defer func() { if args.Debug && (err != nil || res != nil && !res.Passed()) { dumpLogs() } }() res = check.RunAll(&check.RunConf{ Filter: args.Run, Stream: true, Verbose: true, KeepWorkDir: args.Debug, }) fmt.Println(res) }
func (r *Runner) build(b *Build) (err error) { r.updateStatus(b, "pending", "") <-r.buildCh defer func() { r.buildCh <- struct{}{} }() var buildLog bytes.Buffer defer func() { if err != nil { fmt.Fprintf(&buildLog, "build error: %s\n", err) } url := r.uploadToS3(buildLog, b) if err == nil { r.updateStatus(b, "success", url) } else { r.updateStatus(b, "failure", url) } }() log.Printf("building %s[%s]\n", b.Repo, b.Commit) out := io.MultiWriter(os.Stdout, &buildLog) bc := r.bc bc.Network, err = r.allocateNet() if err != nil { return err } defer r.releaseNet(bc.Network) c := cluster.New(bc, out) rootFS, err := c.BuildFlynn(r.rootFS, b.Commit) defer os.RemoveAll(rootFS) if err != nil { return fmt.Errorf("could not build flynn: %s", err) } if err := c.Boot(args.Backend, rootFS, 1); err != nil { return fmt.Errorf("could not boot cluster: %s", err) } defer c.Shutdown() config, err := c.CLIConfig() if err != nil { return fmt.Errorf("could not generate flynnrc: %s", err) } var script bytes.Buffer testRunScript.Execute(&script, c) return c.Run(script.String(), &cluster.Streams{ Stdin: bytes.NewBuffer(config.Marshal()), Stdout: out, Stderr: out, }) }
func main() { var res *check.Result // defer exiting so it runs after all other defers defer func() { if res != nil && !res.Passed() { os.Exit(1) } }() flynnrc = args.Flynnrc routerIP = args.RouterIP if flynnrc == "" { c := cluster.New(args.BootConfig, os.Stdout) rootFS, err := c.BuildFlynn(args.RootFS, "origin/master") if err != nil { log.Fatal("could not build flynn:", err) } if args.KeepRootFS { fmt.Println("Built Flynn in rootfs:", rootFS) } else { defer os.RemoveAll(rootFS) } if err := c.Boot(args.Backend, rootFS, 1); err != nil { log.Fatal("could not boot cluster: ", err) } if args.Kill { defer c.Shutdown() } if err := createFlynnrc(c); err != nil { log.Fatal(err) } defer os.RemoveAll(flynnrc) routerIP = c.RouterIP } ssh, err := genSSHKey() if err != nil { log.Fatal(err) } defer ssh.Cleanup() gitEnv = ssh.Env keyAdd := flynn("", "key", "add", ssh.Pub) if keyAdd.Err != nil { log.Fatalf("Error during `%s`:\n%s%s", strings.Join(keyAdd.Cmd, " "), keyAdd.Output, keyAdd.Err) } res = check.RunAll(&check.RunConf{ Stream: true, Verbose: true, KeepWorkDir: args.Debug, }) fmt.Println(res) }
func main() { flynnrc = args.Flynnrc if flynnrc == "" { c := cluster.New(args.BootConfig, os.Stdout) dockerfs := args.DockerFS if dockerfs == "" { var err error if dockerfs, err = c.BuildFlynn("", util.Repos); err != nil { log.Fatal("could not build flynn:", err) } if !args.KeepDockerFS { defer os.RemoveAll(dockerfs) } } if err := c.Boot(dockerfs, 1); err != nil { log.Fatal("could not boot cluster: ", err) } if args.Kill { defer c.Shutdown() } if err := createFlynnrc(c); err != nil { log.Fatal(err) } defer os.RemoveAll(flynnrc) } ssh, err := genSSHKey() if err != nil { log.Fatal(err) } defer ssh.Cleanup() gitEnv = ssh.Env keyAdd := flynn("", "key-add", ssh.Pub) if keyAdd.Err != nil { log.Fatalf("Error during `%s`:\n%s%s", strings.Join(keyAdd.Cmd, " "), keyAdd.Output, keyAdd.Err) } res := check.RunAll(&check.RunConf{ Stream: true, Verbose: true, KeepWorkDir: args.Debug, }) fmt.Println(res) }
func (r *Runner) build(b *Build) (err error) { logFile, err := ioutil.TempFile("", "build-log") if err != nil { return err } b.LogFile = logFile.Name() buildLog := buildlog.NewLog(logFile) mainLog, err := buildLog.NewFile("build.log") if err != nil { return err } r.updateStatus(b, "pending") <-r.buildCh defer func() { r.buildCh <- struct{}{} }() start := time.Now() fmt.Fprintf(mainLog, "Starting build of %s at %s\n", b.Commit, start.Format(time.RFC822)) var c *cluster.Cluster defer func() { b.Duration = time.Since(start) b.DurationFormatted = formatDuration(b.Duration) fmt.Fprintf(mainLog, "build finished in %s\n", b.DurationFormatted) if err != nil { fmt.Fprintf(mainLog, "build error: %s\n", err) fmt.Fprintln(mainLog, "DUMPING LOGS") c.DumpLogs(buildLog) } c.Shutdown() buildLog.Close() b.LogURL = r.uploadToS3(logFile, b, buildLog.Boundary()) logFile.Close() os.RemoveAll(b.LogFile) b.LogFile = "" if err == nil { log.Printf("build %s passed!\n", b.ID) r.updateStatus(b, "success") r.ircMsgs <- fmt.Sprintf("PASS: %s %s", b.Description, b.URL()) } else { log.Printf("build %s failed: %s\n", b.ID, err) r.updateStatus(b, "failure") r.ircMsgs <- fmt.Sprintf("FAIL: %s %s", b.Description, b.URL()) } }() log.Printf("building %s\n", b.Commit) out := &iotool.SafeWriter{W: io.MultiWriter(os.Stdout, mainLog)} bc := r.bc bc.Network = r.allocateNet() defer r.releaseNet(bc.Network) c = cluster.New(bc, out) log.Println("created cluster with ID", c.ID) r.clusters[c.ID] = c defer func() { delete(r.clusters, c.ID) }() rootFS, err := c.BuildFlynn(r.rootFS, b.Commit, b.Merge, true) defer removeRootFS(rootFS) if err != nil { return fmt.Errorf("could not build flynn: %s", err) } if _, err := c.Boot(cluster.ClusterTypeDefault, 3, buildLog, false); err != nil { return fmt.Errorf("could not boot cluster: %s", err) } config, err := c.CLIConfig() if err != nil { return fmt.Errorf("could not generate flynnrc: %s", err) } var script bytes.Buffer testRunScript.Execute(&script, map[string]interface{}{"Cluster": c, "Config": config.Clusters[0], "ListenPort": listenPort}) return c.RunWithEnv(script.String(), &cluster.Streams{ Stdout: out, Stderr: out, }, map[string]string{"TEST_RUNNER_AUTH_KEY": r.authKey}) }
func (r *Runner) build(b *Build) (err error) { r.updateStatus(b, "pending", "") <-r.buildCh defer func() { r.buildCh <- struct{}{} }() var buildLog bytes.Buffer start := time.Now() fmt.Fprintf(&buildLog, "Starting build of %s at %s\n", b.Commit, start.Format(time.RFC822)) defer func() { b.Duration = time.Since(start) b.DurationFormatted = formatDuration(b.Duration) fmt.Fprintf(&buildLog, "build finished in %s\n", b.DurationFormatted) if err != nil { fmt.Fprintf(&buildLog, "build error: %s\n", err) } url := r.uploadToS3(buildLog, b) if err == nil { r.updateStatus(b, "success", url) } else { r.updateStatus(b, "failure", url) } }() log.Printf("building %s[%s]\n", b.Repo, b.Commit) out := io.MultiWriter(os.Stdout, &buildLog) bc := r.bc bc.Network, err = r.allocateNet() if err != nil { return err } defer r.releaseNet(bc.Network) c := cluster.New(bc, out) log.Println("created cluster with ID", c.ID) r.clusters[c.ID] = c defer func() { delete(r.clusters, c.ID) c.Shutdown() }() rootFS, err := c.BuildFlynn(r.rootFS, b.Commit, b.Merge) defer os.RemoveAll(rootFS) if err != nil { return fmt.Errorf("could not build flynn: %s", err) } if err := c.Boot(rootFS, 3); err != nil { return fmt.Errorf("could not boot cluster: %s", err) } config, err := c.CLIConfig() if err != nil { return fmt.Errorf("could not generate flynnrc: %s", err) } var script bytes.Buffer testRunScript.Execute(&script, map[string]interface{}{"Cluster": c, "ListenPort": listenPort, "AuthKey": r.authKey}) return c.Run(script.String(), &cluster.Streams{ Stdin: bytes.NewBuffer(config.Marshal()), Stdout: out, Stderr: out, }) }
func main() { var err error var res *check.Result // defer exiting here so it runs after all other defers defer func() { if err != nil || res != nil && !res.Passed() { if args.Debug { if args.Gist { exec.Command("flynn-host", "upload-debug-info").Run() } else { dumpLogs() } } os.Exit(1) } }() flynnrc = args.Flynnrc routerIP = args.RouterIP if flynnrc == "" { var rootFS string testCluster = cluster.New(args.BootConfig, os.Stdout) rootFS, err = testCluster.BuildFlynn(args.RootFS, "origin/master", false) if err != nil { testCluster.Shutdown() log.Println("could not build flynn: ", err) return } if args.KeepRootFS { fmt.Println("Built Flynn in rootfs:", rootFS) } else { defer os.RemoveAll(rootFS) } if err = testCluster.Boot(rootFS, 3); err != nil { log.Println("could not boot cluster: ", err) return } if args.Kill { defer testCluster.Shutdown() } if err = createFlynnrc(); err != nil { log.Println(err) return } defer os.RemoveAll(flynnrc) routerIP = testCluster.RouterIP } if args.ClusterAPI != "" { httpClient = &http.Client{Transport: &http.Transport{TLSClientConfig: &tls.Config{ServerName: "ci.flynn.io"}}} res, err := httpClient.Get(args.ClusterAPI) if err != nil { log.Println(err) return } testCluster = &cluster.Cluster{} err = json.NewDecoder(res.Body).Decode(testCluster) res.Body.Close() if err != nil { log.Println(err) return } } res = check.RunAll(&check.RunConf{ Filter: args.Run, Stream: args.Stream, Verbose: args.Debug, KeepWorkDir: args.Debug, ConcurrencyLevel: 5, }) fmt.Println(res) }
func main() { defer shutdown.Exit() var err error if err = lookupImageURIs(); err != nil { log.Fatalf("could not determine image ID: %s", err) } var res *check.Result // defer exiting here so it runs after all other defers defer func() { if err != nil || res != nil && !res.Passed() { os.Exit(1) } }() flynnrc = args.Flynnrc routerIP = args.RouterIP if flynnrc == "" { c := cluster.New(args.BootConfig, os.Stdout) var rootFS string rootFS, err = c.BuildFlynn(args.RootFS, "origin/master", false, false) if err != nil { if args.Kill { c.Shutdown() } log.Println("could not build flynn: ", err) if rootFS != "" { os.RemoveAll(rootFS) } return } if args.BuildRootFS { c.Shutdown() fmt.Println("Built Flynn in rootfs:", rootFS) return } else { defer os.RemoveAll(rootFS) } if _, err = c.Boot(cluster.ClusterTypeDefault, 3, nil, args.Kill); err != nil { log.Println("could not boot cluster: ", err) return } if args.Kill { defer c.Shutdown() } if err = createFlynnrc(c); err != nil { log.Println(err) return } defer os.RemoveAll(flynnrc) routerIP = c.RouterIP } if args.ClusterAPI != "" { testCluster, err = testcluster.NewClient(args.ClusterAPI) if err != nil { log.Println(err) return } } res = check.RunAll(&check.RunConf{ Filter: args.Run, Stream: args.Stream, Verbose: args.Debug, KeepWorkDir: args.Debug, ConcurrencyLevel: args.Concurrency, }) fmt.Println(res) }