func (mr *RunCommand) processRunner(id int, runner *common.RunnerConfig, runners chan *common.RunnerConfig) (err error) {
provider := common.GetExecutor(runner.Executor)
if provider == nil {
return
}
context, err := provider.Acquire(runner)
if err != nil {
log.Warningln("Failed to update executor", runner.Executor, "for", runner.ShortDescription(), err)
return
}
defer provider.Release(runner, context)
// Acquire build slot
if !mr.buildsHelper.acquire(runner) {
return
}
defer mr.buildsHelper.release(runner)
// Receive a new build
buildData, healthy := mr.network.GetBuild(*runner)
mr.makeHealthy(runner.UniqueID(), healthy)
if buildData == nil {
return
}
// Make sure to always close output
buildCredentials := &common.BuildCredentials{
ID: buildData.ID,
Token: buildData.Token,
}
trace := mr.network.ProcessBuild(*runner, buildCredentials)
defer trace.Fail(err)
// Create a new build
build := &common.Build{
GetBuildResponse: *buildData,
Runner: runner,
ExecutorData: context,
SystemInterrupt: mr.abortBuilds,
}
// Add build to list of builds to assign numbers
mr.buildsHelper.addBuild(build)
defer mr.buildsHelper.removeBuild(build)
// Process the same runner by different worker again
// to speed up taking the builds
select {
case runners <- runner:
mr.log().WithField("runner", runner.ShortDescription()).Debugln("Requeued the runner")
default:
mr.log().WithField("runner", runner.ShortDescription()).Debugln("Failed to requeue the runner: ")
}
// Process a build
return build.Run(mr.config, trace)
}
func newMachineProvider(executor string) *machineProvider {
provider := common.GetExecutor(executor)
if provider == nil {
logrus.Panicln("Missing", executor)
}
return &machineProvider{
details: make(machinesDetails),
machine: docker_helpers.NewMachineCommand(),
provider: provider,
}
}
func (s *RegisterCommand) askExecutor() {
for {
names := common.GetExecutors()
executors := strings.Join(names, ", ")
s.Executor = s.ask("executor", "Please enter the executor: "+executors+":", true)
if common.GetExecutor(s.Executor) != nil {
return
}
message := "Invalid executor specified"
if s.NonInteractive {
log.Panicln(message)
} else {
log.Errorln(message)
}
}
}
func (n *GitLabClient) getRunnerVersion(config common.RunnerConfig) common.VersionInfo {
info := common.VersionInfo{
Name: common.NAME,
Version: common.VERSION,
Revision: common.REVISION,
Platform: runtime.GOOS,
Architecture: runtime.GOARCH,
Executor: config.Executor,
}
if executor := common.GetExecutor(config.Executor); executor != nil {
executor.GetFeatures(&info.Features)
}
if shell := common.GetShell(config.Shell); shell != nil {
shell.GetFeatures(&info.Features)
}
return info
}
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")
}
executorProvider := common.GetExecutor(r.Executor)
if executorProvider == nil {
log.Fatalln("Uknown executor:", r.Executor)
}
log.Println("Starting runner for", r.URL, "with token", r.ShortDescription(), "...")
finished := false
abortSignal := make(chan os.Signal)
doneSignal := make(chan int, 1)
go waitForInterrupts(&finished, abortSignal, doneSignal)
for !finished {
data, err := executorProvider.Acquire(&r.RunnerConfig)
if err != nil {
log.Warningln("Executor update:", err)
}
r.processBuild(data, abortSignal)
executorProvider.Release(&r.RunnerConfig, data)
}
doneSignal <- 0
}