// Start runs the coprocess
func (coprocess *Coprocess) Start() {
log.Debugf("coprocess[%s].Start", coprocess.Name)
fields := log.Fields{"process": "coprocess", "coprocess": coprocess.Name}
stdout := utils.NewLogWriter(fields, log.InfoLevel)
stderr := utils.NewLogWriter(fields, log.DebugLevel)
coprocess.logWriters = []io.WriteCloser{stdout, stderr}
defer coprocess.closeLogs()
// always reset restartsRemain when we load the config
coprocess.restartsRemain = coprocess.restartLimit
for {
if coprocess.restartLimit != unlimitedRestarts &&
coprocess.restartsRemain <= haltRestarts {
break
}
cmd := utils.ArgsToCmd(coprocess.Args)
coprocess.cmd = cmd
cmd.Stdout = stdout
cmd.Stderr = stderr
if _, err := utils.ExecuteAndWait(cmd); err != nil {
log.Errorf("coprocess[%s] exited: %s", coprocess.Name, err)
}
log.Debugf("coprocess[%s] exited", coprocess.Name)
if !coprocess.restart {
break
}
coprocess.restartsRemain--
}
}
// OnChange runs the backend's onChange command, returning the results
func (b *Backend) OnChange() (int, error) {
defer func() {
// reset command object because it can't be reused
b.onChangeCmd = utils.ArgsToCmd(b.onChangeCmd.Args)
}()
exitCode, err := utils.RunWithFields(b.onChangeCmd, log.Fields{"process": "OnChange", "backend": b.Name})
return exitCode, err
}
func getSignalTestConfig() *App {
service, _ := services.NewService(
"test-service", 1, 1, 1, nil, nil, &NoopServiceBackend{})
app := EmptyApp()
app.Command = utils.ArgsToCmd([]string{
"./testdata/test.sh",
"interruptSleep"})
app.StopTimeout = 5
app.Services = []*services.Service{service}
return app
}
func (s *Sensor) observe() (string, error) {
defer func() {
// reset command object because it can't be reused
s.checkCmd = utils.ArgsToCmd(s.checkCmd.Args)
}()
// we'll pass stderr to the container's stderr, but stdout must
// be "clean" and not have anything other than what we intend
// to write to our collector.
s.checkCmd.Stderr = os.Stderr
out, err := s.checkCmd.Output()
if err != nil {
return "", err
}
return string(out[:]), nil
}
// CheckHealth runs the service's health command, returning the results
func (s *Service) CheckHealth() (int, error) {
defer func() {
// reset command object because it can't be reused
if s.healthCheckCmd != nil {
s.healthCheckCmd = utils.ArgsToCmd(s.healthCheckCmd.Args)
}
}()
// if we have a valid Service but there's no health check
// set, assume it always passes (ex. telemetry service).
if s.healthCheckCmd == nil {
return 0, nil
}
exitCode, err := utils.RunWithFields(s.healthCheckCmd, log.Fields{"process": "health", "serviceName": s.Name, "serviceID": s.ID})
return exitCode, err
}
func parseCoprocess(coprocess *Coprocess) error {
args, err := utils.ToStringArray(coprocess.Command)
if err != nil {
return err
}
coprocess.Args = args
if coprocess.Args == nil || len(coprocess.Args) == 0 {
return fmt.Errorf("Coprocess did not provide a command")
}
cmd := utils.ArgsToCmd(coprocess.Args)
coprocess.cmd = cmd
if coprocess.Name == "" {
coprocess.Name = strings.Join(coprocess.Args, " ")
}
return parseCoprocessRestarts(coprocess)
}
// PollAction runs the task
func (t *Task) PollAction() {
log.Debugf("task[%s].PollAction", t.Name)
cmd := utils.ArgsToCmd(t.Args)
t.cmd = cmd
fields := log.Fields{"process": "task", "task": t.Name}
stdout := utils.NewLogWriter(fields, log.InfoLevel)
stderr := utils.NewLogWriter(fields, log.DebugLevel)
t.logWriters = []io.WriteCloser{stdout, stderr}
cmd.Stdout = stdout
cmd.Stderr = stderr
defer t.closeLogs()
log.Debugf("task[%s].PollAction start", t.Name)
if err := cmd.Start(); err != nil {
log.Errorf("Unable to start task %s: %v", t.Name, err)
return
}
t.run(cmd)
log.Debugf("task[%s].PollAction complete", t.Name)
}