Merge lp:~mvo/go-dbus/dbus-service into lp:go-dbus/v1

[Michael Vogt]

This branch adds a new DBusService helper that can be used to export a existing type over dbus. Its loosely modeled after the python dbus way of exporting objects.

The idea is that you can simply do:
"""
type Impl struct {
}
func (m *Impl) Something() error {
 return nil
}
ser := NewDBusService(dbus.Connect(dbus.SessionBus), INTERFACE, OBJECT_PATH, BUS_NAME, impl)
"""
and this makes it possible to call Impl.Something() over dbus.

This diff is mostly meant to start a discussion if this is the right approach. If you guys like it the error checking of the reflect code needs to be improved, the test needs to test for various error conditions (wrong parameter count, wrong types etc) and it would be nice if it would generate introspect data automatically for the dbus introspection interface.

In r135,136 it also contains a testcase and a fix for a hang that can happen when a dbus method sends a signal with a active watcher before the reply of the method is send.

Unmerged revisions

136. By Michael Vogt on 2015-01-30

dbus.go: fix previous hang by running the watcher callbacks in a go routine

135. By Michael Vogt on 2015-01-30

add FAILING test (it hangs) that shows how go-dbus hangs when a method is sending a Signal in the dbus message before sending a reply msg

134. By Michael Vogt on 2015-01-07

Add DBusService wrapper

=== modified file 'dbus.go'
--- dbus.go	2014-11-19 19:24:28 +0000
+++ dbus.go	2015-01-30 09:31:50 +0000
@@ -238,7 +238,7 @@
 		watches := p.signalMatchRules.FindMatches(msg)
 		p.handlerMutex.Unlock()
 		for _, watch := range watches {
-			watch.cb(msg)
+			go watch.cb(msg)
 		}
 	}
 	return nil

=== added file 'service.go'
--- service.go	1970-01-01 00:00:00 +0000
+++ service.go	2015-01-30 09:31:50 +0000
@@ -0,0 +1,87 @@
+package dbus
+
+import (
+	"fmt"
+	"log"
+	"reflect"
+	"runtime"
+)
+
+type DBusService struct {
+	conn    *Connection
+	msgChan chan *Message
+
+	BusInterface string
+	BusPath      string
+	BusName      string
+
+	actor interface{}
+}
+
+func NewDBusService(conn *Connection, interf, path, name string, actor interface{}) *DBusService {
+	s := &DBusService{
+		conn:         conn,
+		msgChan:      make(chan *Message),
+		BusInterface: interf,
+		BusPath:      path,
+		BusName:      name,
+		actor:        actor}
+	runtime.SetFinalizer(s, cleanupDBusService)
+
+	nameOnBus := conn.RequestName(name, NameFlagDoNotQueue)
+	err := <-nameOnBus.C
+	if err != nil {
+		fmt.Errorf("bus name coule not be taken %s", err)
+		return nil
+	}
+	go s.watchBus()
+	conn.RegisterObjectPath(ObjectPath(path), s.msgChan)
+	return s
+}
+
+func (s *DBusService) Send(msg *Message) (err error) {
+	return s.conn.Send(msg)
+}
+
+func (s *DBusService) watchBus() {
+	for msg := range s.msgChan {
+		var reply *Message
+		switch {
+		case msg.Interface == s.BusInterface:
+			methodName := msg.Member
+			m := reflect.ValueOf(s.actor).MethodByName(methodName)
+			if !m.IsValid() {
+				reply = NewErrorMessage(msg, "method-not-found", fmt.Sprintf("method %s not found for %s", methodName, s.actor))
+				break
+			}
+			allArgs := msg.AllArgs()
+			params := make([]reflect.Value, len(allArgs))
+			for i, arg := range allArgs {
+				params[i] = reflect.ValueOf(arg)
+			}
+			// FIMXE: check if params match the method signature
+			ret := m.Call(params)
+			// FIXME: check we always get at least one value
+			//        back
+			errVal := ret[len(ret)-1]
+			if !errVal.IsNil() {
+				reply = NewErrorMessage(msg, "method-returned-error", fmt.Sprintf("%v", reflect.ValueOf(errVal)))
+				break
+			}
+			reply = NewMethodReturnMessage(msg)
+			for i := 0; i < len(ret)-1; i++ {
+				reply.AppendArgs(ret[i].Interface())
+			}
+		default:
+			log.Println("unknown method call %v", msg)
+		}
+		if err := s.conn.Send(reply); err != nil {
+			log.Println("could not send reply:", err)
+		}
+	}
+}
+
+func cleanupDBusService(s *DBusService) {
+	s.conn.UnregisterObjectPath(ObjectPath(s.BusPath))
+	close(s.msgChan)
+}

