// DisableUnitFiles() may be used to disable one or more units in the system (by
// removing symlinks to them from /etc or /run).
//
// It takes a list of unit files to disable (either just file names or full
// absolute paths if the unit files are residing outside the usual unit
// search paths), and one boolean: whether the unit was enabled for runtime
// only (true, /run), or persistently (false, /etc).
//
// This call returns an array with the changes made. The changes list
// consists of structures with three strings: the type of the change (one of
// symlink or unlink), the file name of the symlink and the destination of the
// symlink.
func (c *Conn) DisableUnitFiles(files []string, runtime bool) ([]DisableUnitFileChange, error) {
result := make([][]interface{}, 0)
err := c.sysobj.Call("org.freedesktop.systemd1.Manager.DisableUnitFiles", 0, files, runtime).Store(&result)
if err != nil {
return nil, err
}
resultInterface := make([]interface{}, len(result))
for i := range result {
resultInterface[i] = result[i]
}
changes := make([]DisableUnitFileChange, len(result))
changesInterface := make([]interface{}, len(changes))
for i := range changes {
changesInterface[i] = &changes[i]
}
err = dbus.Store(resultInterface, changesInterface...)
if err != nil {
return nil, err
}
return changes, nil
}
// ListFileUnits returns an array -> `systemctl list-unit-files`.
func (c *Conn) ListUnitFiles() ([]UnitFileStatus, error) {
result := make([][]interface{}, 0)
err := c.sysobj.Call("org.freedesktop.systemd1.Manager.ListUnitFiles", 0).Store(&result)
if err != nil {
return nil, err
}
resultInterface := make([]interface{}, len(result))
for i := range result {
resultInterface[i] = result[i]
}
status := make([]UnitFileStatus, len(result))
statusInterface := make([]interface{}, len(status))
for i := range status {
statusInterface[i] = &status[i]
}
err = dbus.Store(resultInterface, statusInterface...)
if err != nil {
return nil, err
}
return status, nil
}
// EnableUnitFiles() may be used to enable one or more units in the system (by
// creating symlinks to them in /etc or /run).
//
// It takes a list of unit files to enable (either just file names or full
// absolute paths if the unit files are residing outside the usual unit
// search paths), and two booleans: the first controls whether the unit shall
// be enabled for runtime only (true, /run), or persistently (false, /etc).
// The second one controls whether symlinks pointing to other units shall
// be replaced if necessary.
//
// This call returns one boolean and an array with the changes made. The
// boolean signals whether the unit files contained any enablement
// information (i.e. an [Install]) section. The changes list consists of
// structures with three strings: the type of the change (one of symlink
// or unlink), the file name of the symlink and the destination of the
// symlink.
func (c *Conn) EnableUnitFiles(files []string, runtime bool, force bool) (bool, []EnableUnitFileChange, error) {
var carries_install_info bool
result := make([][]interface{}, 0)
err := c.sysobj.Call("org.freedesktop.systemd1.Manager.EnableUnitFiles", 0, files, runtime, force).Store(&carries_install_info, &result)
if err != nil {
return false, nil, err
}
resultInterface := make([]interface{}, len(result))
for i := range result {
resultInterface[i] = result[i]
}
changes := make([]EnableUnitFileChange, len(result))
changesInterface := make([]interface{}, len(changes))
for i := range changes {
changesInterface[i] = &changes[i]
}
err = dbus.Store(resultInterface, changesInterface...)
if err != nil {
return false, nil, err
}
return carries_install_info, changes, nil
}
func (c *Conn) listUnitsInternal(f storeFunc) ([]UnitStatus, error) {
result := make([][]interface{}, 0)
err := f(&result)
if err != nil {
return nil, err
}
resultInterface := make([]interface{}, len(result))
for i := range result {
resultInterface[i] = result[i]
}
status := make([]UnitStatus, len(result))
statusInterface := make([]interface{}, len(status))
for i := range status {
statusInterface[i] = &status[i]
}
err = dbus.Store(resultInterface, statusInterface...)
if err != nil {
return nil, err
}
return status, nil
}
func (c *Conn) listUnitFilesInternal(f storeFunc) ([]UnitFile, error) {
result := make([][]interface{}, 0)
err := f(&result)
if err != nil {
return nil, err
}
resultInterface := make([]interface{}, len(result))
for i := range result {
resultInterface[i] = result[i]
}
files := make([]UnitFile, len(result))
fileInterface := make([]interface{}, len(files))
for i := range files {
fileInterface[i] = &files[i]
}
err = dbus.Store(resultInterface, fileInterface...)
if err != nil {
return nil, err
}
return files, nil
}
// ListUnitFiles returns an array of all available units on disk.
func (c *Conn) ListUnitFiles() ([]UnitFile, error) {
result := make([][]interface{}, 0)
err := c.sysobj.Call("org.freedesktop.systemd1.Manager.ListUnitFiles", 0).Store(&result)
if err != nil {
return nil, err
}
resultInterface := make([]interface{}, len(result))
for i := range result {
resultInterface[i] = result[i]
}
files := make([]UnitFile, len(result))
fileInterface := make([]interface{}, len(files))
for i := range files {
fileInterface[i] = &files[i]
}
err = dbus.Store(resultInterface, fileInterface...)
if err != nil {
return nil, err
}
return files, nil
}
func (c *logindDbus) listSessions() ([]logindSessionEntry, error) {
var result [][]interface{}
err := c.object.Call(dbusObject+".Manager.ListSessions", 0).Store(&result)
if err != nil {
return nil, err
}
resultInterface := make([]interface{}, len(result))
for i := range result {
resultInterface[i] = result[i]
}
sessions := make([]logindSessionEntry, len(result))
sessionsInterface := make([]interface{}, len(sessions))
for i := range sessions {
sessionsInterface[i] = &sessions[i]
}
err = dbus.Store(resultInterface, sessionsInterface...)
if err != nil {
return nil, err
}
return sessions, nil
}
func (c *logindDbus) listSeats() ([]string, error) {
var result [][]interface{}
err := c.object.Call(dbusObject+".Manager.ListSeats", 0).Store(&result)
if err != nil {
return nil, err
}
resultInterface := make([]interface{}, len(result))
for i := range result {
resultInterface[i] = result[i]
}
seats := make([]logindSeatEntry, len(result))
seatsInterface := make([]interface{}, len(seats))
for i := range seats {
seatsInterface[i] = &seats[i]
}
err = dbus.Store(resultInterface, seatsInterface...)
if err != nil {
return nil, err
}
ret := make([]string, len(seats)+1)
for i := range seats {
ret[i] = seats[i].SeatId
}
// Always add the empty seat, which is used for remote sessions like SSH
ret[len(seats)] = ""
return ret, nil
}
// Check whether the InterfacesAdded signal contains deviceInterface
// See http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager
func containsDevice(s *dbus.Signal) bool {
var dict map[string]map[string]dbus.Variant
err := dbus.Store(s.Body[1:2], &dict)
if err != nil {
return false
}
return dict[deviceInterface] != nil
}
func (m *unitMonitor) watch() error {
conn, err := dbus.SystemBus()
if err != nil {
return err
}
m.path = m.getUnitPath()
// subscribe the props changes signal
props := fmt.Sprintf("type='signal',path='%s',interface='org.freedesktop.DBus.Properties'", m.path)
call := conn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, props)
if call != nil && call.Err != nil {
return call.Err
}
// unsubscribe on return
defer func() {
conn.BusObject().Call("org.freedesktop.DBus.RemoveMatch", 0, props)
}()
signal := make(chan *dbus.Signal, 10)
defer close(signal)
conn.Signal(signal)
log.Printf("watching for %s @%s\n", m.name, m.path)
for {
select {
case ev := <-signal:
switch ev.Name {
case propertiesChanged:
var iName string
var changedProps map[string]dbus.Variant
var invProps []string
if ev.Path == m.path {
if err := dbus.Store(ev.Body, &iName, &changedProps, &invProps); err != nil {
log.Println(err.Error())
log.Println("aku dead")
continue
}
if iName == "org.freedesktop.systemd1.Unit" {
m.chanPub <- m.generateStatus()
}
}
}
case <-m.done:
return nil
}
}
return nil
}
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
}
c.jobListener.Unlock()
}
func applyHandler(s *dbus.Signal) {
handler := notifyHandler[s.Path]
if handler == nil {
log.Printf("%s: no notify handler", s.Path)
return
}
// Reflection used by dbus.Store() requires explicit type here.
var changed map[string]dbus.Variant
dbus.Store(s.Body[1:2], &changed)
keys := []string{}
for k, _ := range changed {
keys = append(keys, k)
}
data, ok := changed["Value"].Value().([]byte)
if ok {
go handler(data)
}
}
// Store is part of the Call interface
func (call *fakeCall) Store(retvalues ...interface{}) error {
if call.err != nil {
return call.err
}
return godbus.Store(call.ret, retvalues...)
}
