// NewDaemonPen creates a new DaemonPen
func NewDaemonPen(block conf.Block, vars map[string]string, log termlog.TermLog) (*DaemonPen, error) {
d := make([]*daemon, len(block.Daemons))
for i, dmn := range block.Daemons {
vcmd := varcmd.VarCmd{Block: nil, Mod: nil, Vars: vars}
finalcmd, err := vcmd.Render(dmn.Command)
if err != nil {
return nil, err
}
dmn.Command = finalcmd
var indir string
if block.InDir != "" {
indir = block.InDir
} else {
indir, err = os.Getwd()
if err != nil {
return nil, err
}
}
d[i] = &daemon{
conf: dmn,
log: log.Stream(niceHeader("daemon: ", dmn.Command)),
shell: vars[shellVarName],
indir: indir,
}
}
return &DaemonPen{daemons: d}, nil
}
// RunPreps runs all commands in sequence. Stops if any command returns an error.
func RunPreps(b conf.Block, vars map[string]string, mod *watch.Mod, log termlog.TermLog) error {
vcmd := varcmd.VarCmd{Block: &b, Mod: mod, Vars: vars}
for _, p := range b.Preps {
cmd, err := vcmd.Render(p.Command)
if err != nil {
return err
}
err = RunProc(cmd, log.Stream(niceHeader("prep: ", cmd)))
if err != nil {
return err
}
}
return nil
}
// NewDaemonPen creates a new DaemonPen
func NewDaemonPen(block conf.Block, vars map[string]string, log termlog.TermLog) (*DaemonPen, error) {
d := make([]*daemon, len(block.Daemons))
for i, dmn := range block.Daemons {
vcmd := varcmd.VarCmd{Block: nil, Mod: nil, Vars: vars}
finalcmd, err := vcmd.Render(dmn.Command)
if err != nil {
return nil, err
}
dmn.Command = finalcmd
d[i] = &daemon{
conf: dmn,
log: log.Stream(niceHeader("daemon: ", dmn.Command)),
}
}
return &DaemonPen{daemons: d}, nil
}
func (d *daemon) Run() {
var lastStart time.Time
for d.stop != true {
d.log.Notice(">> starting...")
since := time.Now().Sub(lastStart)
if since < MinRestart {
time.Sleep(MinRestart - since)
}
lastStart = time.Now()
sh := getShell()
vcmd := varcmd.VarCmd{Block: nil, Mod: nil, Vars: d.vars}
finalcmd, err := vcmd.Render(d.conf.Command)
if err != nil {
d.log.Shout("%s", err)
continue
}
c := exec.Command(sh, "-c", finalcmd)
stdo, err := c.StdoutPipe()
if err != nil {
d.log.Shout("%s", err)
continue
}
stde, err := c.StderrPipe()
if err != nil {
d.log.Shout("%s", err)
continue
}
wg := sync.WaitGroup{}
wg.Add(2)
go logOutput(&wg, stde, d.log.Warn)
go logOutput(&wg, stdo, d.log.Say)
err = c.Start()
if err != nil {
d.log.Shout("%s", err)
continue
}
d.cmd = c
err = c.Wait()
wg.Wait()
if err != nil {
d.log.Shout("%s", c.ProcessState.String())
continue
}
}
}
// RunPreps runs all commands in sequence. Stops if any command returns an error.
func RunPreps(b conf.Block, vars map[string]string, mod *watch.Mod, log termlog.TermLog, notifiers []notify.Notifier) error {
vcmd := varcmd.VarCmd{Block: &b, Mod: mod, Vars: vars}
for _, p := range b.Preps {
cmd, err := vcmd.Render(p.Command)
if err != nil {
return err
}
err = RunProc(cmd, log.Stream(niceHeader("prep: ", cmd)))
if err != nil {
if pe, ok := err.(ProcError); ok {
for _, n := range notifiers {
n.Push("modd error", pe.Output, "")
}
}
return err
}
}
return nil
}
// Start starts set of daemons, each specified by a command
func (dp *DaemonPen) Start(daemons []conf.Daemon, vars map[string]string, log termlog.TermLog) {
dp.Lock()
defer dp.Unlock()
d := make([]daemon, len(daemons))
for i, dmn := range daemons {
vcmd := varcmd.VarCmd{Block: nil, Mod: nil, Vars: vars}
finalcmd, err := vcmd.Render(dmn.Command)
if err != nil {
log.Shout("%s", err)
continue
}
dmn.Command = finalcmd
d[i] = daemon{
conf: dmn,
log: log.Stream(
niceHeader("daemon: ", dmn.Command),
),
}
go d[i].Run()
}
dp.daemons = &d
}
// RunPreps runs all commands in sequence. Stops if any command returns an error.
func RunPreps(b conf.Block, vars map[string]string, mod *moddwatch.Mod, log termlog.TermLog, notifiers []notify.Notifier, initial bool) error {
shell := vars[shellVarName]
vcmd := varcmd.VarCmd{Block: &b, Mod: mod, Vars: vars}
for _, p := range b.Preps {
cmd, err := vcmd.Render(p.Command)
if initial && p.Onchange {
log.Say(niceHeader("skipping prep: ", cmd))
continue
}
if err != nil {
return err
}
err = RunProc(cmd, shell, log.Stream(niceHeader("prep: ", cmd)))
if err != nil {
if pe, ok := err.(ProcError); ok {
for _, n := range notifiers {
n.Push("modd error", pe.Output, "")
}
}
return err
}
}
return nil
}
