func (m *machineProvider) updateMachines(machines []string, config *common.RunnerConfig) (data machinesData) { data.Runner = config.ShortDescription() for _, name := range machines { details := m.machineDetails(name, false) err := m.updateMachine(config, &data, details) if err != nil { m.remove(details.Name, err) } data.Add(details.State) } return }
func (m *machineProvider) Acquire(config *common.RunnerConfig) (data common.ExecutorData, err error) { if config.Machine == nil || config.Machine.MachineName == "" { err = fmt.Errorf("Missing Machine options") return } machines, err := m.loadMachines(config) if err != nil { return } // Lock updating machines, because two Acquires can be run at the same time m.acquireLock.Lock() // Update a list of currently configured machines machinesData := m.updateMachines(machines, config) // Pre-create machines m.createMachines(config, &machinesData) m.acquireLock.Unlock() logrus.WithFields(machinesData.Fields()). WithField("runner", config.ShortDescription()). WithField("minIdleCount", config.Machine.IdleCount). WithField("maxMachines", config.Limit). WithField("time", time.Now()). Debugln("Docker Machine Details") machinesData.writeDebugInformation() // Try to find a free machine details := m.findFreeMachine(machines...) if details != nil { data = details return } // If we have a free machines we can process a build if config.Machine.IdleCount != 0 && machinesData.Idle == 0 { err = errors.New("No free machines that can process builds") } return }
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 machineFilter(config *common.RunnerConfig) string { return machineFormat(config.ShortDescription(), config.Machine.MachineName) }