func (c *Conn) StartUnit(name string, mode string) (string, error) {
	return c.runJob("org.freedesktop.systemd1.Manager.StartUnit", name, mode)
}
StartUnit enqeues a start job and depending jobs, if any (unless otherwise
specified by the mode string).

Takes the unit to activate, plus a mode string. The mode needs to be one of
replace, fail, isolate, ignore-dependencies, ignore-requirements. If
"replace" the call will start the unit and its dependencies, possibly
replacing already queued jobs that conflict with this. If "fail" the call
will start the unit and its dependencies, but will fail if this would change
an already queued job. If "isolate" the call will start the unit in question
and terminate all units that aren't dependencies of it. If
"ignore-dependencies" it will start a unit but ignore all its dependencies.
If "ignore-requirements" it will start a unit but only ignore the
requirement dependencies. It is not recommended to make use of the latter
two options.

Result string: one of done, canceled, timeout, failed, dependency, skipped.
done indicates successful execution of a job. canceled indicates that a job
has been canceled  before it finished execution. timeout indicates that the
job timeout was reached. failed indicates that the job failed. dependency
indicates that a job this job has been depending on failed and the job hence
has been removed too. skipped indicates that a job was skipped because it
didn't apply to the units current state.
package dbus
import (
	"errors"
	"github.com/guelfey/go.dbus"
)
func (c *Conn) initJobs() {
	c.jobListener.jobs = make(map[dbus.ObjectPath]chan string)
}
func (c *Conn) jobComplete(signal *dbus.Signal) {
	var id uint32
	var job dbus.ObjectPath
	var unit string
	var result string
	dbus.Store(signal.Body, &id, &job, &unit, &result)
	c.jobListener.Lock()
	out, ok := c.jobListener.jobs[job]
	if ok {
		out <- result
		delete(c.jobListener.jobs, job)
	}
	c.jobListener.Unlock()
}
func (c *Conn) startJob(job string, args ...interface{}) (<-chan string, error) {
	c.jobListener.Lock()
	defer c.jobListener.Unlock()
	ch := make(chan string, 1)
	var path dbus.ObjectPath
	err := c.sysobj.Call(job, 0, args...).Store(&path)
	if err != nil {
		return nil, err
	}
	c.jobListener.jobs[path] = ch
	return ch, nil
}
func (c *Conn) runJob(job string, args ...interface{}) (string, error) {
	respCh, err := c.startJob(job, args...)
	if err != nil {
		return "", err
	}
	return <-respCh, nil
}