Merge lp:~chipaca/ubuntu-push/networkmanager into lp:ubuntu-push

[John Lenton]

A simplified, testable, Network Manager wrapper

A very small, partial, wrapper around network manager.

[lp:~chipaca/ubuntu-push/networkmanager]

12. By John Lenton on 2014-01-20

Merged simple-bus-interface into networkmanager.

[Samuele Pedroni (pedronis)]

+ return NetworkManager{conn, log}

the struct is big enough that that should return a pointer and the methods be on pointers

218 +func (nm State) String() string {

nm should be state there

the const group ins state, NetworkManager and New need docs

according to coverage this is not hit by tests:

67 + func() { close(ch) })

[lp:~chipaca/ubuntu-push/networkmanager]

13. By John Lenton on 2014-01-20

Merged simple-bus-interface into networkmanager.

14. By John Lenton on 2014-01-20

addressed issues raised by pedronis during peer review

15. By John Lenton on 2014-01-20

Merged simple-bus-interface into networkmanager.

[Samuele Pedroni (pedronis)]

review: Approve

=== modified file 'bus/testing/testing_bus.go'
--- bus/testing/testing_bus.go	2014-01-20 13:45:52 +0000
+++ bus/testing/testing_bus.go	2014-01-20 13:45:52 +0000
@@ -33,13 +33,13 @@
 
 type testingBus struct {
 	TestCond condition.Interface
-	TestEndp *testingEndpoint
+	TestEndp bus.Endpoint
 }
 
 // Build a bus.Bus that takes a condition to determine whether it should work,
 // as well as a condition and series of return values for the testing
 // bus.Endpoint it builds.
