| package util |
| |
| import ( |
| "bytes" |
| "errors" |
| "flag" |
| "fmt" |
| "io" |
| "log" |
| "os" |
| "os/exec" |
| "strings" |
| "time" |
| ) |
| |
| // Should switch to a logging package that supports levels, |
| // e.g. https://github.com/golang/glog |
| var debug = flag.Bool("debug", false, |
| "If true, dump more information during run.") |
| |
| // check reports the error fatally if its non-nil. |
| func check(msg string, err error) { |
| if err != nil { |
| fmt.Printf("Problem with %s\n", msg, err) |
| log.Fatal(err) |
| } |
| } |
| |
| // blockOutput pairs the output collected from a stream (i.e. stderr |
| // or stdout) as a result of executing all or part of a command block |
| // with a bool indicating if the output is associated with shell |
| // success or shell failure. Output can appear on stderr without |
| // neccessarily being associated with shell failure. |
| type blockOutput struct { |
| success bool |
| output string |
| } |
| |
| // accumulateOutput returns a channel to which it writes objects that |
| // contain what purport to be the entire output of one command block. |
| // |
| // To do so, it accumulates strings off a channel representing command |
| // block output until the channel closes, or until a string arrives |
| // that matches a particular pattern. |
| // |
| // On the happy path, strings are accumulated and every so often sent |
| // out with a success == true flag attached. This continues until the |
| // input channel closes. |
| // |
| // On a sad path, an accumulation of strings is sent with a success == |
| // false flag attached, and the function exits early, before it's |
| // input channel closes. |
| func accumulateOutput(prefix string, in <-chan string) <-chan *blockOutput { |
| out := make(chan *blockOutput) |
| var accum bytes.Buffer |
| go func() { |
| defer close(out) |
| for line := range in { |
| if strings.HasPrefix(line, MsgTimeout) { |
| accum.WriteString("\n" + line + "\n") |
| accum.WriteString("A subprocess might still be running.\n") |
| if *debug { |
| fmt.Printf("DEBUG: accumulateOutput %s: Timeout return.\n", prefix) |
| } |
| out <- &blockOutput{false, accum.String()} |
| return |
| } |
| if strings.HasPrefix(line, MsgError) { |
| accum.WriteString(line + "\n") |
| if *debug { |
| fmt.Printf("DEBUG: accumulateOutput %s: Error return.\n", prefix) |
| } |
| out <- &blockOutput{false, accum.String()} |
| return |
| } |
| if strings.HasPrefix(line, MsgHappy) { |
| if *debug { |
| fmt.Printf("DEBUG: accumulateOutput %s: %s\n", prefix, line) |
| } |
| out <- &blockOutput{true, accum.String()} |
| accum.Reset() |
| } else { |
| if *debug { |
| fmt.Printf("DEBUG: accumulateOutput %s: Accumulating [%s]\n", prefix, line) |
| } |
| accum.WriteString(line + "\n") |
| } |
| } |
| |
| if *debug { |
| fmt.Printf("DEBUG: accumulateOutput %s: <--- This channel has closed.\n", prefix) |
| } |
| trailing := strings.TrimSpace(accum.String()) |
| if len(trailing) > 0 { |
| if *debug { |
| fmt.Printf( |
| "DEBUG: accumulateOutput %s: Erroneous (missing-happy) output [%s]\n", prefix, accum.String()) |
| } |
| out <- &blockOutput{false, accum.String()} |
| } else { |
| if *debug { |
| fmt.Printf("DEBUG: accumulateOutput %s: Nothing trailing.\n", prefix) |
| } |
| } |
| }() |
| return out |
| } |
| |
| // ScriptResult pairs blockOutput with meta data about shell execution. |
| type ScriptResult struct { |
| blockOutput |
| fileName string // File in which the error occurred. |
| index int // Command block index. |
| block *CommandBlock // Content of actual command block. |
| problem error // Error, if any. |
| message string // Detailed error message, if any. |
| } |
| |
| func (x ScriptResult) GetFileName() string { |
| return x.fileName |
| } |
| |
| func (x ScriptResult) GetProblem() error { |
| return x.problem |
| } |
| |
| // ScriptBucket associates a list of commandBlocks with the name of the |
| // file they came from. |
| type ScriptBucket struct { |
| fileName string |
| script []*CommandBlock |
| } |
| |
| func (x ScriptBucket) GetFileName() string { |
| return x.fileName |
| } |
| func (x ScriptBucket) GetScript() []*CommandBlock { |
| return x.script |
| } |
| func NewScriptBucket(fileName string, script []*CommandBlock) *ScriptBucket { |
| return &ScriptBucket{fileName, script} |
| } |
| |
| // userBehavior acts like a command line user. |
| // |
| // It writes command blocks to shell, then waits after each block to |
| // see if the block worked. If the block appeared to complete without |
| // error, the routine sends the next block, else it exits early. |
| func userBehavior(stdIn io.Writer, scriptBuckets []*ScriptBucket, blockTimeout time.Duration, |
| stdOut, stdErr io.ReadCloser) (errResult *ScriptResult) { |
| emptyArray := []string{} |
| |
| chOut := BuffScanner(blockTimeout, "stdout", stdOut, *debug) |
| chErr := BuffScanner(1*time.Minute, "stderr", stdErr, *debug) |
| |
| chAccOut := accumulateOutput("stdOut", chOut) |
| chAccErr := accumulateOutput("stdErr", chErr) |
| |
| errResult = &ScriptResult{blockOutput{false, ""}, "", -1, &CommandBlock{emptyArray, ""}, nil, ""} |
| for _, bucket := range scriptBuckets { |
| for i, block := range bucket.script { |
| blockName := block.labels[0] |
| fmt.Printf("Running %s (%d/%d) from %s\n", |
| blockName, i+1, len(bucket.script), bucket.fileName) |
| if *debug { |
| fmt.Printf("DEBUG: userBehavior: sending \"%s\"\n", block.codeText) |
| } |
| _, err := stdIn.Write([]byte(block.codeText)) |
| check("write script", err) |
| if *debug { |
| fmt.Printf("DEBUG: userBehavior: sending happy\n") |
| } |
| _, err = stdIn.Write([]byte("\necho " + MsgHappy + " " + blockName + "\n")) |
| check("write msgHappy", err) |
| |
| result := <-chAccOut |
| |
| if result == nil || !result.success { |
| // A nil result means stdout has closed early because a |
| // sub-subprocess failed. |
| if result == nil { |
| if *debug { |
| fmt.Printf("DEBUG: userBehavior: stdout Result == nil.\n") |
| // fmt.Printf("DEBUG: userBehavior: sending warning to stdErr\n") |
| } |
| // chErr <- MsgError + " : early termination; stdout has closed." |
| } else { |
| if *debug { |
| fmt.Printf("DEBUG: userBehavior: stdout Result: %s\n", result.output) |
| } |
| // Shell may still be alive despite a failure (e.g. an mdrip |
| // imposed timeout). Maybe send exit. |
| exitShell(stdIn) |
| errResult.output = result.output |
| errResult.message = result.output |
| } |
| errResult.fileName = bucket.fileName |
| errResult.index = i |
| errResult.block = block |
| fillErrResult(chAccErr, errResult) |
| return |
| } |
| } |
| } |
| exitShell(stdIn) |
| fmt.Printf("All done, no errors triggered.\n") |
| return |
| } |
| |
| // fillErrResult fills an instance of ScriptResult. |
| func fillErrResult(chAccErr <-chan *blockOutput, errResult *ScriptResult) { |
| result := <-chAccErr |
| if result == nil { |
| if *debug { |
| fmt.Printf("DEBUG: userBehavior: stderr Result == nil.\n") |
| } |
| errResult.problem = errors.New("unknown") |
| return |
| } |
| errResult.problem = errors.New(result.output) |
| errResult.message = result.output |
| if *debug { |
| fmt.Printf("DEBUG: userBehavior: stderr Result: %s\n", result.output) |
| } |
| } |
| |
| func exitShell(stdIn io.Writer) { |
| if *debug { |
| fmt.Printf("DEBUG: userBehavior: exiting subshell.\n") |
| } |
| stdIn.Write([]byte("exit\n")) |
| // Don't check for error - it either works, or we'll have |
| // already reported a failed shell. |
| } |
| |
| func dumpCapturedOutput(name, delim, output string) { |
| fmt.Fprintf(os.Stderr, "\n%s capture:\n", name) |
| fmt.Fprintf(os.Stderr, delim) |
| fmt.Fprintf(os.Stderr, output) |
| fmt.Fprintf(os.Stderr, "\n") |
| fmt.Fprintf(os.Stderr, delim) |
| } |
| |
| // Complain spits the contents of a ScriptResult to stderr. |
| func Complain(result *ScriptResult, label string) { |
| delim := strings.Repeat("-", 70) + "\n" |
| fmt.Fprintf(os.Stderr, "Error in block '%s' (#%d of script '%s') in %s:\n", |
| result.block.labels[0], result.index+1, label, result.fileName) |
| fmt.Fprintf(os.Stderr, delim) |
| fmt.Fprintf(os.Stderr, string(result.block.codeText)) |
| fmt.Fprintf(os.Stderr, delim) |
| dumpCapturedOutput("Stdout", delim, result.output) |
| if len(result.message) > 0 { |
| dumpCapturedOutput("Stderr", delim, result.message) |
| } |
| } |
| |
| // RunInSubShell runs command blocks in a subprocess, stopping and |
| // reporting on any error. The subprocess runs with the -e flag, so |
| // it will abort if any sub-subprocess (any command) fails. |
| // |
| // Command blocks are strings presumably holding code from some shell |
| // language. The strings may be more complex than single commands |
| // delimitted by linefeeds - e.g. blocks that operate on HERE |
| // documents, or multi-line commands using line continuation via '\', |
| // quotes or curly brackets. |
| // |
| // This function itself is not a shell interpreter, so it has no idea |
| // if one line of text from a command block is an individual command |
| // or part of something else. |
| // |
| // Error reporting works by discarding output from command blocks that |
| // succeeded, and only reporting the contents of stdout and stderr |
| // when the subprocess exits on error. |
| func RunInSubShell(scriptBuckets []*ScriptBucket, blockTimeout time.Duration) ( |
| result *ScriptResult) { |
| // Adding "-e" to force the subshell to die on any error. |
| shell := exec.Command("bash", "-e") |
| |
| stdOut, err := shell.StdoutPipe() |
| check("out pipe", err) |
| |
| stdErr, err := shell.StderrPipe() |
| check("err pipe", err) |
| |
| stdIn, err := shell.StdinPipe() |
| check("in pipe", err) |
| |
| err = shell.Start() |
| check("shell start", err) |
| |
| pid := shell.Process.Pid |
| if *debug { |
| fmt.Printf("DEBUG: RunInSubShell: pid = %d\n", pid) |
| } |
| pgid, err := getProcesssGroupId(pid) |
| if err == nil { |
| if *debug { |
| fmt.Printf("DEBUG: RunInSubShell: pgid = %d\n", pgid) |
| } |
| } |
| |
| result = userBehavior(stdIn, scriptBuckets, blockTimeout, stdOut, stdErr) |
| |
| if *debug { |
| fmt.Printf("DEBUG: RunInSubShell: Waiting for shell to end.\n") |
| } |
| waitError := shell.Wait() |
| if result.problem == nil { |
| result.problem = waitError |
| } |
| if *debug { |
| fmt.Printf("DEBUG: RunInSubShell: Shell done.\n") |
| } |
| |
| // killProcesssGroup(pgid) |
| return |
| } |
