func runVerify(c *cli.Context) { config := common.NewConfig() err := config.LoadConfig(c.String("config")) if err != nil { log.Fatalln(err) return } // verify if runner exist runners := []*common.RunnerConfig{} for _, runner := range config.Runners { if common.VerifyRunner(runner.URL, runner.Token) { runners = append(runners, runner) } } if !c.Bool("delete") { return } // check if anything changed if len(config.Runners) == len(runners) { return } config.Runners = runners // save config file err = config.SaveConfig(c.String("config")) if err != nil { log.Fatalln("Failed to update", c.String("config"), err) } log.Println("Updated", c.String("config")) }
func (c *configOptions) loadConfig() error { config := common.NewConfig() err := config.LoadConfig(c.ConfigFile) if err != nil { return err } c.config = config return nil }
func (mr *MultiRunner) loadConfig() error { newConfig := common.NewConfig() err := newConfig.LoadConfig(mr.configFile) if err != nil { return err } mr.healthy = nil mr.config = newConfig return nil }
func (mr *MultiRunner) loadConfig() error { newConfig := common.NewConfig() err := newConfig.LoadConfig(mr.configFile) if err != nil { return err } // pass user to execute scripts as specific user if mr.user != "" { newConfig.User = &mr.user } mr.healthy = nil mr.config = newConfig return nil }
func runUnregister(c *cli.Context) { runner := common.RunnerConfig{ URL: c.String("url"), Token: c.String("token"), } if !common.DeleteRunner(runner.URL, runner.Token) { log.Fatalln("Failed to delete runner") } config := common.NewConfig() err := config.LoadConfig(c.String("config")) if err != nil { return } runners := []*common.RunnerConfig{} for _, otherRunner := range config.Runners { if otherRunner.Token == runner.Token && otherRunner.URL == runner.URL { continue } runners = append(runners, otherRunner) } // check if anything changed if len(config.Runners) == len(runners) { return } config.Runners = runners // save config file err = config.SaveConfig(c.String("config")) if err != nil { log.Fatalln("Failed to update", c.String("config"), err) } log.Println("Updated", c.String("config")) }
func runServiceInstall(s service.Service, c *cli.Context) error { if user := c.String("user"); user == "" && os.Getuid() == 0 { log.Fatal("Please specify user that will run gitlab-runner service") } if configFile := c.String("config"); configFile != "" { // try to load existing config config := common.NewConfig() err := config.LoadConfig(configFile) if err != nil { return err } // save config for the first time if !config.Loaded { err = config.SaveConfig(configFile) if err != nil { return err } } } return service.Control(s, "install") }
func runRegister(c *cli.Context) { s := RegistrationContext{ Context: c, config: common.NewConfig(), configFile: c.String("config"), reader: bufio.NewReader(os.Stdin), } defer func() { if r := recover(); r != nil { log.Fatalf("FATAL ERROR: %v", r) } }() s.loadConfig() runnerConfig := s.askRunner() if !c.Bool("leave-runner") { defer func() { if r := recover(); r != nil { common.DeleteRunner(runnerConfig.URL, runnerConfig.Token) // pass panic to next defer panic(r) } }() signals := make(chan os.Signal, 1) signal.Notify(signals, os.Interrupt) go func() { s := <-signals common.DeleteRunner(runnerConfig.URL, runnerConfig.Token) log.Fatalf("RECEIVED SIGNAL: %v", s) }() } runnerConfig.Executor = s.askExecutor() limit := c.Int("limit") runnerConfig.Limit = &limit if s.config.Concurrent < limit { log.Warningf("Specified limit (%d) larger then current concurrent limit (%d). Concurrent limit will not be enlarged.", limit, s.config.Concurrent) } switch runnerConfig.Executor { case "docker", "docker-ssh": s.askDocker(&runnerConfig) case "parallels": s.askParallels(&runnerConfig) } switch runnerConfig.Executor { case "ssh": s.askSSH(&runnerConfig, false) case "docker-ssh": s.askSSH(&runnerConfig, true) case "parallels": s.askSSH(&runnerConfig, true) } s.addRunner(&runnerConfig) s.saveConfig() log.Printf("Runner registered successfully. Feel free to start it, but if it's running already the config should be automatically reloaded!") }
func runSingle(c *cli.Context) { buildsDir := c.String("builds-dir") shell := c.String("shell") config := common.NewConfig() runner := common.RunnerConfig{ URL: c.String("url"), Token: c.String("token"), Executor: c.String("executor"), BuildsDir: &buildsDir, Shell: &shell, } if len(runner.URL) == 0 { log.Fatalln("Missing URL") } if len(runner.Token) == 0 { log.Fatalln("Missing Token") } if len(runner.Executor) == 0 { log.Fatalln("Missing Executor") } go runServer(c.String("addr")) go runHerokuURL(c.String("heroku-url")) signals := make(chan os.Signal) signal.Notify(signals, os.Interrupt, syscall.SIGTERM) log.Println("Starting runner for", runner.URL, "with token", runner.ShortDescription(), "...") finished := false abortSignal := make(chan os.Signal) doneSignal := make(chan int, 1) go func() { interrupt := <-signals log.Warningln("Requested exit:", interrupt) finished = true go func() { for { abortSignal <- interrupt } }() select { case newSignal := <-signals: log.Fatalln("forced exit:", newSignal) case <-time.After(common.ShutdownTimeout * time.Second): log.Fatalln("shutdown timedout") case <-doneSignal: } }() for !finished { buildData, healthy := common.GetBuild(runner) if !healthy { log.Println("Runner is not healthy!") select { case <-time.After(common.NotHealthyCheckInterval * time.Second): case <-abortSignal: } continue } if buildData == nil { select { case <-time.After(common.CheckInterval * time.Second): case <-abortSignal: } continue } newBuild := common.Build{ GetBuildResponse: *buildData, Runner: &runner, BuildAbort: abortSignal, } newBuild.AssignID() newBuild.Run(config) } doneSignal <- 0 }
func (r *RunSingleCommand) Execute(c *cli.Context) { if len(r.URL) == 0 { log.Fatalln("Missing URL") } if len(r.Token) == 0 { log.Fatalln("Missing Token") } if len(r.Executor) == 0 { log.Fatalln("Missing Executor") } config := common.NewConfig() signals := make(chan os.Signal) signal.Notify(signals, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT) log.Println("Starting runner for", r.URL, "with token", r.ShortDescription(), "...") finished := false abortSignal := make(chan os.Signal) doneSignal := make(chan int, 1) go func() { interrupt := <-signals finished = true // request stop, but wait for force exit for interrupt == syscall.SIGQUIT { log.Warningln("Requested quit, waiting for builds to finish") interrupt = <-signals } log.Warningln("Requested exit:", interrupt) go func() { for { abortSignal <- interrupt } }() select { case newSignal := <-signals: log.Fatalln("forced exit:", newSignal) case <-time.After(common.ShutdownTimeout * time.Second): log.Fatalln("shutdown timedout") case <-doneSignal: } }() for !finished { buildData, healthy := common.GetBuild(r.RunnerConfig) if !healthy { log.Println("Runner is not healthy!") select { case <-time.After(common.NotHealthyCheckInterval * time.Second): case <-abortSignal: } continue } if buildData == nil { select { case <-time.After(common.CheckInterval * time.Second): case <-abortSignal: } continue } newBuild := common.Build{ GetBuildResponse: *buildData, Runner: &r.RunnerConfig, BuildAbort: abortSignal, } newBuild.AssignID() newBuild.Run(config) } doneSignal <- 0 }