140 lines
3.3 KiB
Go
140 lines
3.3 KiB
Go
package runner
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
workflow "runner/internal/workflow"
|
|
)
|
|
|
|
type Runner struct {
|
|
Labels map[string]string
|
|
Driver ContainerDriver
|
|
Tasks map[string]*Task
|
|
Runs int
|
|
}
|
|
|
|
func NewRunner(driver ContainerDriver, labels map[string]string) Runner {
|
|
return Runner{
|
|
Driver: driver,
|
|
Labels: labels,
|
|
Tasks: map[string]*Task{},
|
|
}
|
|
}
|
|
|
|
func (r *Runner) GetImageUriByLabel(label string) string {
|
|
uri, exists := r.Labels[label]
|
|
|
|
if exists {
|
|
return uri
|
|
}
|
|
|
|
return "debian:latest"
|
|
}
|
|
|
|
func (r *Runner) GetContainerName(jobId string) string {
|
|
return fmt.Sprintf("runner-%s", jobId)
|
|
}
|
|
|
|
func (r *Runner) AddTask() string {
|
|
task := NewTask()
|
|
r.Tasks[task.Id] = &task
|
|
|
|
return task.Id
|
|
}
|
|
|
|
func (r *Runner) GetTask(taskId string) *Task {
|
|
task, _ := r.Tasks[taskId]
|
|
|
|
return task
|
|
}
|
|
|
|
// Executes a workflow using the runner.
|
|
//
|
|
// This is the high-level call that will set up the container
|
|
// that the jobs will be executed in, run the jobs's steps and
|
|
// tear down the container once no longer useful.
|
|
func (r *Runner) Execute(workflow workflow.Workflow) Task {
|
|
log.Printf("Executing workflow: %s", workflow.SourcePath)
|
|
task := r.GetTask(r.AddTask())
|
|
|
|
for _, job := range workflow.Jobs {
|
|
jobContext := task.GetJobContext(task.AddJob())
|
|
jobContext.SetStatus("started")
|
|
|
|
runnerImage := r.GetImageUriByLabel(job.RunsOn)
|
|
containerName := r.GetContainerName(jobContext.Id)
|
|
|
|
log.Printf("Using image %s (label: %s)", runnerImage, job.RunsOn)
|
|
|
|
if pullError := r.PullContainer(runnerImage); pullError != nil {
|
|
jobContext.SetStatus("failed").SetError(pullError)
|
|
continue
|
|
}
|
|
|
|
if runError := r.RunJobInContainer(runnerImage, containerName, job); runError != nil {
|
|
jobContext.SetStatus("failed").SetError(runError)
|
|
continue
|
|
}
|
|
|
|
jobContext.SetStatus("success")
|
|
}
|
|
|
|
return *task
|
|
}
|
|
|
|
// Executes a job within a container.
|
|
//
|
|
// The container is started before the job steps are run and cleaned up after.
|
|
func (r *Runner) RunJobInContainer(imageUri string, containerId string, job workflow.Job) error {
|
|
r.StartContainer(imageUri, containerId)
|
|
|
|
defer func() {
|
|
log.Printf("Cleaning up %s", containerId)
|
|
r.StopContainer(containerId)
|
|
}()
|
|
|
|
log.Printf("Started %s", containerId)
|
|
for _, step := range job.Steps {
|
|
log.Printf("Run: %s", step.Run)
|
|
|
|
if err := r.RunCommandInContainer(containerId, step.Run); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Pulls the container from the registry provided its image uri.
|
|
func (r *Runner) PullContainer(uri string) error {
|
|
return r.Driver.Pull(uri)
|
|
}
|
|
|
|
// Starts a container from the given image uri with the given name.
|
|
func (r *Runner) StartContainer(uri string, containerName string) error {
|
|
return r.Driver.Start(uri, containerName)
|
|
}
|
|
|
|
// Executes a command within the given container.
|
|
//
|
|
// If the command raises an error while in the container or fails to run
|
|
// the command at all, an error is returned, otherwise nil.
|
|
func (r *Runner) RunCommandInContainer(containerId string, command string) error {
|
|
result := r.Driver.Exec(containerId, command)
|
|
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
|
|
if result.ExitCode != 0 {
|
|
return errors.New(fmt.Sprintf("Command returned a non-zero exit code (%d).", result.ExitCode))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Stops the given container.
|
|
func (r *Runner) StopContainer(containerName string) {
|
|
r.Driver.Stop(containerName)
|
|
}
|