Kerrigan29a/recipe

package recipe

import (
    "bytes"
    "encoding/json"
    "os"
    "os/exec"
    "strings"
    "sync"
)

/*
 * Sources:
 * - https://blog.kowalczyk.info/article/wOYk/advanced-command-execution-in-go-with-osexec.html
 */

type Task struct {
    Deps         []string          `json:"deps" toml:"deps"`
    Env          map[string]string `json:"env" toml:"env"`
    Interp       []string          `json:"interp" toml:"interp"`
    Cmd          string            `json:"cmd" toml:"cmd"`
    Stdout       string            `json:"stdout" toml:"stdout"`
    Stderr       string            `json:"stderr" toml:"stderr"`
    AllowFailure bool              `json:"allow_failure" toml:"allow_failure"`
    cmd          *exec.Cmd
    mu           sync.RWMutex
}

/***
 * Task
 */

/*

// NOTE: This snippet shows how to reset unmarshaled structs to have different default values
// WARNING: At this moment is not working with TOML due to a go-toml limitation: https://github.com/pelletier/go-toml/blob/master/marshal.go#L318

// Used to avoid recursion in UnmarshalJSON below.
type task Task

func (t *task) reset() {
    t.Deps = make([]string, 0)
    t.Env = make(map[string]string, 0)
    t.Interp = make([]string, 0)
    t.Cmd = ""
    t.Stdout = ""
    t.Stderr = ""
    t.AllowFailure = false
}

func (t *Task) UnmarshalJSON(b []byte) error {
    fmt.Printf("DEBUG TASK UnmarshalJSON\n")

    newT := task{}
    newT.reset()

    err := json.Unmarshal(b, &newT)
    if err != nil {
        return err
    }

    t.Deps = newT.Deps
    t.Env = newT.Env
    t.Interp = newT.Interp
    t.Cmd = newT.Cmd
    t.Stdout = newT.Stdout
    t.Stderr = newT.Stderr
    t.AllowFailure = newT.AllowFailure
    t.mu = newT.mu

    fmt.Printf("DEBUG task = %s\n", t)
    return nil
}

func (t *Task) UnmarshalTOML(b []byte) error {
    fmt.Printf("DEBUG TASK UnmarshalTOML\n")

    newT := task{}
    newT.reset()

    err := toml.Unmarshal(b, &newT)
    if err != nil {
        return err
    }

    t.Deps = newT.Deps
    t.Env = newT.Env
    t.Interp = newT.Interp
    t.Cmd = newT.Cmd
    t.Stdout = newT.Stdout
    t.Stderr = newT.Stderr
    t.AllowFailure = newT.AllowFailure
    t.mu = newT.mu

    fmt.Printf("DEBUG task = %s\n", t)
    return nil
}

*/

func (t *Task) composeEnv(r *Recipe) []string {
    newEnv := os.Environ()
    for key, value := range r.Environ() {
        newEnv = append(newEnv, key+"="+value)
    }
    for key, value := range t.Environ() {
        newEnv = append(newEnv, key+"="+value)
    }
    return newEnv
}

func replaceCmd(parts []string, spell string) []string {
    newParts := make([]string, len(parts))
    for i, txt := range parts {
        newParts[i] = strings.Replace(txt, "{cmd}", spell, -1)
    }
    return newParts
}

func (t *Task) composeInterpreterCmd(spell string, r *Recipe) []string {
    // Check task config
    if parts := t.Interpreter(); parts != nil {
        if len(parts) == 0 {
            return t.composeDefaultInterpreterCmd(spell)
        }
        return replaceCmd(parts, spell)
    }
    // Check recipe config
    if parts := r.Interpreter(); parts != nil {
        if len(parts) == 0 {
            return t.composeDefaultInterpreterCmd(spell)
        }
        return replaceCmd(parts, spell)
    }
    return t.composeDefaultInterpreterCmd(spell)
}

func (t *Task) Execute(r *Recipe) error {
    t.mu.RLock()
    defer t.mu.RUnlock()

    if t.Cmd == "" {
        return nil
    }

    parts := t.composeInterpreterCmd(t.Cmd, r)
    env := t.composeEnv(r)

    // Search program
    path, err := exec.LookPath(parts[0])
    if err != nil {
        return err
    }
    // Create cmd
    t.cmd = exec.Command(path, parts[1:]...)
    // Redirect stdout and stderr
    if t.Stdout != "" {
        f, err := os.Create(t.Stdout)
        if err != nil {
            return err
        }
        defer f.Close()
        t.cmd.Stdout = f
    } else {
        t.cmd.Stdout = os.Stdout
    }
    if t.Stderr != "" {
        f, err := os.Create(t.Stderr)
        if err != nil {
            return err
        }
        defer f.Close()
        t.cmd.Stderr = f
    } else {
        t.cmd.Stderr = os.Stderr
    }
    t.cmd.Env = env

    // Set SysProcAttr
    t.setSysProcAttr()

    // Run
    err = t.cmd.Run()
    if err != nil {
        return err
    }
    return nil
}

func (t *Task) Environ() map[string]string {
    t.mu.RLock()
    defer t.mu.RUnlock()
    return t.Env
}

func (t *Task) Interpreter() []string {
    t.mu.RLock()
    defer t.mu.RUnlock()
    return t.Interp
}

func (t *Task) String() string {
    return t.serialize(false).String()
}

func (t *Task) PrettyString() string {
    return t.serialize(true).String()
}

func (t *Task) serialize(indent bool) *bytes.Buffer {
    t.mu.RLock()
    defer t.mu.RUnlock()
    b := bytes.Buffer{}
    e := json.NewEncoder(&b)
    if indent {
        e.SetIndent("", "  ")
    }
    err := e.Encode(t)
    if err != nil {
        panic(err)
    }
    return &b
}