0
0
package workflow
import (
"bytes"
"context"
"encoding/json"
"fmt"
"maps"
"sort"
"strings"
"time"
"gopkg.in/yaml.v3"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/sandbox"
"github.com/johnandersen777/socialweb-computer-kcp/internal/policyengine/models"
)
type Action struct {
Uses string
Path string
Using string
Main string
Inputs map[string]string
Source []byte
}
type ActionResolver func(uses string) (*Action, error)
type Options struct {
Sandbox sandbox.Runner
ResolveAction ActionResolver
MaxConsoleBytes int64
MaxOutputBytes int64
}
type JobResult struct {
Status string
Outputs map[string]any
Error string
}
type Context struct {
Inputs map[string]any
Env map[string]any
Secrets map[string]string
Outputs map[string]map[string]any
Annotations map[string][]models.Annotation
Cache models.Cache
Vars map[string]any
JobResults map[string]JobResult
Console []string
Shell string
Error error
console int64
}
type Executor struct {
opts Options
Context *Context
jobFailed bool
jobDeadline time.Time
}
func New(options Options) *Executor {
return &Executor{
opts: options,
Context: &Context{
Inputs: map[string]any{},
Env: map[string]any{},
Secrets: map[string]string{},
Outputs: map[string]map[string]any{},
Annotations: map[string][]models.Annotation{},
Cache: models.Cache{},
Vars: map[string]any{},
JobResults: map[string]JobResult{},
Shell: "bash -xe",
},
}
}
func Parse(raw json.RawMessage) (*models.Workflow, error) {
trimmed := bytes.TrimSpace(raw)
if len(trimmed) == 0 || bytes.Equal(trimmed, []byte("null")) {
return nil, fmt.Errorf("workflow is required")
}
var text string
if err := json.Unmarshal(trimmed, &text); err == nil {
text = strings.TrimSpace(text)
if text == "" || text == "null" {
return nil, fmt.Errorf("workflow is required")
}
var parsed models.Workflow
if err := yaml.Unmarshal([]byte(text), &parsed); err != nil {
return nil, fmt.Errorf("failed to parse workflow YAML: %w", err)
}
return &parsed, nil
}
var parsed models.Workflow
if err := yaml.Unmarshal(trimmed, &parsed); err != nil {
return nil, fmt.Errorf("failed to parse workflow: %w", err)
}
return &parsed, nil
}
func HasRunStep(raw json.RawMessage) (string, bool) {
parsed, err := Parse(raw)
if err != nil {
return "", false
}
names := make([]string, 0, len(parsed.Jobs))
for name := range parsed.Jobs {
names = append(names, name)
}
sort.Strings(names)
for _, name := range names {
for _, step := range parsed.Jobs[name].Steps {
if strings.TrimSpace(step.Run) != "" {
return name, true
}
}
}
return "", false
}
func (e *Executor) Execute(ctx context.Context, request *models.Request) (*models.Result, error) {
if request == nil {
return nil, fmt.Errorf("request is required")
}
workflow, err := Parse(request.Workflow)
if err != nil {
return nil, err
}
if err := e.initializeContext(request); err != nil {
return nil, err
}
if workflow.Name != "" {
e.Context.Env["GITHUB_WORKFLOW"] = workflow.Name
}
for key, value := range workflow.Env {
evaluated, evalErr := e.evaluateExpression(ctx, fmt.Sprintf("%v", value))
if evalErr != nil {
return e.failureResult(evalErr), nil
}
e.Context.Env[key] = evaluated
}
order, err := jobOrder(workflow)
if err != nil {
return e.failureResult(err), nil
}
var firstErr error
for _, name := range order {
job := workflow.Jobs[name]
result, jobErr := e.executeJob(ctx, name, &job)
e.Context.JobResults[name] = result
if jobErr != nil && firstErr == nil {
firstErr = jobErr
}
}
if firstErr != nil {
e.Context.Error = firstErr
return e.failureResult(firstErr), nil
}
return e.successResult(), nil
}
func (e *Executor) initializeContext(request *models.Request) error {
maps.Copy(e.Context.Inputs, request.Inputs)
if request.Context != nil {
if config, ok := request.Context["config"].(map[string]any); ok {
if env, ok := config["env"].(map[string]any); ok {
maps.Copy(e.Context.Env, env)
}
}
if secrets, ok := request.Context["secrets"].(map[string]any); ok {
for key, value := range secrets {
if text, ok := value.(string); ok {
e.Context.Secrets[key] = text
}
}
}
if cacheValue, ok := request.Context["cache"]; ok && cacheValue != nil {
e.Context.Cache = decodeCache(cacheValue)
}
if vars, ok := request.Context["vars"].(map[string]any); ok {
e.Context.Vars = vars
}
}
if token := e.Context.Secrets["GITHUB_TOKEN"]; token != "" {
if _, exists := e.Context.Env["GITHUB_TOKEN"]; !exists {
e.Context.Env["GITHUB_TOKEN"] = token
}
}
e.Context.Env["CI"] = "true"
e.Context.Env["GITHUB_ACTIONS"] = "true"
return nil
}
func jobOrder(workflow *models.Workflow) ([]string, error) {
names := make([]string, 0, len(workflow.Jobs))
for name := range workflow.Jobs {
names = append(names, name)
}
sort.Strings(names)
visited := map[string]bool{}
visiting := map[string]bool{}
order := make([]string, 0, len(names))
var visit func(string) error
visit = func(name string) error {
if visited[name] {
return nil
}
if visiting[name] {
return fmt.Errorf("circular needs involving job %s", name)
}
job, ok := workflow.Jobs[name]
if !ok {
return fmt.Errorf("job %s is not defined", name)
}
visiting[name] = true
for _, need := range needsOf(job.Needs) {
if err := visit(need); err != nil {
return err
}
}
visiting[name] = false
visited[name] = true
order = append(order, name)
return nil
}
for _, name := range names {
if err := visit(name); err != nil {
return nil, err
}
}
return order, nil
}
func needsOf(value any) []string {
switch typed := value.(type) {
case string:
if typed == "" {
return nil
}
return []string{typed}
case []string:
return typed
case []any:
out := make([]string, 0, len(typed))
for _, item := range typed {
if name, ok := item.(string); ok && name != "" {
out = append(out, name)
}
}
return out
default:
return nil
}
}
func (e *Executor) executeJob(ctx context.Context, name string, job *models.WorkflowJob) (JobResult, error) {
result := JobResult{Status: "success", Outputs: map[string]any{}}
dependencyFailed := false
for _, need := range needsOf(job.Needs) {
dep, ok := e.Context.JobResults[need]
if ok && (dep.Status == "failure" || dep.Status == "skipped") {
dependencyFailed = true
}
}
e.jobFailed = dependencyFailed
if job.If != nil {
guard, err := e.evaluateGuard(ctx, job.If)
if err != nil {
result.Status = "failure"
result.Error = err.Error()
return result, fmt.Errorf("job %s: %w", name, err)
}
if !guard.run {
result.Status = "skipped"
return result, nil
}
} else if dependencyFailed {
result.Status = "skipped"
return result, nil
}
jobCtx := ctx
if job.TimeoutMinutes > 0 {
var cancel context.CancelFunc
jobCtx, cancel = context.WithTimeout(ctx, time.Duration(job.TimeoutMinutes)*time.Minute)
defer cancel()
}
e.jobDeadline = time.Time{}
if job.TimeoutMinutes > 0 {
e.jobDeadline = time.Now().Add(time.Duration(job.TimeoutMinutes) * time.Minute)
}
envSnapshot := make(map[string]any, len(e.Context.Env))
maps.Copy(envSnapshot, e.Context.Env)
for key, value := range job.Env {
evaluated, evalErr := e.evaluateExpression(ctx, fmt.Sprintf("%v", value))
if evalErr != nil {
maps.Copy(e.Context.Env, envSnapshot)
result.Status = "failure"
result.Error = evalErr.Error()
return result, fmt.Errorf("job %s: %w", name, evalErr)
}
e.Context.Env[key] = evaluated
}
err := e.executeSteps(jobCtx, job)
outputs := map[string]any{}
for outputName, expression := range job.Outputs {
value, evalErr := e.evaluateExpression(ctx, fmt.Sprintf("%v", expression))
if evalErr != nil {
outputs[outputName] = ""
continue
}
outputs[outputName] = value
}
for key := range e.Context.Env {
if _, existed := envSnapshot[key]; !existed {
delete(e.Context.Env, key)
}
}
maps.Copy(e.Context.Env, envSnapshot)
result.Outputs = outputs
if err != nil {
result.Status = "failure"
result.Error = err.Error()
return result, fmt.Errorf("job %s: %w", name, err)
}
return result, nil
}
func (e *Executor) executeSteps(ctx context.Context, job *models.WorkflowJob) error {
e.jobFailed = false
e.Context.Error = nil
var firstErr error
for index, step := range job.Steps {
if err := ctx.Err(); err != nil {
e.jobFailed = true
return err
}
stepName := fmt.Sprintf("step_%d", index+1)
if step.ID != "" {
stepName = step.ID
} else if step.Name != "" {
stepName = step.Name
}
guard, err := e.evaluateGuard(ctx, step.If)
if err != nil {
firstErr = fmt.Errorf("step %s: %w", stepName, err)
e.jobFailed = true
break
}
if e.jobFailed && !guard.always && !guard.failure {
continue
}
if !guard.run {
continue
}
if step.Shell != "" {
e.Context.Shell = step.Shell
}
env, err := e.buildStepEnv(ctx, &step)
if err != nil {
firstErr = fmt.Errorf("step %s: %w", stepName, err)
e.jobFailed = true
break
}
e.emit(fmt.Sprintf("##[group]%s", stepName))
var stepErr error
if strings.TrimSpace(step.Run) != "" {
stepErr = fmt.Errorf("this evaluator runs gha-lite policies net-only and refuses a run: step (job step %s)", stepName)
} else if step.Uses != "" {
stepErr = e.executeStepUses(ctx, &step, env)
}
e.emit("##[endgroup]")
if stepErr != nil {
e.emit(fmt.Sprintf("##[error]step %s failed: %v", stepName, stepErr))
if step.ContinueOnError {
continue
}
e.jobFailed = true
e.Context.Error = stepErr
if firstErr == nil {
firstErr = fmt.Errorf("step %s: %w", stepName, stepErr)
}
continue
}
}
if firstErr != nil {
return firstErr
}
if !e.jobDeadline.IsZero() && time.Now().After(e.jobDeadline) {
e.jobFailed = true
return fmt.Errorf("job exceeded timeout-minutes")
}
return nil
}
func (e *Executor) emit(line string) {
if e.opts.MaxConsoleBytes > 0 {
if e.Context.console >= e.opts.MaxConsoleBytes {
return
}
remaining := e.opts.MaxConsoleBytes - e.Context.console
if int64(len(line)) > remaining {
line = line[:remaining]
}
}
e.Context.Console = append(e.Context.Console, line)
e.Context.console += int64(len(line)) + 1
}
func (e *Executor) successResult() *models.Result {
outputs := models.Outputs{}
for name, result := range e.Context.JobResults {
outputs[name] = result.Outputs
}
if used, limit := e.outputBytes(outputs); limit > 0 && used > limit {
err := fmt.Errorf("workflow outputs exceed the configured limit")
e.emit("##[error]" + err.Error())
return e.failureResult(err)
}
return &models.Result{
Status: models.ExecutionComplete,
ExitStatus: models.ExitSuccess,
Outputs: outputs,
Cache: e.Context.Cache,
Annotations: e.annotationMap(),
ConsoleOutput: strings.Join(e.Context.Console, "\n"),
}
}
func (e *Executor) failureResult(err error) *models.Result {
annotations := e.annotationMap()
errors := []models.Annotation{}
if err != nil {
errors = append(errors, models.Annotation{AnnotationLevel: models.AnnotationError, Message: err.Error(), Title: err.Error()})
}
annotations["error"] = errors
return &models.Result{
Status: models.ExecutionComplete,
ExitStatus: models.ExitFailure,
Outputs: models.Outputs{},
Cache: e.Context.Cache,
Annotations: annotations,
ConsoleOutput: strings.Join(e.Context.Console, "\n"),
}
}
func (e *Executor) annotationMap() models.Annotations {
out := models.Annotations{}
for level, list := range e.Context.Annotations {
copied := make([]models.Annotation, len(list))
copy(copied, list)
out[level] = copied
}
return out
}
func (e *Executor) outputBytes(outputs models.Outputs) (int64, int64) {
if e.opts.MaxOutputBytes <= 0 {
return 0, e.opts.MaxOutputBytes
}
data, err := json.Marshal(outputs)
if err != nil {
return 0, e.opts.MaxOutputBytes
}
return int64(len(data)), e.opts.MaxOutputBytes
}
func decodeCache(value any) models.Cache {
data, err := json.Marshal(value)
if err != nil {
return models.Cache{}
}
var out models.Cache
if err := json.Unmarshal(data, &out); err != nil {
return models.Cache{}
}
if out == nil {
out = models.Cache{}
}
return out
}