// AddRequestHeaders add a few default headers to req. Currently added: User- // Agent, X-Wercker-Version, X-Wercker-Git. func AddRequestHeaders(req *http.Request) { userAgent := fmt.Sprintf("wercker %s", util.FullVersion()) req.Header.Set("User-Agent", userAgent) req.Header.Set("X-Wercker-Version", util.Version()) if util.GitCommit != "" { req.Header.Set("X-Wercker-Git", util.GitCommit) } }
func GetApp() *cli.App { // logger.SetLevel(logger.DebugLevel) // util.RootLogger().SetLevel("debug") // util.RootLogger().Formatter = &logger.JSONFormatter{} app := cli.NewApp() setupUsageFormatter(app) app.Author = "Team wercker" app.Name = "wercker" app.Usage = "build and deploy from the command line" app.Email = "*****@*****.**" app.Version = util.FullVersion() app.Flags = FlagsFor(GlobalFlagSet) app.Commands = []cli.Command{ buildCommand, devCommand, checkConfigCommand, deployCommand, detectCommand, // inspectCommand, loginCommand, logoutCommand, pullCommand, versionCommand, documentCommand(app), } app.Before = func(ctx *cli.Context) error { if ctx.GlobalBool("debug") { util.RootLogger().Formatter = &util.VerboseFormatter{} util.RootLogger().SetLevel("debug") } else { util.RootLogger().Formatter = &util.TerseFormatter{} util.RootLogger().SetLevel("info") } if ctx.GlobalBool("journal") { util.RootLogger().Hooks.Add(&journalhook.JournalHook{}) util.RootLogger().Out = ioutil.Discard } // Register the global signal handler util.GlobalSigint().Register(os.Interrupt) util.GlobalSigterm().Register(unix.SIGTERM) return nil } return app }
// SetupEnvironment does a lot of boilerplate legwork and returns a pipeline, // box, and session. This is a bit of a long method, but it is pretty much // the entire "Setup Environment" step. func (p *Runner) SetupEnvironment(runnerCtx context.Context) (*RunnerShared, error) { shared := &RunnerShared{} f := &util.Formatter{p.options.GlobalOptions.ShowColors} timer := util.NewTimer() sr := &StepResult{ Success: false, Artifact: nil, Message: "", ExitCode: 1, } setupEnvironmentStep := &core.ExternalStep{ BaseStep: core.NewBaseStep(core.BaseStepOptions{ Name: "setup environment", Owner: "wercker", Version: util.Version(), }), } finisher := p.StartStep(shared, setupEnvironmentStep, 2) defer finisher.Finish(sr) if p.options.Verbose { p.emitter.Emit(core.Logs, &core.LogsArgs{ Logs: fmt.Sprintf("Running wercker version: %s\n", util.FullVersion()), }) } p.logger.Debugln("Application:", p.options.ApplicationName) // Grab our config rawConfig, stringConfig, err := p.GetConfig() if err != nil { sr.Message = err.Error() return shared, err } shared.config = rawConfig sr.WerckerYamlContents = stringConfig // Init the pipeline pipeline, err := p.GetPipeline(rawConfig) if err != nil { sr.Message = err.Error() return shared, err } pipeline.InitEnv(p.options.HostEnv) shared.pipeline = pipeline if p.options.Verbose { p.emitter.Emit(core.Logs, &core.LogsArgs{ Logs: fmt.Sprintf("Using config:\n%s\n", stringConfig), }) } // Fetch the box timer.Reset() box := pipeline.Box() _, err = box.Fetch(runnerCtx, pipeline.Env()) if err != nil { sr.Message = err.Error() return shared, err } // TODO(termie): dump some logs about the image shared.box = box if p.options.Verbose { p.logger.Printf(f.Success(fmt.Sprintf("Fetched %s", box.GetName()), timer.String())) } // Fetch the services and add them to the box if err := p.AddServices(runnerCtx, pipeline, box); err != nil { sr.Message = err.Error() return shared, err } // Start setting up the pipeline dir p.logger.Debugln("Copying source to build directory") err = p.CopySource() if err != nil { sr.Message = err.Error() return shared, err } // ... and the cache dir p.logger.Debugln("Copying cache to build directory") err = p.CopyCache() if err != nil { sr.Message = err.Error() return shared, err } p.logger.Debugln("Steps:", len(pipeline.Steps())) // Fetch the steps steps := pipeline.Steps() for _, step := range steps { timer.Reset() if _, err := step.Fetch(); err != nil { sr.Message = err.Error() return shared, err } if p.options.Verbose { p.logger.Printf(f.Success("Prepared step", step.Name(), timer.String())) } } // ... and the after steps afterSteps := pipeline.AfterSteps() for _, step := range afterSteps { timer.Reset() if _, err := step.Fetch(); err != nil { sr.Message = err.Error() return shared, err } if p.options.Verbose { p.logger.Printf(f.Success("Prepared step", step.Name(), timer.String())) } } // Boot up our main container, it will run the services container, err := box.Run(runnerCtx, pipeline.Env()) if err != nil { sr.Message = err.Error() return shared, err } shared.containerID = container.ID // Register our signal handler to clean the box up // NOTE(termie): we're expecting that this is going to be the last handler // to be run since it calls exit, in the future we might be // able to do something like close the calling context and // short circuit / let the rest of things play out boxCleanupHandler := &util.SignalHandler{ ID: "box-cleanup", F: func() bool { p.logger.Errorln("Interrupt detected, cleaning up containers and shutting down") box.Stop() if p.options.ShouldRemove { box.Clean() } os.Exit(1) return true }, } util.GlobalSigint().Add(boxCleanupHandler) util.GlobalSigterm().Add(boxCleanupHandler) p.logger.Debugln("Attaching session to base box") // Start our session sessionCtx, sess, err := p.GetSession(runnerCtx, container.ID) if err != nil { sr.Message = err.Error() return shared, err } shared.sess = sess shared.sessionCtx = sessionCtx // Some helpful logging pipeline.LogEnvironment() p.logger.Debugln("Setting up guest (base box)") err = pipeline.SetupGuest(sessionCtx, sess) if err != nil { sr.Message = err.Error() return shared, err } err = pipeline.ExportEnvironment(sessionCtx, sess) if err != nil { sr.Message = err.Error() return shared, err } sr.Message = "" sr.Success = true sr.ExitCode = 0 return shared, nil }