-func NewTestingBus(clientTC condition.Interface, busTC condition.Interface, retvals ...interface{}) *testingBus {
+func NewTestingBus(clientTC condition.Interface, busTC condition.Interface, retvals ...interface{}) bus.Bus {
 	return &testingBus{clientTC, NewTestingEndpoint(busTC, retvals...)}
 }
 

=== modified file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	2014-01-20 13:45:52 +0000
+++ bus/testing/testing_endpoint.go	2014-01-20 13:45:52 +0000
@@ -35,7 +35,7 @@
 //
 // NOTE: Call() always returns the first return value; Watch() will provide
 // each of them intern, irrespective of whether Call has been called.
-func NewTestingEndpoint(cond condition.Interface, retvals ...interface{}) *testingEndpoint {
+func NewTestingEndpoint(cond condition.Interface, retvals ...interface{}) bus.Endpoint {
 	return &testingEndpoint{cond, retvals}
 }
 

=== added directory 'networkmanager'
=== added file 'networkmanager/networkmanager.go'
--- networkmanager/networkmanager.go	1970-01-01 00:00:00 +0000
+++ networkmanager/networkmanager.go	2014-01-20 13:45:52 +0000
@@ -0,0 +1,85 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// Package networkmanager wraps a couple of NetworkManager's DBus API points:
+// the org.freedesktop.NetworkManager.state call, and listening for the
+// StateChange signal.
+package networkmanager
+
+import (
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+// NetworkManager lives on a well-knwon bus.Address
+var BusAddress bus.Address = bus.Address{
+	Interface: "org.freedesktop.NetworkManager",
+	Path:      "/org/freedesktop/NetworkManager",
+	Name:      "org.freedesktop.NetworkManager",
+}
+
+/*****************************************************************
+ *    NetworkManager (and its implementation)
+ */
+
+type NetworkManager interface {
+	// GetState fetches and returns NetworkManager's current state
+	GetState() State
+	// WatchState listens for changes to NetworkManager's state, and sends
+	// them out over the channel returned.
+	WatchState() (<-chan State, error)
+}
+
+type networkManager struct {
+	bus bus.Endpoint
+	log logger.Logger
+}
+
+// New returns a new NetworkManager that'll use the provided bus.Endpoint
+func New(endp bus.Endpoint, log logger.Logger) NetworkManager {
+	return &networkManager{endp, log}
+}
+
+var _ NetworkManager = &networkManager{}
+
+/*
+   public methods
+*/
+
+func (nm *networkManager) GetState() State {
+	s, err := nm.bus.Call("state")
+
+	if err != nil {
+		nm.log.Errorf("Failed gettting current state: %s", err)
+		nm.log.Debugf("Defaulting state to Unknown")
+		return Unknown
+	}
+
+	return State(s.(uint32))
+}
+
+func (nm *networkManager) WatchState() (<-chan State, error) {
+	ch := make(chan State)
+	err := nm.bus.WatchSignal("StateChanged",
+		func(n interface{}) { ch <- State(n.(uint32)) },
+		func() { close(ch) })
+	if err != nil {
+		nm.log.Debugf("Failed to set up the watch: %s", err)
+		return nil, err
+	}
+
+	return ch, nil
+}

=== added file 'networkmanager/networkmanager_test.go'
--- networkmanager/networkmanager_test.go	1970-01-01 00:00:00 +0000
+++ networkmanager/networkmanager_test.go	2014-01-20 13:45:52 +0000
@@ -0,0 +1,100 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package networkmanager
+
+import (
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	testingbus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/testing/condition"
+	"testing"
+)
+
+// hook up gocheck
+func Test(t *testing.T) { TestingT(t) }
+
+type NMSuite struct{}
+
+var _ = Suite(&NMSuite{})
+
+var nullog = logger.NewSimpleLogger(ioutil.Discard, "error")
+
+// TestNames checks that networkmanager.State objects serialize
+// correctly, to a point.
+func (s *NMSuite) TestNames(c *C) {
+	var i State
+	for i = 0; i < _max_state; i += 10 {
+		c.Check(names[i], Equals, i.String())
+	}
+	i = _max_state
+	c.Check(i.String(), Equals, "Unknown")
+}
+
+// TestNew doesn't test much at all. If this fails, all is wrong in the world.
+func (s *NMSuite) TestNew(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(condition.Work(true)), nullog)
+	c.Check(nm, NotNil)
+}
+
+// GetState returns the right state when everything works
+func (s *NMSuite) TestGetState(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(condition.Work(true), uint32(ConnectedGlobal)), nullog)
+	state := nm.GetState()
+	c.Check(state, Equals, ConnectedGlobal)
+}
+
+// GetState returns the right state when dbus fails
+func (s *NMSuite) TestGetStateFail(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(condition.Work(false), uint32(ConnectedGlobal)), nullog)
+	state := nm.GetState()
+	c.Check(state, Equals, Unknown)
+}
+
+// GetState returns the right state when dbus works but delivers rubbish
+func (s *NMSuite) TestGetStateRubbish(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(condition.Work(false), 42), nullog)
+	state := nm.GetState()
+	c.Check(state, Equals, Unknown)
+}
+
+// WatchState sends a stream of States over the channel
+func (s *NMSuite) TestWatchState(c *C) {
+	tc := testingbus.NewTestingEndpoint(condition.Work(true), uint32(Unknown), uint32(Asleep), uint32(ConnectedGlobal))
+	nm := New(tc, nullog)
+	ch, err := nm.WatchState()
+	c.Check(err, IsNil)
+	l := []State{<-ch, <-ch, <-ch}
+	c.Check(l, DeepEquals, []State{Unknown, Asleep, ConnectedGlobal})
+}
+
+// WatchState returns on error if the dbus call fails
+func (s *NMSuite) TestWatchStateFails(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(condition.Work(false)), nullog)
+	_, err := nm.WatchState()
+	c.Check(err, NotNil)
+}
+
+// WatchState calls close on its channel when the watch bails
+func (s *NMSuite) TestWatchClosesOnWatchBail(c *C) {
+	tc := testingbus.NewTestingEndpoint(condition.Work(true))
+	nm := New(tc, nullog)
+	ch, err := nm.WatchState()
+	c.Check(err, IsNil)
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}

=== added file 'networkmanager/state.go'
--- networkmanager/state.go	1970-01-01 00:00:00 +0000
+++ networkmanager/state.go	2014-01-20 13:45:52 +0000
@@ -0,0 +1,52 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package networkmanager
+
+type State uint32
+
+// the NetworkManager states, as per
+// https://wiki.gnome.org/Projects/NetworkManager/DBusInterface/LatestDBusAPI
+const (
+	Unknown State = iota * 10
+	Asleep
+	Disconnected
+	Disconnecting
+	Connecting
+	ConnectedLocal
+	ConnectedSite
+	ConnectedGlobal
+	_max_state
+)
+
+var names = map[State]string{
+	Unknown:         "Unknown",
+	Asleep:          "Asleep",
+	Disconnected:    "Disconnected",
+	Disconnecting:   "Disconnecting",
+	Connecting:      "Connecting",
+	ConnectedLocal:  "Connected Local",
+	ConnectedSite:   "Connected Site",
+	ConnectedGlobal: "Connected Global",
+}
+
+// give its state a descriptive stringification
+func (state State) String() string {
+	if s, ok := names[state]; ok {
+		return s
+	}
+	return names[Unknown]
+}