wip: refactor(config): completed task structure

task/cron.go

@@ -66,55 +66,104 @@ func (cms *CronMultiOccurrenceSpec) Match(u uint8) bool {
 	return false
 }
 
-type Cron struct {
+type CronTask struct {
 	CronSchedule
-	name    string
-	command []string
-	lastRun time.Time
-	hasRun  bool //NOTE: make sure initialised as false
+	name       string
+	command    []string
+	environ    []string
+	setsid     bool
+	user       string
+	group      string
+	workingDir string
+	lastRun    time.Time
+	hasRun     bool //NOTE: make sure initialised as false
 }
 
-func (c *Cron) Name() string {
+func NewCronTask(name string) *CronTask {
+	return &CronTask{
+		name:   name,
+		hasRun: false,
+	}
+}
+
+func (c *CronTask) SetCommand(cmds ...string) *CronTask {
+	c.command = make([]string, len(cmds))
+	copy(c.command, cmds)
+	return c
+}
+
+func (c *CronTask) SetEnv(envs ...string) *CronTask {
+	c.environ = make([]string, len(envs))
+	copy(c.environ, envs)
+	return c
+}
+
+func (c *CronTask) SetFlagSetsid(flag bool) *CronTask {
+	c.setsid = flag
+	return c
+}
+
+func (c *CronTask) SetWorkingDir(path string) *CronTask {
+	c.workingDir = path
+	return c
+}
+
+func (c *CronTask) SetUser(user string) *CronTask {
+	c.user = user
+	return c
+}
+
+func (c *CronTask) SetGroup(group string) *CronTask {
+	c.group = group
+	return c
+}
+
+func (c *CronTask) SetSchedule(schedule CronSchedule) *CronTask {
+	c.CronSchedule = schedule
+	return c
+}
+
+func (c *CronTask) Name() string {
 	return c.name
 }
 
-func (c *Cron) Command() []string {
+func (c *CronTask) Command() []string {
 	retval := make([]string, len(c.command))
 	copy(retval, c.command)
 	return retval
 }
 
-func (c *Cron) Environ() []string {
+func (c *CronTask) Environ() []string {
 	panic("not implemented")
 	return nil
 }
 
-func (c *Cron) Setsid() bool {
+func (c *CronTask) Setsid() bool {
 	panic("not implemented")
 	return false
 }
 
-func (c *Cron) UserGroup() wminit.UserGroup {
+func (c *CronTask) UserGroup() wminit.UserGroup {
 	panic("not implemented")
 	return nil
 }
 
-func (c *Cron) Background() bool {
-	panic("not implemented")
+func (c *CronTask) Background() bool {
+	//NOTE: cron will always return false for this
 	return false
 }
 
-func (c *Cron) WorkingDir() string {
+func (c *CronTask) WorkingDir() string {
 	panic("not implemented")
 	return ""
 }
 
-func (c *Cron) Status() wminit.TaskStatus {
+func (c *CronTask) Status() wminit.TaskStatus {
 	panic("not implemented")
 	return nil
 }
 
-func (c *Cron) TimeToRun(now time.Time) bool {
+func (c *CronTask) TimeToRun(now time.Time) bool {
 	if c.Minute.Match(uint8(now.Minute())) &&
 		c.Hour.Match(uint8(now.Hour())) &&
 		c.DoM.Match(uint8(now.Day())) &&

task/task.go

@@ -17,19 +17,21 @@ func NewTasks() *Tasks {
 }
 
 func (ts *Tasks) AddV0Service(path string) {
-	ts.services = append(ts.services, &ServiceTask{
-		name:    path,
-		command: []string{path},
-	})
+	ts.AddService(NewServiceTask(path)).SetCommand(path)
+}
+
+func (ts *Tasks) AddService(serviceTask *ServiceTask) *ServiceTask {
+	ts.services = append(ts.services, serviceTask)
+	return serviceTask
 }
 
 func (ts *Tasks) AddV0Cron(schedule CronSchedule, path string) {
-	ts.crones = append(ts.crones, &Cron{
-		CronSchedule: schedule,
-		name:         path,
-		command:      []string{path},
-		hasRun:       false,
-	})
+	ts.AddCron(NewCronTask(path)).SetCommand(path).SetSchedule(schedule)
+}
+
+func (ts *Tasks) AddCron(cronTask *CronTask) *CronTask {
+	ts.crones = append(ts.crones, cronTask)
+	return cronTask
 }
 
 func (ts *Tasks) List() []wminit.Task {
@@ -57,11 +59,57 @@ func (ts *Tasks) Get(name string) (wminit.Task, error) {
 }
 
 type ServiceTask struct {
-	name    string
-	command []string
-	environ []string
-	setsid  bool
-	//TODO: user group
+	name       string
+	command    []string
+	environ    []string
+	setsid     bool
+	user       string
+	group      string
+	background bool
+	workingDir string
+}
+
+func NewServiceTask(name string) *ServiceTask {
+	return &ServiceTask{
+		name: name,
+	}
+}
+
+func (t *ServiceTask) SetCommand(cmds ...string) *ServiceTask {
+	t.command = make([]string, len(cmds))
+	copy(t.command, cmds)
+	return t
+}
+
+func (t *ServiceTask) SetEnv(envs ...string) *ServiceTask {
+	t.environ = make([]string, len(envs))
+	copy(t.environ, envs)
+	return t
+}
+
+func (t *ServiceTask) SetFlagSetsid(flag bool) *ServiceTask {
+	t.setsid = flag
+	return t
+}
+
+func (t *ServiceTask) SetFlagBackground(flag bool) *ServiceTask {
+	t.background = flag
+	return t
+}
+
+func (t *ServiceTask) SetWorkingDir(path string) *ServiceTask {
+	t.workingDir = path
+	return t
+}
+
+func (t *ServiceTask) SetUser(user string) *ServiceTask {
+	t.user = user
+	return t
+}
+
+func (t *ServiceTask) SetGroup(group string) *ServiceTask {
+	t.group = group
+	return t
 }
 
 func (t *ServiceTask) Name() string {

task/task_test.go

@@ -43,7 +43,7 @@ func TestTasks_List(t *testing.T) {
 		},
 	}
 	tasks.crones = []wminit.CronTask{
-		&Cron{
+		&CronTask{
 			CronSchedule: CronSchedule{
 				Minute: NewCronAnySpec(),
 				Hour:   NewCronAnySpec(),
@@ -54,7 +54,7 @@ func TestTasks_List(t *testing.T) {
 			name:    "cron-one",
 			command: []string{"/path/to/executable"},
 		},
-		&Cron{
+		&CronTask{
 			CronSchedule: CronSchedule{
 				Minute: NewCronAnySpec(),
 				Hour:   NewCronAnySpec(),