=== added file 'service_test.go'
--- service_test.go	1970-01-01 00:00:00 +0000
+++ service_test.go	2015-01-30 09:31:50 +0000
@@ -0,0 +1,95 @@
+package dbus
+
+import (
+	"fmt"
+
+	. "launchpad.net/gocheck"
+)
+
+const (
+	INTERFACE   = "com.example.Testing"
+	OBJECT_PATH = "/Testing"
+	BUS_NAME    = INTERFACE
+	TEST_SIGNAL    = "TestSignalName"
+)
+
+type TestService struct {
+	TrivialCalled bool
+	service *DBusService
+}
+
+func (m *TestService) Trivial() error {
+	m.TrivialCalled = true
+	return nil
+}
+
+func (m *TestService) ComplexReturn() (map[string]string, error) {
+	ret := make(map[string]string)
+	ret["pi"] = "3.14"
+	return ret, nil
+}
+
+func (m *TestService) WithArgs(v string) (string, error) {
+	return fmt.Sprintf("got: %s", v), nil
+}
+
+func (m *TestService) SendsSignal(v string) (error) {
+	sig := NewSignalMessage(OBJECT_PATH, INTERFACE, TEST_SIGNAL)
+	sig.AppendArgs(v)
+	if err := m.service.Send(sig); err != nil {
+		panic(err)
+	}
+	return nil
+}
+
+
+func (s *S) TestDBusService(c *C) {
+
+	// setUp
+	conn, err := Connect(SessionBus)
+	c.Assert(err, IsNil)
+	c.Assert(conn, NotNil)
+	defer conn.Close()
+
+	impl := new(TestService)
+	ser := NewDBusService(conn, INTERFACE, OBJECT_PATH, BUS_NAME, impl)
+	c.Assert(ser, NotNil)
+	impl.service = ser
+
+	// t1: trivial
+	proxy := conn.Object(BUS_NAME, OBJECT_PATH)
+	c.Assert(proxy, NotNil)
+	_, err = proxy.Call(BUS_NAME, "Trivial")
+	c.Assert(err, IsNil)
+	c.Assert(impl.TrivialCalled, Equals, true)
+
+	// t2: map return
+	msg, err := proxy.Call(BUS_NAME, "ComplexReturn")
+	c.Assert(err, IsNil)
+	var ret map[string]string
+	msg.Args(&ret)
+	c.Assert(ret, DeepEquals, map[string]string{"pi": "3.14"})
+
+	// t3: pass args
+	msg, err = proxy.Call(BUS_NAME, "WithArgs", "meep")
+	c.Assert(err, IsNil)
+	var ret2 string
+	msg.Args(&ret2)
+	c.Assert(ret2, Equals, "got: meep")
+
+	// t4: send signal from method
+	watch, err := conn.WatchSignal(&MatchRule{
+		Type:      TypeSignal,
+		Sender:    BUS_NAME,
+		Interface: INTERFACE,
+		Member:    TEST_SIGNAL})
+	c.Assert(err, IsNil)
+	defer watch.Cancel()
+
+	msg, err = proxy.Call(BUS_NAME, "SendsSignal", "meep")
+	c.Assert(err, IsNil)
+	sigReplyMsg := <- watch.C
+	var sigReply string
+	sigReplyMsg.Args(&sigReply)
+	c.Assert(sigReply, Equals, "meep")
+}