Ejemplo n.º 1
0
func registerServiceViaDBusAvahi(name, serviceType string, serverPort uint16, txt []string) bool {
	conn, err := dbus.SystemBus()

	if err != nil {
		fmt.Fprintln(os.Stderr, "Failed to connect to D-BUS session bus:", err)
		return false
	}

	obj := conn.Object(AVAHI_DBUS_NAME, "/")

	var groupPath dbus.ObjectPath
	call := obj.Call("org.freedesktop.Avahi.Server.EntryGroupNew", 0)
	if call.Err != nil {
		fmt.Fprintln(os.Stderr, "Avahi not found on D-BUS")
		return false
	}
	call.Store(&groupPath)

	group := conn.Object(AVAHI_DBUS_NAME, groupPath)

	var txtBytes [][]byte
	for _, s := range txt {
		txtBytes = append(txtBytes, []byte(s))
	}

	var flags = uint32(0)
	var domain = string("")
	var host = string("")
	group.Call(AVAHI_ENTRYGROUP_ADD_SERVICE, 0, AVAHI_IF_UNSPEC, PROTO_UNSPEC, flags, name, serviceType, domain, host, serverPort, txtBytes)
	group.Call(AVAHI_ENTRYGROUP_COMMIT, 0)

	return true
}
Ejemplo n.º 2
0
// machinedRegister checks if nspawn should register the pod to machined
func machinedRegister() bool {
	// machined has a D-Bus interface following versioning guidelines, see:
	// http://www.freedesktop.org/wiki/Software/systemd/machined/
	// Therefore we can just check if the D-Bus method we need exists and we
	// don't need to check the signature.
	var found int

	conn, err := dbus.SystemBus()
	if err != nil {
		return false
	}
	node, err := introspect.Call(conn.Object("org.freedesktop.machine1", "/org/freedesktop/machine1"))
	if err != nil {
		return false
	}
	for _, iface := range node.Interfaces {
		if iface.Name != "org.freedesktop.machine1.Manager" {
			continue
		}
		// machined v215 supports methods "RegisterMachine" and "CreateMachine" called by nspawn v215.
		// machined v216+ (since commit 5aa4bb) additionally supports methods "CreateMachineWithNetwork"
		// and "RegisterMachineWithNetwork", called by nspawn v216+.
		for _, method := range iface.Methods {
			if method.Name == "CreateMachineWithNetwork" || method.Name == "RegisterMachineWithNetwork" {
				found++
			}
		}
		break
	}
	return found == 2
}
func main() {
	conn, err := dbus.SystemBus()
	if err != nil {
		log.Fatalln(err)
	}
	reply, err := conn.RequestName("system.powermanager", dbus.NameFlagDoNotQueue)
	if err != nil {
		log.Fatalln(err)
	}
	if reply != dbus.RequestNameReplyPrimaryOwner {
		log.Fatalln("system.powermanager already registered")
	}
	log.Infoln(conn.Names())
	pm := NewPowerManager(conn)
	err = conn.Export(&pm, "/powermanager", "system.powermanager")
	if err != nil {
		log.Fatalln("export powermanager:", err)
	}
	err = conn.Export(introspect.Introspectable(introRoot), "/", "org.freedesktop.DBus.Introspectable")
	if err != nil {
		log.Fatalln("export powermanager (introspectable-root):", err)
	}
	err = conn.Export(introspect.Introspectable(intro), "/powermanager", "org.freedesktop.DBus.Introspectable")
	if err != nil {
		log.Fatalln("export powermanager (introspectable):", err)
	}

	log.Fatalln(exec.Command("/home/steam/app_run.sh").Run())
}
Ejemplo n.º 4
0
func newDbusServer() (*dbusServer, error) {
	conn, err := dbus.SystemBus()
	if err != nil {
		return nil, err
	}

	reply, err := conn.RequestName(busName, dbus.NameFlagDoNotQueue)
	if err != nil {
		return nil, err
	}
	if reply != dbus.RequestNameReplyPrimaryOwner {
		return nil, errors.New("Bus name is already owned")
	}
	ds := &dbusServer{}

	if err := conn.Export(ds, objectPath, interfaceName); err != nil {
		return nil, err
	}

	ps := strings.Split(objectPath, "/")
	path := "/"
	for _, p := range ps {
		if len(path) > 1 {
			path += "/"
		}
		path += p

		if err := conn.Export(ds, dbus.ObjectPath(path), "org.freedesktop.DBus.Introspectable"); err != nil {
			return nil, err
		}
	}
	ds.conn = conn
	ds.prompter = newPrompter(conn)
	return ds, nil
}
Ejemplo n.º 5
0
// StartWithEnv starts this job (an instance, really) with the specified env.
func (j *job) StartWithEnv(env map[string]string) error {
	wait := true // TODO

	// connect to the system bus
	conn, err := dbus.SystemBus()
	if err != nil {
		return err
	}

	jobpath, err := j.dbusPath(conn)
	if err != nil {
		return err
	}

	// manipulate env map into env arr
	envarr := []string{}
	for k, v := range env {
		envarr = append(envarr, fmt.Sprintf("%s=%s", k, v))
	}

	// start a job instance based on the env
	err = conn.
		Object(upstartServiceDBusPath, jobpath).
		Call("com.ubuntu.Upstart0_6.Job.Start", 0, envarr, wait).
		Store(&jobpath)
	if err != nil {
		return err
	}

	return nil
}
Ejemplo n.º 6
0
func main() {
	bus, err := dbus.SystemBus()
	bus.RequestName("com.devicehive.alljoyn.test.basic",
		dbus.NameFlagDoNotQueue)

	if err != nil {
		log.Panic(err)
	}

	basicService := NewBasicService(bus)

	bus.Export(basicService, "/com/devicehive/alljoyn/test/basic", "org.alljoyn.About")
	bus.Export(basicService, "/com/devicehive/alljoyn/test/basic", "org.alljoyn.Bus.sample")
	bus.Export(basicService, "/com/devicehive/alljoyn/test/basic", "org.freedesktop.DBus.Introspectable")

	// Now try to register ourself in AllJoyn via dbus
	go func() {
		bridge := bus.Object("com.devicehive.alljoyn.bridge", dbus.ObjectPath("/com/devicehive/alljoyn/bridge"))
		res := bridge.Call("com.devicehive.alljoyn.bridge.AddService", 0, "/com/devicehive/alljoyn/test/basic", "com.devicehive.alljoyn.test.basic", "/sample", "org.alljoyn.Bus.sample", "")
		log.Printf("Result: %+v", res)
		res = bridge.Call("com.devicehive.alljoyn.bridge.StartAllJoyn", 0, "com.devicehive.alljoyn.test.basic")
	}()

	select {}
}
// RegisterMachine with systemd on the host system
func RegisterMachine(name string, id string, pid int, root_directory string) error {
	var (
		av  []byte
		err error
	)
	if conn == nil {
		conn, err = dbus.SystemBus()
		if err != nil {
			return err
		}
	}

	av, err = hex.DecodeString(id[0:32])
	if err != nil {
		return err
	}
	obj := conn.Object("org.freedesktop.machine1", "/org/freedesktop/machine1")
	service := os.Getenv("container")
	if service == "" {
		service = "runc"
	}
	/*	return obj.Call("org.freedesktop.machine1.Manager.RegisterMachine", 0, name[0:32], av, service, "container", uint32(pid), root_directory).Err
	 */
	return obj.Call("org.freedesktop.machine1.Manager.RegisterMachine", 0, name[0:32], av, service, "container", uint32(pid), "/").Err
	return nil
}
Ejemplo n.º 8
0
// execute function 'f' for each instance of this job.
func (j *job) foreachInstance(f func(*dbus.Conn, dbus.ObjectPath) error) error {

	conn, err := dbus.SystemBus()
	if err != nil {
		return err
	}

	jobpath, err := j.dbusPath(conn)
	if err != nil {
		return err
	}

	// list the instances
	var instpaths []dbus.ObjectPath
	err = conn.
		Object(upstartServiceDBusPath, jobpath).
		Call("com.ubuntu.Upstart0_6.Job.GetAllInstances", 0).
		Store(&instpaths)
	if err != nil {
		return err
	}

	for _, inst := range instpaths {
		err = f(conn, inst)
		if err != nil {
			return err
		}
	}

	return nil
}
Ejemplo n.º 9
0
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
}
Ejemplo n.º 10
0
func NewdbusWrapper(path string, iface string) (*dbusWrapper, error) {
	d := new(dbusWrapper)

	conn, err := dbus.SystemBus()
	if err != nil {
		conn, err = dbus.SessionBus()
		if err != nil {
			log.Panic(err)
		}
	}

	d.handlers = make(map[string]signalHandler)

	d.conn = conn
	d.path = path
	d.iface = iface
	d.queue = &signalQueue{cond: &sync.Cond{L: &sync.Mutex{}}}
	heap.Init(d.queue)

	filter := fmt.Sprintf("type='signal',path='%[1]s',interface='%[2]s',sender='%[2]s'", path, iface)
	log.Printf("Filter: %s", filter)

	conn.Object("org.freedesktop.DBus", "/org/freedesktop/DBus").Call("org.freedesktop.DBus.AddMatch", 0, filter)

	go func() {
		ch := make(chan *dbus.Signal, 2*QueueCapacity)
		conn.Signal(ch)
		for signal := range ch {
			if !((strings.Index(signal.Name, iface) == 0) && (string(signal.Path) == path)) {
				continue
			}
			if val, ok := d.handlers[signal.Name]; ok {
				for d.queue.Len() > QueueCapacity-1 {
					item := heap.Remove(d.queue, d.queue.Len()-1)
					log.Printf("Removing %+v from queue", item)
				}
				heap.Push(d.queue, signalItem{handler: val, signal: signal, timestamp: uint64(time.Now().Unix())})
			} else {
				log.Printf("Unhandled signal: %s", signal.Name)
			}
		}
	}()

	go func() {
		for {
			d.queue.cond.L.Lock()
			for d.queue.Len() == 0 {
				d.queue.cond.Wait()
			}
			d.queue.cond.L.Unlock()
			item := heap.Pop(d.queue).(signalItem)
			item.handler.handler(item.signal.Body...)
		}
	}()

	return d, nil
}
Ejemplo n.º 11
0
func main() {
	bus, err := dbus.SystemBus()

	if err != nil {
		log.Fatal(err)
	}

	// run as a child
	if len(spawnUUID) != 0 && len(spawnDbusServiceId) != 0 && len(spawnDbusPath) != 0 {
		allJoynBridge := NewAllJoynBridge(bus)
		allJoynBridge.addService(spawnUUID, spawnDbusServiceId, spawnDbusService, spawnDbusPath, spawnAlljoynService)
		select {} // exit?
		return
	}

	res, err := bus.RequestName("com.devicehive.alljoyn.bridge",
		dbus.NameFlagDoNotQueue)

	if err != nil {
		log.Fatalf("Failed to request dbus name: %s", err)
	}

	if res != dbus.RequestNameReplyPrimaryOwner {
		log.Fatalf("Failed to request dbus name: %+v", res)
	}

	allJoynBridge := NewAllJoynBridge(bus)

	bus.Export(allJoynBridge, "/com/devicehive/alljoyn/bridge", "com.devicehive.alljoyn.bridge")

	n := &introspect.Node{
		Interfaces: []introspect.Interface{
			{
				Name:    "com.devicehive.alljoyn.bridge",
				Methods: introspect.Methods(allJoynBridge),
				Signals: []introspect.Signal{},
			},
		},
	}

	root := &introspect.Node{
		Children: []introspect.Node{
			{
				Name: "com/devicehive/alljoyn/bridge",
			},
		},
	}

	bus.Export(introspect.NewIntrospectable(n), "/com/devicehive/alljoyn/bridge", "org.freedesktop.DBus.Introspectable")
	bus.Export(introspect.NewIntrospectable(root), "/", "org.freedesktop.DBus.Introspectable") // workaroud for dbus issue #14

	log.Printf("Bridge is Running.")

	select {}
}
Ejemplo n.º 12
0
func daemon() {
	conn, err := dbus.SystemBus()
	if err != nil {
		log.Fatal(err)
	}

	// Subscribe to device state changes so that we get notified when a device
	// gets activated. We can then trigger a connectivity check.
	if err := conn.BusObject().Call(
		"org.freedesktop.DBus.AddMatch",
		0,
		"type='signal',"+
			"interface='org.freedesktop.NetworkManager.Device',"+
			"member='StateChanged'").Err; err != nil {
		log.Fatal(err)
	}

	connectivityChanged := make(chan bool)

	// If filterStateChanges does not read signals fast enough, i.e. the signal
	// channel write blocks, godbus will panic. The intention of the channel
	// buffer (which was arbitrarily sized) is to make that situation as
	// unlikely as possible.
	signals := make(chan *dbus.Signal, 100)
	conn.Signal(signals)
	go filterStateChanges(signals, connectivityChanged)

	for {
		select {
		case <-connectivityChanged:
			log.Printf("Connectivity changed. Waiting for the situation to settle (1m without changes).\n")

		Settled:
			for {
				select {
				case <-connectivityChanged:
					log.Printf("Connectivity changed again, waiting another 1m.\n")
				case <-time.After(1 * time.Minute):
					break Settled
				}
			}

			log.Printf("could check for an update now\n")
			if err := pull(); err != nil {
				log.Fatal(err)
			}

		case <-time.After(1 * time.Hour):
			log.Printf("check opportunistically for an update now\n")
			if err := pull(); err != nil {
				log.Fatal(err)
			}
		}
	}
}
// TerminateMachine registered with systemd on the host system
func TerminateMachine(name string) error {
	var err error
	if conn == nil {
		conn, err = dbus.SystemBus()
		if err != nil {
			return err
		}
	}
	obj := conn.Object("org.freedesktop.machine1", "/org/freedesktop/machine1")
	return obj.Call("org.freedesktop.machine1.Manager.TerminateMachine", 0, name).Err
}
Ejemplo n.º 14
0
// SystemBus is part of Interface
func (db *dbusImpl) SystemBus() (Connection, error) {
	if db.systemBus == nil {
		bus, err := godbus.SystemBus()
		if err != nil {
			return nil, err
		}
		db.systemBus = &connImpl{bus}
	}

	return db.systemBus, nil
}
Ejemplo n.º 15
0
func ConnectToDBus(bus string) (*DBusClient, error) {
	c := new(DBusClient)

	var err error
	switch bus {
	case "session":
		c.bus, err = dbus.SessionBus()

	case "system":
		c.bus, err = dbus.SystemBus()

	default:
		c.bus, err = dbus.Dial(bus)
	}

	if err != nil {
		return nil, err
	}
	if !c.bus.SupportsUnixFDs() {
		return nil, errors.New("DBus connection does not support file descriptors")
	}

	c.path = dbus.ObjectPath("/com/firelizzard/teasvc/Client")
	err = c.bus.Export(c, c.path, "com.firelizzard.teasvc.Client")
	if err != nil {
		return nil, err
	}

	c.sigchans = make(map[string](chan *dbus.Signal))
	chsig := make(chan *dbus.Signal, 10)

	go func() {
		for {
			sig := <-chsig
			ch, ok := c.sigchans[sig.Name]
			if !ok {
				log.Print("Unhandled signal: " + sig.Name)
			}

			select {
			case ch <- sig:
				// sent singal, done

			default:
				log.Print("Unhandled signal (full channel): " + sig.Name)
			}
		}
	}()
	c.bus.Signal(chsig)
	c.bus.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, "type='signal',interface='com.firelizzard.teasvc',member='Pong'")

	return c, nil
}
Ejemplo n.º 16
0
Archivo: base.go Proyecto: ecc1/ble
func Open() (*Connection, error) {
	bus, err := dbus.SystemBus()
	if err != nil {
		return nil, err
	}
	conn := Connection{bus: bus}
	err = conn.Update()
	if err != nil {
		conn.Close()
		return nil, err
	}
	return &conn, nil
}
Ejemplo n.º 17
0
func New() *Interface {
	bus, err := dbus.SystemBus()
	if err != nil {
		return &Interface{}
	}

	fw := &Interface{
		obj: bus.Object(firewalldName, dbus.ObjectPath(firewalldPath)),
	}

	go fw.dbusSignalHandler(bus)

	return fw
}
Ejemplo n.º 18
0
func (s *Service) Enable() (err error) {
	s.System, err = dbus.SystemBus()
	if err != nil {
		return err
	}

	s.Session, err = dbus.SessionBus()
	if err != nil {
		return err
	}

	s.Subscribe("notify", "", s.handleNotify)
	s.Subscribe("poweroff", "", s.handlePowerOff)

	return s.setupSignals()
}
Ejemplo n.º 19
0
func NewDbus(path, iface string) (*Dbus, error) {
	w := new(Dbus)

	conn, err := dbus.SystemBus()
	if err != nil {
		conn, err = dbus.SessionBus()
		if err != nil {
			return nil, err
		}
	}

	w.path = path
	w.iface = iface
	w.conn = conn
	return w, nil
}
Ejemplo n.º 20
0
func main() {
	var err error
	SystemBus, err = dbus.SystemBus()
	if err != nil {
		log.Errorln("connect to system bus:", err)
	} else {
		go monitor(SystemBus, "system")
	}
	SessionBus, err = dbus.SessionBus()
	if err != nil {
		log.Errorln("connect to session bus:", err)
	} else {
		go monitor(SessionBus, "session")
	}

	log.Fatalln(ListenAndServe(":3000"))
}
Ejemplo n.º 21
0
func main() {
	say.SetLevelWithConfName("info")

	configFile, config, err := conf.FromArgs()
	switch {
	case err != nil:
		say.Fatalf("Cannot read configuration in `%s` with error: %s", configFile, err.Error())
	case configFile == "":
		say.Infof("You should specify configuration file. Starting with test configuration: %+v", config)
	default:
		say.Infof("Starting DeviceHive gateway with configuration in '%s': %+v", configFile, config)
	}

	say.SetLevelWithConfName(config.LoggingLevel)

	bus, err := dbus.SystemBus()
	if err != nil {
		say.Infof("Cannot get system bus with error: %s", err.Error())
		say.Infof("Trying to use session bus for testing purposes...")
		if bus, err = dbus.SessionBus(); err != nil {
			say.Fatalf("Cannot get session bus with error: %s\n", err.Error())
			return
		}
	}

	reply, err := bus.RequestName(DBusConnName, dbus.NameFlagDoNotQueue)
	switch {
	case err != nil:
		say.Fatalf("Cannot request name '%s' with error: %s\n", DBusConnName, err.Error())
	case reply != dbus.RequestNameReplyPrimaryOwner:
		say.Fatalf("The name '%s' already taken.", DBusConnName)
	}

	if config.DeviceNotificationReceive == conf.DeviceNotificationReceiveByWS {
		say.Infof("Starting as websocket...")
		wsImplementation(bus, config)
		return
	}

	if config.DeviceNotificationReceive == conf.DeviceNotificationReceiveByREST {
		say.Infof("Starting as rest...")
		restImplementation(bus, config)
		return
	}

}
Ejemplo n.º 22
0
// Detect returns true if the system we're running on has an upstart daemon listening on
// its known address and we're able to communicate with it.
func Detect() bool {
	versionPropPath := "com.ubuntu.Upstart0_6.version"

	// connect to the system bus
	conn, err := dbus.SystemBus()
	if err != nil {
		return false
	}

	_, err = conn.
		Object(upstartServiceDBusPath, upstartManagerObject).
		GetProperty(versionPropPath)
	if err != nil {
		return false
	}

	return true
}
Ejemplo n.º 23
0
func waitForMachinedRegistration(uuid string) error {
	conn, err := dbus.SystemBus()
	if err != nil {
		return err
	}
	machined := conn.Object("org.freedesktop.machine1", "/org/freedesktop/machine1")
	machineName := "rkt-" + uuid

	var o dbus.ObjectPath
	for i := 0; i < 10; i++ {
		if err := machined.Call("org.freedesktop.machine1.Manager.GetMachine", 0, machineName).Store(&o); err == nil {
			return nil
		}
		time.Sleep(time.Millisecond * 50)
	}

	return errors.New("pod not found")
}
Ejemplo n.º 24
0
func main() {
	configFile, config, err := conf.FromArgs()
	switch {
	case err != nil:
		log.Fatalf("Failed to read %q configuration (%s)", configFile, err)
	case configFile == "":
		log.Warnf("No configuration file provided!")
		log.Infof("Test configuration is used: %+v", config)
	default:
		log.Infof("Starting DeviceHive with %q configuration: %+v", configFile, config)
	}

	log.SetLevelByName(config.LoggingLevel)

	bus, err := dbus.SystemBus()
	if err != nil {
		log.Warnf("Cannot get system bus (error: %s)", err)
		log.Infof("Trying to use session bus for testing purposes...")
		if bus, err = dbus.SessionBus(); err != nil {
			log.Fatalf("Cannot get session bus (error: %s)", err)
			return
		}
	}

	reply, err := bus.RequestName(DBusConnName, dbus.NameFlagDoNotQueue)
	switch {
	case err != nil:
		log.Fatalf("Cannot request name %q (error: %s)", DBusConnName, err)
	case reply != dbus.RequestNameReplyPrimaryOwner:
		log.Fatalf("The name %q already taken", DBusConnName)
	}

	s, err := devicehive.NewService(config.URL, config.AccessKey)
	if err != nil {
		log.Fatalf("Failed to create DeviceHive service (error: %s)", err)
	}

	log.Infof("Starting %v", s)
	mainLoop(bus, s, config)
}
Ejemplo n.º 25
0
func GetVisibleNetworks() ([]string, error) {
	conn, err := dbus.SystemBus()
	if err != nil {
		panic(err)
	}

	obj := conn.Object("org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager")

	networkDevices := []dbus.ObjectPath{}
	if err := obj.Call("org.freedesktop.NetworkManager.GetDevices", 0).Store(&networkDevices); err != nil {
		panic(err)
	}

	ret := []string{}

	for _, el := range networkDevices {
		obj := conn.Object("org.freedesktop.NetworkManager", el)
		accessPoints := []dbus.ObjectPath{}
		if err := obj.Call(
			"org.freedesktop.NetworkManager.Device.Wireless.GetAccessPoints",
			0,
		).Store(&accessPoints); err != nil {
			continue
		}
		for _, accessPoint := range accessPoints {
			obj := conn.Object("org.freedesktop.NetworkManager", accessPoint)

			ssid, err := obj.GetProperty(
				"org.freedesktop.NetworkManager.AccessPoint.Ssid",
			)

			if err != nil {
				panic(err)
			}
			ret = append(ret, string(ssid.Value().([]uint8)))
		}
	}

	return ret, nil
}
Ejemplo n.º 26
0
func (m *unitMonitor) getProp(name string) dbus.Variant {

	var ret dbus.Variant

	c, err := dbus.SystemBus()
	if err != nil {
		log.Println(err)
		return ret
	}

	err = c.Object("org.freedesktop.systemd1", m.path).Call(
		propGet,
		0,
		"org.freedesktop.systemd1.Unit",
		name,
	).Store(&ret)

	if err != nil {
		log.Println(err)
	}
	return ret
}
Ejemplo n.º 27
0
func NewdbusWrapper(path string, iface string) (*dbusWrapper, error) {
	d := new(dbusWrapper)

	conn, err := dbus.SystemBus()
	if err != nil {
		log.Panic(err)
	}

	d.handlers = make(map[string]signalHandlerFunc)

	d.conn = conn
	d.path = path
	d.iface = iface
	d.readingsBuffer = make(map[string]*[]float64)
	d.scanMap = make(map[string]bool)

	filter := fmt.Sprintf("type='signal',path='%[1]s',interface='%[2]s',sender='%[2]s'", path, iface)
	log.Printf("Filter: %s", filter)

	conn.Object("org.freedesktop.DBus", "/org/freedesktop/DBus").Call("org.freedesktop.DBus.AddMatch", 0, filter)

	go func() {
		ch := make(chan *dbus.Signal, 1)
		conn.Signal(ch)
		for signal := range ch {
			if !((strings.Index(signal.Name, iface) == 0) && (string(signal.Path) == path)) {
				continue
			}
			if handler, ok := d.handlers[signal.Name]; ok {
				go handler(signal.Body...)
			} else {
				log.Printf("Unhandled signal: %s", signal.Name)
			}
		}
	}()

	return d, nil
}
Ejemplo n.º 28
0
func (m *unitMonitor) getUnitPath() dbus.ObjectPath {

	var ret dbus.ObjectPath

	c, err := dbus.SystemBus()
	if err != nil {
		return ret
	}

	obj := c.Object("org.freedesktop.systemd1", "/org/freedesktop/systemd1")
	call := obj.Call("org.freedesktop.systemd1.Manager.GetUnit", 0, m.name)
	if call != nil && call.Err != nil {
		log.Println(err)
		return ret
	}

	if err := call.Store(&ret); err != nil {
		log.Println(err)
		return ret
	}

	return ret
}
Ejemplo n.º 29
0
func ExportToDBus(proc *Process, bus string) (*DBusServer, error) {
	s := new(DBusServer)
	s.proc = proc

	var err error
	switch bus {
	case "session":
		s.bus, err = dbus.SessionBus()

	case "system":
		s.bus, err = dbus.SystemBus()

	default:
		s.bus, err = dbus.Dial(bus)
	}

	if err != nil {
		return nil, err
	}
	if !s.bus.SupportsUnixFDs() {
		return nil, errors.New("DBus connection does not support file descriptors")
	}

	s.path = dbus.ObjectPath("/com/firelizzard/teasvc/Server")
	go s.handleSignals()

	err = s.bus.Export(s, s.path, "com.firelizzard.teasvc.Server")
	if err != nil {
		return nil, err
	}

	c := s.bus.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, "type='signal',interface='com.firelizzard.teasvc',member='Ping'")
	if c.Err != nil {
		return nil, c.Err
	}
	return s, nil
}
Ejemplo n.º 30
0
// Innitialize D-Bus connection.
func (c *Conn) initConnection() error {
	var err error

	c.sysconn, err = dbus.SystemBus()
	if err != nil {
		return err
	}

	// This never fails, even if the service is not running atm.
	c.sysobj = c.sysconn.Object(dbusInterface, dbus.ObjectPath(dbusPath))

	rule := fmt.Sprintf("type='signal',path='%s',interface='%s',sender='%s',member='Reloaded'",
		dbusPath, dbusInterface, dbusInterface)
	c.sysconn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, rule)

	rule = fmt.Sprintf("type='signal',interface='org.freedesktop.DBus',member='NameOwnerChanged',path='/org/freedesktop/DBus',sender='org.freedesktop.DBus',arg0='%s'",
		dbusInterface)
	c.sysconn.BusObject().Call("org.freedesktop.DBus.AddMatch", 0, rule)

	c.signal = make(chan *dbus.Signal, 10)
	c.sysconn.Signal(c.signal)

	return nil
}