WIP: Switch to new config format.

Don't use jobrun for daemon, just call JobDo() once, the job must
organize stuff itself.

Sacrifice all the oneshot commands, they will be reintroduced as
client-calls to the daemon.

cmd/daemon.go

@@ -2,74 +2,56 @@ package cmd
 
 import (
 	"github.com/spf13/cobra"
-	"github.com/zrepl/zrepl/jobrun"
+	"fmt"
+	"sync"
 )
 
-var daemonArgs struct {
-	noPrune    bool
-	noAutosnap bool
-	noPull     bool
-}
-
 // daemonCmd represents the daemon command
 var daemonCmd = &cobra.Command{
 	Use:   "daemon",
-	Short: "run zrepl as a daemon",
+	Short: "start daemon",
 	Run:   doDaemon,
 }
 
 func init() {
 	RootCmd.AddCommand(daemonCmd)
-	daemonCmd.Flags().BoolVar(&daemonArgs.noPrune, "noprune", false, "don't run prune jobs")
-	daemonCmd.Flags().BoolVar(&daemonArgs.noAutosnap, "noautosnap", false, "don't run autosnap jobs")
-	daemonCmd.Flags().BoolVar(&daemonArgs.noPull, "nopull", false, "don't run pull jobs")
+}
+
+type jobLogger struct {
+	MainLog Logger
+	JobName string
+}
+
+func (l jobLogger) Printf(format string, v ...interface{}) {
+	l.MainLog.Printf(fmt.Sprintf("[%s]: %s", l.JobName, format), v...)
+}
+
+
+type Job interface {
+	JobName() string
+	JobDo(log Logger) (err error)
 }
 
 func doDaemon(cmd *cobra.Command, args []string) {
 
-	r := jobrun.NewJobRunner(log)
-	rc := make(chan jobrun.JobEvent)
-	r.SetNotificationChannel(rc)
-	go r.Run()
+	var wg sync.WaitGroup
 
-	if !daemonArgs.noAutosnap {
-		for name := range conf.Autosnaps {
-			as := conf.Autosnaps[name]
-			r.AddJob(as)
-		}
-	}
+	log.Printf("starting jobs from config")
 
-	if !daemonArgs.noPrune {
-		for name := range conf.Prunes {
-			p := conf.Prunes[name]
-			r.AddJob(p)
-		}
-	}
-
-	if !daemonArgs.noPull {
-		for name := range conf.Pulls {
-			p := conf.Pulls[name]
-			r.AddJob(p)
-		}
-	}
-
-	for {
-		event := <-rc
-		//		log.Printf("received event: %T", event)
-		switch e := (event).(type) {
-		case jobrun.JobFinishedEvent:
-			//log.Printf("[%s] job run finished after %s", e.Job.JobName(), e.Result.RunTime())
-			if e.Result.Error != nil {
-				log.Printf("[%s] exited with error: %s", e.Result.Error)
+	for _, job := range conf.Jobs {
+		log.Printf("starting job %s", job.JobName())
+		logger := jobLogger{log, job.JobName()}
+		wg.Add(1)
+		go func(j Job) {
+			defer wg.Done()
+			err := job.JobDo(logger)
+			if err != nil {
+				logger.Printf("returned error: %+v", err)
 			}
-		case jobrun.JobScheduledEvent:
-			//log.Printf("[%s] scheduled to run at %s", e.Job.JobName(), e.DueAt)
-		case jobrun.JobrunIdleEvent:
-			//log.Printf("sleeping until %v", e.SleepUntil)
-		case jobrun.JobrunFinishedEvent:
-			//log.Printf("no more jobs")
-			break
-		}
+		}(job)
 	}
 
+	log.Printf("waiting for jobs from config to finish")
+	wg.Wait()
+
 }