Merge lp:~pedronis/ubuntu-push/flight-mode-n-wireless-tracking into lp:ubuntu-push/automatic

[Samuele Pedroni]

URfkill dbus api to get and warch flight mode state, get and watch WirelessEnabled state from NetworkManager

URfkill dbus api to get and warch flight mode state, get and watch WirelessEnabled state from NetworkManager

[lp:~pedronis/ubuntu-push/flight-mode-n-wireless-tracking]

390. By Samuele Pedroni on 2015-03-30

Merged ubuntu-push into flight-mode-n-wireless-tracking.

[John Lenton (chipaca)]

Good.

Man, we need to change our dbus implementation already.

Thank you for nuking FOO, I always forgot and it's annoying.

review: Approve

=== modified file 'bus/networkmanager/networkmanager.go'
--- bus/networkmanager/networkmanager.go	2015-02-26 19:36:57 +0000
+++ bus/networkmanager/networkmanager.go	2015-03-30 20:47:18 +0000
@@ -1,5 +1,5 @@
 /*
- Copyright 2013-2014 Canonical Ltd.
+ Copyright 2013-2015 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
@@ -14,9 +14,10 @@
  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 wraps a couple of NetworkManager's DBus API
+// points: the org.freedesktop.NetworkManager.state call, and
+// listening for the StateChange signal, similarly for the primary
+// connection and wireless enabled state.
 package networkmanager
 
 import (
@@ -47,8 +48,14 @@
 	// primary connection.
 	GetPrimaryConnection() string
 	// WatchPrimaryConnection listens for changes of NetworkManager's
-	// Primary Connection, and sends it out over the channel returned.
+	// Primary Connection, and sends them out over the channel returned.
 	WatchPrimaryConnection() (<-chan string, bus.Cancellable, error)
+	// GetWirelessEnabled fetches and returns NetworkManager's
+	// wireless state.
+	GetWirelessEnabled() bool
+	// WatchWirelessEnabled listens for changes of NetworkManager's
+	// wireless state, and sends them out over the channel returned.
+	WatchWirelessEnabled() (<-chan bool, bus.Cancellable, error)
 }
 
 type networkManager struct {
@@ -71,7 +78,7 @@
 func (nm *networkManager) GetState() State {
 	s, err := nm.bus.GetProperty("state")
 	if err != nil {
-		nm.log.Errorf("failed gettting current state: %s", err)
+		nm.log.Errorf("failed getting current state: %s", err)
 		nm.log.Debugf("defaulting state to Unknown")
 		return Unknown
 	}
@@ -108,16 +115,16 @@
 }
 
 func (nm *networkManager) GetPrimaryConnection() string {
-	s, err := nm.bus.GetProperty("PrimaryConnection")
+	got, 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")
+		nm.log.Errorf("failed getting current PrimaryConnection: %s", err)
+		nm.log.Debugf("defaulting PrimaryConnection to empty")
 		return ""
 	}
 
-	v, ok := s.(dbus.ObjectPath)
+	v, ok := got.(dbus.ObjectPath)
 	if !ok {
-		nm.log.Errorf("got weird PrimaryConnection: %#v", s)
+		nm.log.Errorf("got weird PrimaryConnection: %#v", got)
 		return ""
 	}
 
@@ -142,7 +149,7 @@
 				nm.log.Errorf("got weird PrimaryConnection via PropertiesChanged: %#v", v)
 				return
 			}
-			nm.log.Debugf("got primary connection: %s", con)
+			nm.log.Debugf("got PrimaryConnection change: %s", con)
 			ch <- string(con)
 		}, func() { close(ch) })
 	if err != nil {
@@ -152,3 +159,49 @@
 
 	return ch, w, nil
 }
+
+func (nm *networkManager) GetWirelessEnabled() bool {
+	got, err := nm.bus.GetProperty("WirelessEnabled")
+	if err != nil {
+		nm.log.Errorf("failed getting WirelessEnabled: %s", err)
+		nm.log.Debugf("defaulting WirelessEnabled to true")
+		return true
+	}
+
+	v, ok := got.(bool)
+	if !ok {
+		nm.log.Errorf("got weird WirelessEnabled: %#v", got)
+		return true
+	}
+
+	return v
+}
+
+func (nm *networkManager) WatchWirelessEnabled() (<-chan bool, bus.Cancellable, error) {
+	ch := make(chan bool)
+	w, err := nm.bus.WatchSignal("PropertiesChanged",
+		func(ppsi ...interface{}) {
+			pps, ok := ppsi[0].(map[string]dbus.Variant)
+			if !ok {
+				nm.log.Errorf("got weird PropertiesChanged: %#v", ppsi[0])
+				return
+			}
+			v, ok := pps["WirelessEnabled"]
+			if !ok {
+				return
+			}
+			en, ok := v.Value.(bool)
+			if !ok {
+				nm.log.Errorf("got weird WirelessEnabled via PropertiesChanged: %#v", v)
+				return
+			}
+			nm.log.Debugf("got WirelessEnabled change: %v", en)
+			ch <- en
+		}, func() { close(ch) })
+	if err != nil {
+		nm.log.Debugf("failed to set up the watch: %s", err)
+		return nil, nil, err
+	}
+
+	return ch, w, nil
+}

=== modified file 'bus/networkmanager/networkmanager_test.go'
--- bus/networkmanager/networkmanager_test.go	2015-02-26 19:36:57 +0000
+++ bus/networkmanager/networkmanager_test.go	2015-03-30 20:47:18 +0000
@@ -1,5 +1,5 @@
 /*
- Copyright 2013-2014 Canonical Ltd.
+ Copyright 2013-2015 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
@@ -232,3 +232,111 @@
 	c.Check(ok, Equals, true)
 	c.Check(v, Equals, "42")
 }
+
+// GetWirelessEnabled returns the right state when everything works
+func (s *NMSuite) TestGetWirelessEnabled(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), false), s.log)
+	en := nm.GetWirelessEnabled()
+	c.Check(en, Equals, false)
+}
+
+// GetWirelessEnabled returns the right state when dbus fails
+func (s *NMSuite) TestGetWirelessEnabledFail(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	en := nm.GetWirelessEnabled()
+	c.Check(en, Equals, true)
+}
+
+// GetWirelessEnabled returns the right state when dbus works but delivers rubbish values
+func (s *NMSuite) TestGetWirelessEnabledRubbishValues(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), "broken"), s.log)
+	en := nm.GetWirelessEnabled()
+	c.Check(en, Equals, true)
+}
+
+// GetWirelessEnabled returns the right state when dbus works but delivers a rubbish structure
+func (s *NMSuite) TestGetWirelessEnabledRubbishStructure(c *C) {
+	nm := New(testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{}), s.log)
+	en := nm.GetWirelessEnabled()
+	c.Check(en, Equals, true)
+}
+
+func mkWirelessEnMap(en bool) map[string]dbus.Variant {
+	m := make(map[string]dbus.Variant)
+	m["WirelessEnabled"] = dbus.Variant{en}
+	return m
+}
+
+// WatchWirelessEnabled sends a stream of wireless enabled states over the channel
+func (s *NMSuite) TestWatchWirelessEnabled(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true),
+		mkWirelessEnMap(true),
+		mkWirelessEnMap(false),
+		mkWirelessEnMap(true),
+	)
+	nm := New(tc, s.log)
+	ch, w, err := nm.WatchWirelessEnabled()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	l := []bool{<-ch, <-ch, <-ch}
+	c.Check(l, DeepEquals, []bool{true, false, true})
+}
+
+// WatchWirelessEnabled returns on error if the dbus call fails
+func (s *NMSuite) TestWatchWirelessEnabledFails(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	_, _, err := nm.WatchWirelessEnabled()
+	c.Check(err, NotNil)
+}
+
+// WatchWirelessEnabled calls close on its channel when the watch bails
+func (s *NMSuite) TestWatchWirelessEnabledClosesOnWatchBail(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true))
+	nm := New(tc, s.log)
+	ch, w, err := nm.WatchWirelessEnabled()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}
+
+// WatchWirelessEnabled survives rubbish values
+func (s *NMSuite) TestWatchWirelessEnabledSurvivesRubbishValues(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), "gorp")
+	nm := New(tc, s.log)
+	ch, w, err := nm.WatchWirelessEnabled()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}
+
+// WatchWirelessEnabled ignores non-WirelessEnabled PropertyChanged
+func (s *NMSuite) TestWatchWirelessEnabledIgnoresIrrelephant(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true),
+		map[string]dbus.Variant{"foo": dbus.Variant{}},
+		map[string]dbus.Variant{"WirelessEnabled": dbus.Variant{true}},
+	)
+	nm := New(tc, s.log)
+	ch, w, err := nm.WatchWirelessEnabled()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	v, ok := <-ch
+	c.Check(ok, Equals, true)
+	c.Check(v, Equals, true)
+}
+
+// WatchWirelessEnabled ignores rubbish WirelessEnabled
+func (s *NMSuite) TestWatchWirelessEnabledIgnoresRubbishValues(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true),
+		map[string]dbus.Variant{"WirelessEnabled": dbus.Variant{-12}},
+		map[string]dbus.Variant{"WirelessEnabled": dbus.Variant{false}},
+	)
+	nm := New(tc, s.log)
+	ch, w, err := nm.WatchWirelessEnabled()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	v, ok := <-ch
+	c.Check(ok, Equals, true)
+	c.Check(v, Equals, false)
+}

=== added directory 'bus/urfkill'
=== added file 'bus/urfkill/urfkill.go'
--- bus/urfkill/urfkill.go	1970-01-01 00:00:00 +0000
+++ bus/urfkill/urfkill.go	2015-03-30 20:47:18 +0000
@@ -0,0 +1,94 @@
+/*
+ Copyright 2015 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 urfkill wraps a couple of URfkill's DBus API points to
+// watch for flight mode state changes.
+package urfkill
+
+import (
+	//"launchpad.net/go-dbus/v1"
+
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+// URfkill lives on a well-knwon bus.Address
+var BusAddress bus.Address = bus.Address{
+	Interface: "org.freedesktop.URfkill",
+	Path:      "/org/freedesktop/URfkill",
+	Name:      "org.freedesktop.URfkill",
+}
+
+/*****************************************************************
+ *    URfkill (and its implementation)
+ */
+
+type URfkill interface {
+	// IsFlightMode returns flight mode state.
+	IsFlightMode() bool
+	// WatchFlightMode listens for changes to URfkill's flight
+	// mode state, and sends them out over the channel returned.
+	WatchFlightMode() (<-chan bool, bus.Cancellable, error)
+}
+
+type uRfkill struct {
+	bus bus.Endpoint
+	log logger.Logger
+}
+
+// New returns a new URfkill that'll use the provided bus.Endpoint
+func New(endp bus.Endpoint, log logger.Logger) URfkill {
+	return &uRfkill{endp, log}
+}
+
+// ensure uRfkill implements URfkill
+var _ URfkill = &uRfkill{}
+
+/*
+   public methods
+*/
+
+func (ur *uRfkill) IsFlightMode() bool {
+	var res bool
+	err := ur.bus.Call("IsFlightMode", bus.Args(), &res)
+	if err != nil {
+		ur.log.Errorf("failed getting flight-mode state: %s", err)
+		ur.log.Debugf("defaulting flight-mode state to false")
+		return false
+	}
+	return res
+}
+
+func (ur *uRfkill) WatchFlightMode() (<-chan bool, bus.Cancellable, error) {
+	ch := make(chan bool)
+	w, err := ur.bus.WatchSignal("FlightModeChanged",
+		func(ns ...interface{}) {
+			stbool, ok := ns[0].(bool)
+			if !ok {
+				ur.log.Errorf("got weird flight-mode state: %#v", ns[0])
+				return
+			}
+			ur.log.Debugf("got flight-mode change: %v", stbool)
+			ch <- stbool
+		},
+		func() { close(ch) })
+	if err != nil {
+		ur.log.Debugf("Failed to set up the watch: %s", err)
+		return nil, nil, err
+	}
+
+	return ch, w, nil
+}

