func main() {
if state.period > 0 && !shouldrun() {
os.Exit(10)
}
proc := cmd.NewProc(state.cmd.Cmd.Name, state.cmd.Cmd.Args)
proc.Cmd.Stdout = os.Stdout
proc.Cmd.Stderr = os.Stderr
proc.StartExit()
proc.WaitExit()
}
func main() {
if state.bound != 0 {
time.Sleep(time.Duration(rand.Int63n(state.bound.Nanoseconds())))
}
proc := cmd.NewProc(state.cmd.Cmd.Name, state.cmd.Cmd.Args)
proc.Cmd.Stdout = os.Stdout
proc.Cmd.Stderr = os.Stderr
proc.StartExit()
proc.WaitExit()
}
func main() {
lc, err := lockfile.LockRm(state.globalname, state.localname)
if err != nil {
log.Print(err)
os.Exit(20)
}
defer lc.Unlock()
proc := cmd.NewProc(state.cmd.Cmd.Name, state.cmd.Cmd.Args)
proc.Cmd.Stdout = os.Stdout
proc.Cmd.Stderr = os.Stderr
proc.StartExit()
proc.WaitExit()
}
func main() {
proc := cmd.NewProc(state.cmd.Cmd.Name, state.cmd.Cmd.Args)
// Copy combined output from process into ring buffer. So in
// the end, if a lot is written, we'll only be left with the
// last bits.
cout := combinedOutput(proc)
rbuf := ringbuffer.New(maxLogSize)
go func() {
_, err := io.Copy(rbuf, cout)
if err != nil {
log.Print(err)
os.Exit(30)
}
}()
lf, lferr := newLogFile(state.logname)
if lferr != nil {
log.Print(lferr)
os.Exit(31)
}
if perr := proc.StartError(); perr != nil {
// There aren't any errors that could be caused by just
// trying to start the process that we should elide.
perr.Exit()
}
if perr := proc.WaitError(); perr != nil {
// These are the errors that we'll want to potentially elide.
exit(lf, perr, rbuf)
}
// Success: reset the failure count and not only do we log, but
// the consolidated output also goes unconditionally to standard
// error.
lf.failures = 0
write(lf, rbuf, true)
}
func main() {
proc := cmd.NewProc(state.cmd.Cmd.Name, state.cmd.Cmd.Args)
proc.Cmd.Stdout = os.Stdout
proc.Cmd.Stderr = os.Stderr
proc.StartExit()
done := make(chan struct{})
go func() {
proc.WaitExit()
close(done)
}()
if state.timelimit > 0 {
timeout := make(chan struct{})
go func() {
time.Sleep(state.timelimit)
close(timeout)
}()
select {
case <-done:
// Process exited successfully before timeout.
// Thus, there's no need to wait on that anymore
// in combination with the timeout.
break
case <-timeout:
log.Printf("timed out: %s\n", proc)
if err := proc.Cmd.Process.Kill(); err != nil {
log.Print(err)
}
proc.Wait() // Don't care if this errors.
os.Exit(40)
}
}
<-done
}