func (r *Runner) Run(config *evergreen.Settings) error {
lockAcquired, err := db.WaitTillAcquireGlobalLock(RunnerName, db.LockTimeout)
if err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "error acquiring global lock: %v", err)
}
if !lockAcquired {
return evergreen.Logger.Errorf(slogger.ERROR, "timed out acquiring global lock")
}
defer func() {
if err := db.ReleaseGlobalLock(RunnerName); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "error releasing global lock: %v", err)
}
}()
startTime := time.Now()
evergreen.Logger.Logf(slogger.INFO, "Starting monitor at time %v", startTime)
if err := RunAllMonitoring(config); err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "error running monitor: %v", err)
}
runtime := time.Now().Sub(startTime)
if err = model.SetProcessRuntimeCompleted(RunnerName, runtime); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "error updating process status: %v", err)
}
evergreen.Logger.Logf(slogger.INFO, "Monitor took %v to run", runtime)
return nil
}
func (r *Runner) Run(config *evergreen.Settings) error {
lockAcquired, err := db.WaitTillAcquireGlobalLock(RunnerName, db.LockTimeout)
if err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "Error acquiring global lock: %v", err)
}
if !lockAcquired {
return evergreen.Logger.Errorf(slogger.ERROR, "Timed out acquiring global lock")
}
defer func() {
if err := db.ReleaseGlobalLock(RunnerName); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Error releasing global lock: %v", err)
}
}()
startTime := time.Now()
evergreen.Logger.Logf(slogger.INFO, "Running repository tracker with db “%v”", config.Db)
allProjects, err := model.FindAllTrackedProjectRefs()
if err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "Error finding tracked projects %v", err)
}
numNewRepoRevisionsToFetch := config.RepoTracker.NumNewRepoRevisionsToFetch
if numNewRepoRevisionsToFetch <= 0 {
numNewRepoRevisionsToFetch = DefaultNumNewRepoRevisionsToFetch
}
var wg sync.WaitGroup
wg.Add(len(allProjects))
for _, projectRef := range allProjects {
go func(projectRef model.ProjectRef) {
defer wg.Done()
tracker := &RepoTracker{
config,
&projectRef,
NewGithubRepositoryPoller(&projectRef, config.Credentials["github"]),
}
err = tracker.FetchRevisions(numNewRepoRevisionsToFetch)
if err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Error fetching revisions: %v", err)
}
}(projectRef)
}
wg.Wait()
runtime := time.Now().Sub(startTime)
if err = model.SetProcessRuntimeCompleted(RunnerName, runtime); err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "Error updating process status: %v", err)
}
evergreen.Logger.Logf(slogger.INFO, "Repository tracker took %v to run", runtime)
return nil
}
func (r *Runner) Run(config *evergreen.Settings) error {
startTime := time.Now()
evergreen.Logger.Logf(slogger.INFO, "Starting taskrunner at time %v", startTime)
if err := NewTaskRunner(config).Run(); err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "error running taskrunner: %v", err)
}
runtime := time.Now().Sub(startTime)
if err := model.SetProcessRuntimeCompleted(RunnerName, runtime); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "error updating process status: %v", err)
}
evergreen.Logger.Logf(slogger.INFO, "Taskrunner took %v to run", runtime)
return nil
}
func (r *Runner) Run(config *evergreen.Settings) error {
startTime := time.Now()
evergreen.Logger.Logf(slogger.INFO, "Starting notifications at time %v", startTime)
evergreen.Logger.Logf(slogger.INFO, "Running notifications with db %v and notifications configuration %v/%v", config.Db, config.ConfigDir, evergreen.NotificationsFile)
if err := Run(config); err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "error running notify: %v", err)
}
runtime := time.Now().Sub(startTime)
if err := model.SetProcessRuntimeCompleted(RunnerName, runtime); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "error updating process status: %v", err)
}
evergreen.Logger.Logf(slogger.INFO, "Notify took %v to run", runtime)
return nil
}
func (r *Runner) Run(config *evergreen.Settings) error {
startTime := time.Now()
evergreen.Logger.Logf(slogger.INFO, "Starting hostinit at time %v", startTime)
init := &HostInit{config}
if err := init.setupReadyHosts(); err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "Error running hostinit: %v", err)
}
runtime := time.Now().Sub(startTime)
if err := model.SetProcessRuntimeCompleted(RunnerName, runtime); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Error updating process status: %v", err)
}
evergreen.Logger.Logf(slogger.INFO, "Hostinit took %v to run", runtime)
return nil
}
func (r *Runner) Run(config *evergreen.Settings) error {
lockAcquired, err := db.WaitTillAcquireGlobalLock(RunnerName, db.LockTimeout)
if err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "Error acquiring global lock: %v", err)
}
if !lockAcquired {
return evergreen.Logger.Errorf(slogger.ERROR, "Timed out acquiring global lock")
}
defer func() {
if err := db.ReleaseGlobalLock(RunnerName); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Error releasing global lock: %v", err)
}
}()
startTime := time.Now()
evergreen.Logger.Logf(slogger.INFO, "Starting scheduler at time %v", startTime)
schedulerInstance := &Scheduler{
config,
&DBTaskFinder{},
NewCmpBasedTaskPrioritizer(),
&DBTaskDurationEstimator{},
&DBTaskQueuePersister{},
&DurationBasedHostAllocator{},
}
if err = schedulerInstance.Schedule(); err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "Error running scheduler: %v", err)
}
runtime := time.Now().Sub(startTime)
if err = model.SetProcessRuntimeCompleted(RunnerName, runtime); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Error updating process status: %v", err)
}
evergreen.Logger.Logf(slogger.INFO, "Scheduler took %v to run", runtime)
return nil
}
func (r *Runner) Run(config *evergreen.Settings) error {
startTime := time.Now()
evergreen.Logger.Logf(slogger.INFO, "Starting scheduler at time %v", startTime)
schedulerInstance := &Scheduler{
config,
&DBTaskFinder{},
&CmpBasedTaskPrioritizer{},
&DBTaskDurationEstimator{},
&DBTaskQueuePersister{},
&DurationBasedHostAllocator{},
}
if err := schedulerInstance.Schedule(); err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "Error running scheduler: %v", err)
}
runtime := time.Now().Sub(startTime)
if err := model.SetProcessRuntimeCompleted(RunnerName, runtime); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Error updating process status: %v", err)
}
evergreen.Logger.Logf(slogger.INFO, "Scheduler took %v to run", runtime)
return nil
}