=== added file 'bus/urfkill/urfkill.go_test.go'
--- bus/urfkill/urfkill.go_test.go	1970-01-01 00:00:00 +0000
+++ bus/urfkill/urfkill.go_test.go	2015-03-30 20:47:18 +0000
@@ -0,0 +1,121 @@
+/*
+ Copyright 2015 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 urfkill
+
+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"
+)
+
+// hook up gocheck
+func Test(t *testing.T) { TestingT(t) }
+
+type URSuite struct {
+	log logger.Logger
+}
+
+var _ = Suite(&URSuite{})
+
+func (s *URSuite) SetUpTest(c *C) {
+	s.log = helpers.NewTestLogger(c, "debug")
+}
+
+func (s *URSuite) TestNew(c *C) {
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(true)), s.log)
+	c.Check(ur, NotNil)
+}
+
+// IsFlightMode returns the right state when everything works
+func (s *URSuite) TestIsFlightMode(c *C) {
+	endp := testingbus.NewTestingEndpoint(nil, condition.Work(true), true)
+	ur := New(endp, s.log)
+	state := ur.IsFlightMode()
+	c.Check(state, Equals, true)
+	callArgs := testingbus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Assert(callArgs[0].Member, Equals, "IsFlightMode")
+	c.Assert(callArgs[0].Args, HasLen, 0)
+}
+
+// IsFlightMode returns the right state when dbus fails
+func (s *URSuite) TestIsFlightModeFail(c *C) {
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	state := ur.IsFlightMode()
+	c.Check(state, Equals, false)
+}
+
+// IsFlightMode returns the right state when dbus works but delivers
+// rubbish values
+func (s *URSuite) TestIsFlightModeRubbishValues(c *C) {
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), "broken"), s.log)
+	state := ur.IsFlightMode()
+	c.Check(state, Equals, false)
+}
+
+// IsFlightMode returns the right state when dbus works but delivers a rubbish structure
+func (s *URSuite) TestIsFlightModeRubbishStructure(c *C) {
+	ur := New(testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{}), s.log)
+	state := ur.IsFlightMode()
+	c.Check(state, Equals, false)
+}
+
+// WatchFightMode sends a stream of states over the channel
+func (s *URSuite) TestWatchFlightMode(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), false, true, false)
+	ur := New(tc, s.log)
+	ch, w, err := ur.WatchFlightMode()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	l := []bool{<-ch, <-ch, <-ch}
+	c.Check(l, DeepEquals, []bool{false, true, false})
+}
+
+// WatchFlightMode returns on error if the dbus call fails
+func (s *URSuite) TestWatchFlightModeFails(c *C) {
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	_, _, err := ur.WatchFlightMode()
+	c.Check(err, NotNil)
+}
+
+// WatchFlightMode calls close on its channel when the watch bails
+func (s *URSuite) TestWatchFlightModeClosesOnWatchBail(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true))
+	ur := New(tc, s.log)
+	ch, w, err := ur.WatchFlightMode()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}
+
+// WatchFlightMode survives rubbish values
+func (s *URSuite) TestWatchFlightModeSurvivesRubbishValues(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), "gorp")
+	ur := New(tc, s.log)
+	ch, w, err := ur.WatchFlightMode()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}

=== modified file 'client/client.go'
--- client/client.go	2015-03-30 19:21:49 +0000
+++ client/client.go	2015-03-30 20:47:18 +0000
@@ -287,7 +287,6 @@
 
 // takeTheBus starts the connection(s) to D-Bus and sets up associated event channels
 func (client *PushClient) takeTheBus() error {
-	fmt.Println("FOO")
 	cs := connectivity.New(client.connectivityEndp,
 		client.config.ConnectivityConfig, client.log)
 	go cs.Track(client.connCh)