Merge lp:~chipaca/ubuntu-push/nm-primary-connection into lp:ubuntu-push

[John Lenton]

Add the bits to NetworkManager to track the PrimaryConnection.

Also caught a bug in a test of GetState, and fixed it.

[lp:~chipaca/ubuntu-push/nm-primary-connection]

95. By John Lenton on 2014-03-31

added a couple more tests to WatchPrimaryConnection

96. By John Lenton on 2014-04-01

whoops, test name clash

97. By John Lenton on 2014-04-01

changes *of* PrimaryConnection, not changes *to* it. I think.

Unmerged revisions

=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2014-02-21 16:17:28 +0000
+++ bus/endpoint.go	2014-03-31 17:25:45 +0000
@@ -175,7 +175,11 @@
 
 // unpackOneMsg unpacks the value from the response msg
 func (endp *endpoint) unpackOneMsg(msg *dbus.Message, member string) []interface{} {
-	return msg.AllArgs()
+	var varmap map[string]dbus.Variant
+	if err := msg.Args(&varmap); err != nil {
+		return msg.AllArgs()
+	}
+	return []interface{}{varmap}
 }
 
 // unpackMessages unpacks the value from the watch
 
=== modified file 'bus/networkmanager/networkmanager.go'
--- bus/networkmanager/networkmanager.go	2014-01-21 13:21:19 +0000
+++ bus/networkmanager/networkmanager.go	2014-03-31 17:25:45 +0000
@@ -20,6 +20,8 @@
 package networkmanager
 
 import (
+	"launchpad.net/go-dbus/v1"
+
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/logger"
 )
@@ -41,6 +43,12 @@
 	// WatchState listens for changes to NetworkManager's state, and sends
 	// them out over the channel returned.
 	WatchState() (<-chan State, error)
+	// GetPrimaryConnection fetches and returns NetworkManager's current
+	// primary connection.
+	GetPrimaryConnection() string
+	// WatchPrimaryConnection listens for changes to NetworkManager's
+	// Primary Connection, and sends it out over the channel returned.
+	WatchPrimaryConnection() (<-chan string, error)
 }
 
 type networkManager struct {
@@ -68,7 +76,13 @@
 		return Unknown
 	}
 
-	return State(s.(uint32))
+	v, ok := s.(uint32)
+	if !ok {
+		nm.log.Errorf("Got weird state: %#v", s)
+		return Unknown
+	}
+
+	return State(v)
 }
 
 func (nm *networkManager) WatchState() (<-chan State, error) {
@@ -83,3 +97,38 @@
 
 	return ch, nil
 }
+
+func (nm *networkManager) GetPrimaryConnection() string {
+	s, err := nm.bus.GetProperty("PrimaryConnection")
+	if err != nil {
+		nm.log.Errorf("Failed gettting current primary connection: %s", err)
+		nm.log.Debugf("Defaulting primary connection to empty")
+		return ""
+	}
+
+	v, ok := s.(dbus.ObjectPath)
+	if !ok {
+		nm.log.Errorf("got weird PrimaryConnection: %#v", s)
+		return ""
+	}
+
+	return string(v)
+}
+
+func (nm *networkManager) WatchPrimaryConnection() (<-chan string, error) {
+	ch := make(chan string)
+	err := nm.bus.WatchSignal("PropertiesChanged",
+		func(ppsi ...interface{}) {
+			pps := ppsi[0].(map[string]dbus.Variant)
+			v, ok := pps["PrimaryConnection"]
+			if ok {
+				ch <- string(v.Value.(dbus.ObjectPath))
+			}
+		}, func() { close(ch) })
+	if err != nil {
+		nm.log.Debugf("Failed to set up the watch: %s", err)
+		return nil, err
+	}
+
+	return ch, nil
+}
 
=== modified file 'bus/networkmanager/networkmanager_test.go'
--- bus/networkmanager/networkmanager_test.go	2014-02-05 18:17:26 +0000
+++ bus/networkmanager/networkmanager_test.go	2014-03-31 17:25:45 +0000
@@ -17,12 +17,15 @@
 package networkmanager
 
 import (
+	"testing"
+
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
+
 	testingbus "launchpad.net/ubuntu-push/bus/testing"
 	"launchpad.net/ubuntu-push/logger"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
-	"testing"
 )
 
 // hook up gocheck
@@ -71,7 +74,7 @@
 
 // GetState returns the right state when dbus works but delivers rubbish values
 func (s *NMSuite) TestGetStateRubbishValues(c *C) {
-	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false), 42), s.log)
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), "Unknown"), s.log)
 	state := nm.GetState()
 	c.Check(state, Equals, Unknown)
 }
@@ -109,3 +112,67 @@
 	_, ok := <-ch
 	c.Check(ok, Equals, false)
 }
+
+// GetPrimaryConnection returns the right state when everything works
+func (s *NMSuite) TestGetPrimaryConnection(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), dbus.ObjectPath("/a/1")), s.log)
+	con := nm.GetPrimaryConnection()
+	c.Check(con, Equals, "/a/1")
+}
+
+// GetPrimaryConnection returns the right state when dbus fails
+func (s *NMSuite) TestGetPrimaryConnectionFail(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	con := nm.GetPrimaryConnection()
+	c.Check(con, Equals, "")
+}
+
+// GetPrimaryConnection returns the right state when dbus works but delivers rubbish values
+func (s *NMSuite) TestGetPrimaryConnectionRubbishValues(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), "broken"), s.log)
+	con := nm.GetPrimaryConnection()
+	c.Check(con, Equals, "")
+}
+
+// GetPrimaryConnection returns the right state when dbus works but delivers a rubbish structure
+func (s *NMSuite) TestGetPrimaryConnectionRubbishStructure(c *C) {
+	nm := New(testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{}), s.log)
+	con := nm.GetPrimaryConnection()
+	c.Check(con, Equals, "")
+}
+
+func mkPriConMap(priCon string) map[string]dbus.Variant {
+	m := make(map[string]dbus.Variant)
+	m["PrimaryConnection"] = dbus.Variant{dbus.ObjectPath(priCon)}
+	return m
+}
+
+// WatchPrimaryConnection sends a stream of Connections over the channel
+func (s *NMSuite) TestWatchPrimaryConnection(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true),
+		mkPriConMap("/a/1"),
+		mkPriConMap("/b/2"),
+		mkPriConMap("/c/3"))
+	nm := New(tc, s.log)
+	ch, err := nm.WatchPrimaryConnection()
+	c.Check(err, IsNil)
+	l := []string{<-ch, <-ch, <-ch}
+	c.Check(l, DeepEquals, []string{"/a/1", "/b/2", "/c/3"})
+}
+
+// WatchPrimaryConnection returns on error if the dbus call fails
+func (s *NMSuite) TestWatchPrimaryConnectionFails(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	_, err := nm.WatchPrimaryConnection()
+	c.Check(err, NotNil)
+}
+
+// WatchPrimaryConnection calls close on its channel when the watch bails
+func (s *NMSuite) TestWatchClosesOnWatchBail(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true))
+	nm := New(tc, s.log)
+	ch, err := nm.WatchPrimaryConnection()
+	c.Check(err, IsNil)
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}