Merge lp:~pedronis/ubuntu-push/track-wlan-killstate-instead into lp:ubuntu-push/automatic

[Samuele Pedroni]

switch poller to use killswitch state for WLAN instead of misleading NM property

switch poller to use killswitch state for WLAN instead of misleading NM property

[John Lenton (chipaca)]

LGTM. Haven't tested it on a phone though. Question inline, but code is good.

review: Approve

[Bret Barker (noise)]

Tests OK on my krillin.

[Ricardo Salveti (rsalveti)]

Looks good, tested with mako, krillin and arale. Please also create an MR for the RTM branch, as we re planning on landing this as a hotfix as well.

Thanks

review: Approve

=== modified file 'bus/connectivity/connectivity_test.go'
--- bus/connectivity/connectivity_test.go	2015-03-02 16:45:30 +0000
+++ bus/connectivity/connectivity_test.go	2015-04-29 15:34:41 +0000
@@ -196,6 +196,10 @@
 	return nil, nil
 }
 
+func (rep *racyEndpoint) WatchProperties(f func(map[string]dbus.Variant, []string), d func()) (bus.Cancellable, error) {
+	return nil, nil
+}
+
 func (*racyEndpoint) Close()                                                        {}
 func (*racyEndpoint) Dial() error                                                   { return nil }
 func (*racyEndpoint) String() string                                                { return "racyEndpoint" }

=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2015-02-26 19:36:57 +0000
+++ bus/endpoint.go	2015-04-29 15:34:41 +0000
@@ -49,6 +49,7 @@
 	Call(member string, args []interface{}, rvs ...interface{}) error
 	GetProperty(property string) (interface{}, error)
 	SetProperty(property string, suffix string, value interface{}) error
+	WatchProperties(f func(map[string]dbus.Variant, []string), d func()) (Cancellable, error)
 	Dial() error
 	Close()
 	String() string
@@ -195,6 +196,48 @@
 	return err
 }
 
+// WatchProperties() sets up a watch for
+// org.freedesktop.DBus.Properties PropertiesChanged signal for the
+// path and interface provided when creating the endpoint, and then
+// calls f() with the unpacked value. If it's unable to set up the
+// watch it returns an error. If the watch fails once established, d()
+// is called. Typically f() sends the values over a channel, and d()
+// would close the channel.
+//
+// XXX: untested
+func (endp *endpoint) WatchProperties(f func(map[string]dbus.Variant, []string), d func()) (Cancellable, error) {
+	watch, err := endp.proxy.WatchSignal("org.freedesktop.DBus.Properties", "PropertiesChanged")
+	if err != nil {
+		endp.log.Debugf("failed to set up the watch: %s", err)
+		return nil, err
+	}
+
+	go func() {
+		for {
+			msg, ok := <-watch.C
+			if !ok {
+				break
+			}
+			var intfName string
+			var changed map[string]dbus.Variant
+			var invalidated []string
+			if err := msg.Args(&intfName, &changed, &invalidated); err != nil {
+				endp.log.Errorf("unexpected values from Properties watch")
+				break
+			}
+			if intfName != endp.addr.Interface {
+				// ignore
+				continue
+			}
+			f(changed, invalidated)
+		}
+		endp.log.Debugf("got not-OK from Properties watch")
+		d()
+	}()
+
+	return watch, nil
+}
+
 // Close the connection to dbus.
 //
 // XXX: untested

=== modified file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	2015-02-26 19:36:57 +0000
+++ bus/testing/testing_endpoint.go	2015-04-29 15:34:41 +0000
@@ -154,6 +154,16 @@
 	}
 }
 
+// See Endpoint's WatchProperties.
+func (tc *testingEndpoint) WatchProperties(f func(map[string]dbus.Variant, []string), d func()) (bus.Cancellable, error) {
+	translate := func(vals ...interface{}) {
+		changed := vals[0].(map[string]dbus.Variant)
+		invalidated := vals[1].([]string)
+		f(changed, invalidated)
+	}
+	return tc.WatchSignal("PropertiesChanged", translate, d)
+}
+
 // See Endpoint's Call. This Call will check its condition to decide whether
 // to return an error, or the first of its return values
 func (tc *testingEndpoint) Call(member string, args []interface{}, rvs ...interface{}) error {

=== modified file 'bus/testing/testing_endpoint_test.go'
--- bus/testing/testing_endpoint_test.go	2015-02-26 19:36:57 +0000
+++ bus/testing/testing_endpoint_test.go	2015-04-29 15:34:41 +0000
@@ -20,6 +20,7 @@
 	"testing"
 	"time"
 
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
 
 	"launchpad.net/ubuntu-push/bus"
@@ -203,6 +204,24 @@
 	c.Check(e, NotNil)
 }
 
+// Test that WatchProperties() with a positive condition sends the
+// provided return values over the channel.
+func (s *TestingEndpointSuite) TestWatchProperties(c *C) {
+	var m, n int32 = 42, 17
+	endp := NewMultiValuedTestingEndpoint(nil, condition.Work(true),
+		[]interface{}{map[string]dbus.Variant{"s": dbus.Variant{m}}, []string{}},
+		[]interface{}{map[string]dbus.Variant{"s": dbus.Variant{n}}, []string{}},
+	)
+	ch := make(chan int32)
+	w, e := endp.WatchProperties(func(changed map[string]dbus.Variant, nvalited []string) {
+		ch <- changed["s"].Value.(int32)
+	}, func() { close(ch) })
+	c.Assert(e, IsNil)
+	defer w.Cancel()
+	c.Check(<-ch, Equals, m)
+	c.Check(<-ch, Equals, n)
+}
+
 // Test Dial() with a non-working bus fails
 func (s *TestingBusSuite) TestDialNoWork(c *C) {
 	endp := NewTestingEndpoint(condition.Work(false), nil)

=== modified file 'bus/urfkill/urfkill.go'
--- bus/urfkill/urfkill.go	2015-03-30 12:05:10 +0000
+++ bus/urfkill/urfkill.go	2015-04-29 15:34:41 +0000
@@ -19,7 +19,7 @@
 package urfkill
 
 import (
-	//"launchpad.net/go-dbus/v1"
+	"launchpad.net/go-dbus/v1"
 
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/logger"
@@ -32,26 +32,49 @@
 	Name:      "org.freedesktop.URfkill",
 }
 
+// URfkill lives on a well-knwon bus.Address
+var WLANKillswitchBusAddress bus.Address = bus.Address{
+	Interface: "org.freedesktop.URfkill.Killswitch",
+	Path:      "/org/freedesktop/URfkill/WLAN",
+	Name:      "org.freedesktop.URfkill",
+}
+
 /*****************************************************************
  *    URfkill (and its implementation)
  */
 
+type KillswitchState int32
+
+const (
+	KillswitchStateUnblocked   KillswitchState = 0
+	KillswitchStateSoftBlocked KillswitchState = 1
+	KillswitchStateHardBlocked KillswitchState = 2
+)
+
 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)
+	// GetWLANKillswitchState fetches and returns URfkill's
+	// WLAN killswitch state.
+	GetWLANKillswitchState() KillswitchState
+	// WatchWLANKillswitchState listens for changes of URfkill's
+	// WLAN killswtich state, and sends them out over the channel returned.
+	WatchWLANKillswitchState() (<-chan KillswitchState, bus.Cancellable, error)
 }
 
 type uRfkill struct {
-	bus bus.Endpoint
-	log logger.Logger
+	bus            bus.Endpoint
+	wlanKillswitch 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}
+// New returns a new URfkill that'll use the provided bus.Endpoints
+// for BusAddress and WLANKillswitchBusAddress
+func New(endp bus.Endpoint, wlanKillswitch bus.Endpoint, log logger.Logger) URfkill {
+	return &uRfkill{endp, wlanKillswitch, log}
 }
 
 // ensure uRfkill implements URfkill
@@ -92,3 +115,44 @@
 
 	return ch, w, nil
 }
+
+func (ur *uRfkill) GetWLANKillswitchState() KillswitchState {
+	got, err := ur.wlanKillswitch.GetProperty("state")
+	if err != nil {
+		ur.log.Errorf("failed getting WLANKillswitchState: %s", err)
+		ur.log.Debugf("defaulting WLANKillswitchState to true")
+		return KillswitchStateUnblocked
+	}
+
+	v, ok := got.(int32)
+	if !ok {
+		ur.log.Errorf("got weird WLANKillswitchState: %#v", got)
+		return KillswitchStateUnblocked
+	}
+
+	return KillswitchState(v)
+}
+
+func (ur *uRfkill) WatchWLANKillswitchState() (<-chan KillswitchState, bus.Cancellable, error) {
+	ch := make(chan KillswitchState)
+	w, err := ur.wlanKillswitch.WatchProperties(
+		func(changed map[string]dbus.Variant, invalidated []string) {
+			v, ok := changed["state"]
+			if !ok {
+				return
+			}
+			st, ok := v.Value.(int32)
+			if !ok {
+				ur.log.Errorf("got weird WLANKillswitchState via PropertiesChanged: %#v", v)
+				return
+			}
+			ur.log.Debugf("got WLANKillswitchState change: %v", st)
+			ch <- KillswitchState(st)
+		}, 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
+}

=== renamed file 'bus/urfkill/urfkill.go_test.go' => 'bus/urfkill/urfkill_test.go'
--- bus/urfkill/urfkill.go_test.go	2015-03-30 12:05:10 +0000
+++ bus/urfkill/urfkill_test.go	2015-04-29 15:34:41 +0000
@@ -19,7 +19,7 @@
 import (
 	"testing"
 
-	//"launchpad.net/go-dbus/v1"
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
 
 	testingbus "launchpad.net/ubuntu-push/bus/testing"
@@ -42,14 +42,14 @@
 }
 
 func (s *URSuite) TestNew(c *C) {
-	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(true)), s.log)
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(true)), nil, 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)
+	ur := New(endp, nil, s.log)
 	state := ur.IsFlightMode()
 	c.Check(state, Equals, true)
 	callArgs := testingbus.GetCallArgs(endp)
@@ -60,7 +60,7 @@
 
 // IsFlightMode returns the right state when dbus fails
 func (s *URSuite) TestIsFlightModeFail(c *C) {
-	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), nil, s.log)
 	state := ur.IsFlightMode()
 	c.Check(state, Equals, false)
 }
@@ -68,14 +68,14 @@
 // 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)
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), "broken"), nil, 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)
+	ur := New(testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{}), nil, s.log)
 	state := ur.IsFlightMode()
 	c.Check(state, Equals, false)
 }
@@ -83,7 +83,7 @@
 // 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)
+	ur := New(tc, nil, s.log)
 	ch, w, err := ur.WatchFlightMode()
 	c.Assert(err, IsNil)
 	defer w.Cancel()
@@ -93,7 +93,7 @@
 
 // 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)
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), nil, s.log)
 	_, _, err := ur.WatchFlightMode()
 	c.Check(err, NotNil)
 }
@@ -101,7 +101,7 @@
 // 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)
+	ur := New(tc, nil, s.log)
 	ch, w, err := ur.WatchFlightMode()
 	c.Assert(err, IsNil)
 	defer w.Cancel()
@@ -112,10 +112,107 @@
 // WatchFlightMode survives rubbish values
 func (s *URSuite) TestWatchFlightModeSurvivesRubbishValues(c *C) {
 	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), "gorp")
-	ur := New(tc, s.log)
+	ur := New(tc, nil, s.log)
 	ch, w, err := ur.WatchFlightMode()
 	c.Assert(err, IsNil)
 	defer w.Cancel()
 	_, ok := <-ch
 	c.Check(ok, Equals, false)
 }
+
+// GetWLANKillState returns the right state when everything works
+func (s *URSuite) TestGetWLANKillState(c *C) {
+	ur := New(nil, testingbus.NewTestingEndpoint(nil, condition.Work(true), KillswitchStateSoftBlocked), s.log)
+	st := ur.GetWLANKillswitchState()
+	c.Check(st, Equals, KillswitchStateSoftBlocked)
+}
+
+// GetWLANKillswitchState returns the right state when dbus fails
+func (s *URSuite) TestGetWLANKillswitchStateFail(c *C) {
+	ur := New(nil, testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	st := ur.GetWLANKillswitchState()
+	c.Check(st, Equals, KillswitchStateUnblocked)
+}
+
+// GetWLANKillswitchState returns the right state when dbus works but delivers rubbish values
+func (s *URSuite) TestGetWLANKillswitchStateRubbishValues(c *C) {
+	ur := New(nil, testingbus.NewTestingEndpoint(nil, condition.Work(true), "broken"), s.log)
+	st := ur.GetWLANKillswitchState()
+	c.Check(st, Equals, KillswitchStateUnblocked)
+}
+
+// GetWLANKillswitchState returns the right state when dbus works but delivers a rubbish structure
+func (s *URSuite) TestGetWLANKillswitchStateRubbishStructure(c *C) {
+	ur := New(nil, testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{}), s.log)
+	st := ur.GetWLANKillswitchState()
+	c.Check(st, Equals, KillswitchStateUnblocked)
+}
+
+func mkWLANKillswitchStateMap(st KillswitchState) map[string]dbus.Variant {
+	m := make(map[string]dbus.Variant)
+	m["state"] = dbus.Variant{int32(st)}
+	return m
+}
+
+// WatchWLANKillswitchState sends a stream of WLAN killswitch states over the channel
+func (s *URSuite) TestWatchWLANKillswitchState(c *C) {
+	tc := testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true),
+		[]interface{}{mkWLANKillswitchStateMap(KillswitchStateUnblocked), []string{}},
+		[]interface{}{mkWLANKillswitchStateMap(KillswitchStateHardBlocked), []string{}},
+		[]interface{}{mkWLANKillswitchStateMap(KillswitchStateUnblocked), []string{}},
+	)
+	ur := New(nil, tc, s.log)
+	ch, w, err := ur.WatchWLANKillswitchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	l := []KillswitchState{<-ch, <-ch, <-ch}
+	c.Check(l, DeepEquals, []KillswitchState{KillswitchStateUnblocked, KillswitchStateHardBlocked, KillswitchStateUnblocked})
+}
+
+// WatchWLANKillswitchState returns on error if the dbus call fails
+func (s *URSuite) TestWatchWLANKillswitchStateFails(c *C) {
+	ur := New(nil, testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	_, _, err := ur.WatchWLANKillswitchState()
+	c.Check(err, NotNil)
+}
+
+// WatchWLANKillswitchState calls close on its channel when the watch bails
+func (s *URSuite) TestWatchWLANKillswitchStateClosesOnWatchBail(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true))
+	ur := New(nil, tc, s.log)
+	ch, w, err := ur.WatchWLANKillswitchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}
+
+// WatchWLANKillswitchState ignores non-WLAN-killswitch PropertiesChanged
+func (s *URSuite) TestWatchWLANKillswitchStateIgnoresIrrelevant(c *C) {
+	tc := testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true),
+		[]interface{}{map[string]dbus.Variant{"foo": dbus.Variant{}}, []string{}},
+		[]interface{}{mkWLANKillswitchStateMap(KillswitchStateUnblocked), []string{}},
+	)
+	ur := New(nil, tc, s.log)
+	ch, w, err := ur.WatchWLANKillswitchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	v, ok := <-ch
+	c.Check(ok, Equals, true)
+	c.Check(v, Equals, KillswitchStateUnblocked)
+}
+
+// WatchWLANKillswitchState ignores rubbish WLAN killswitch state
+func (s *URSuite) TestWatchWLANKillswitchStateIgnoresRubbishValues(c *C) {
+	tc := testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true),
+		[]interface{}{map[string]dbus.Variant{"state": dbus.Variant{-12}}, []string{}},
+		[]interface{}{mkWLANKillswitchStateMap(KillswitchStateSoftBlocked), []string{}},
+	)
+	ur := New(nil, tc, s.log)
+	ch, w, err := ur.WatchWLANKillswitchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	v, ok := <-ch
+	c.Check(ok, Equals, true)
+	c.Check(v, Equals, KillswitchStateSoftBlocked)
+}

=== modified file 'poller/poller.go'
--- poller/poller.go	2015-03-30 20:48:00 +0000
+++ poller/poller.go	2015-04-29 15:34:41 +0000
@@ -25,7 +25,6 @@
 	"time"
 
 	"launchpad.net/ubuntu-push/bus"
-	"launchpad.net/ubuntu-push/bus/networkmanager"
 	"launchpad.net/ubuntu-push/bus/polld"
 	"launchpad.net/ubuntu-push/bus/powerd"
 	"launchpad.net/ubuntu-push/bus/urfkill"
@@ -68,7 +67,6 @@
 type poller struct {
 	times                Times
 	log                  logger.Logger
-	nm                   networkmanager.NetworkManager
 	powerd               powerd.Powerd
 	polld                polld.Polld
 	urfkill              urfkill.URfkill
@@ -103,18 +101,13 @@
 	if p.powerd != nil || p.polld != nil {
 		return ErrAlreadyStarted
 	}
-	nmEndp := bus.SystemBus.Endpoint(networkmanager.BusAddress, p.log)
 	powerdEndp := bus.SystemBus.Endpoint(powerd.BusAddress, p.log)
 	polldEndp := bus.SessionBus.Endpoint(polld.BusAddress, p.log)
 	urEndp := bus.SystemBus.Endpoint(urfkill.BusAddress, p.log)
+	urWLANKillswitchEndp := bus.SystemBus.Endpoint(urfkill.WLANKillswitchBusAddress, p.log)
 	var wg sync.WaitGroup
 	wg.Add(4)
 	go func() {
-		n := util.NewAutoRedialer(nmEndp).Redial()
-		p.log.Debugf("NetworkManager dialed on try %d", n)
-		wg.Done()
-	}()
-	go func() {
 		n := util.NewAutoRedialer(powerdEndp).Redial()
 		p.log.Debugf("powerd dialed on try %d", n)
 		wg.Done()
@@ -129,12 +122,16 @@
 		p.log.Debugf("URfkill dialed on try %d", n)
 		wg.Done()
 	}()
+	go func() {
+		n := util.NewAutoRedialer(urWLANKillswitchEndp).Redial()
+		p.log.Debugf("URfkill (WLAN killswitch) dialed on try %d", n)
+		wg.Done()
+	}()
 	wg.Wait()
 
-	p.nm = networkmanager.New(nmEndp, p.log)
 	p.powerd = powerd.New(powerdEndp, p.log)
 	p.polld = polld.New(polldEndp, p.log)
-	p.urfkill = urfkill.New(urEndp, p.log)
+	p.urfkill = urfkill.New(urEndp, urWLANKillswitchEndp, p.log)
 
 	// busy sleep loop to workaround go's timer/sleep
 	// not accounting for time when the system is suspended
@@ -157,7 +154,7 @@
 	if p.log == nil {
 		return ErrUnconfigured
 	}
-	if p.nm == nil || p.powerd == nil || p.polld == nil || p.urfkill == nil {
+	if p.powerd == nil || p.polld == nil || p.urfkill == nil {
 		return ErrNotStarted
 	}
 	wakeupCh, err := p.powerd.WatchWakeups()
@@ -169,18 +166,18 @@
 		return err
 	}
 	flightMode := p.urfkill.IsFlightMode()
-	wirelessEnabled := p.nm.GetWirelessEnabled()
+	wlanKillswitchState := p.urfkill.GetWLANKillswitchState()
 	flightModeCh, _, err := p.urfkill.WatchFlightMode()
 	if err != nil {
 		return err
 	}
-	wirelessEnabledCh, _, err := p.nm.WatchWirelessEnabled()
+	wlanKillswitchStateCh, _, err := p.urfkill.WatchWLANKillswitchState()
 	if err != nil {
 		return err
 	}
 
 	filteredWakeUpCh := make(chan bool)
-	go p.control(wakeupCh, filteredWakeUpCh, flightMode, flightModeCh, wirelessEnabled, wirelessEnabledCh)
+	go p.control(wakeupCh, filteredWakeUpCh, flightMode, flightModeCh, wlanKillswitchState, wlanKillswitchStateCh)
 	go p.run(filteredWakeUpCh, doneCh)
 	return nil
 }
@@ -198,7 +195,8 @@
 	return t, cookie, err
 }
 
-func (p *poller) control(wakeupCh <-chan bool, filteredWakeUpCh chan<- bool, flightMode bool, flightModeCh <-chan bool, wirelessEnabled bool, wirelessEnabledCh <-chan bool) {
+func (p *poller) control(wakeupCh <-chan bool, filteredWakeUpCh chan<- bool, flightMode bool, flightModeCh <-chan bool, wlanKillswitchState urfkill.KillswitchState, wlanKillswitchStateCh <-chan urfkill.KillswitchState) {
+	wirelessEnabled := wlanKillswitchState == urfkill.KillswitchStateUnblocked
 	dontPoll := flightMode && !wirelessEnabled
 	var t time.Time
 	cookie := ""
@@ -237,7 +235,8 @@
 				}
 			}
 		case flightMode = <-flightModeCh:
-		case wirelessEnabled = <-wirelessEnabledCh:
+		case wlanKillswitchState = <-wlanKillswitchStateCh:
+			wirelessEnabled = wlanKillswitchState == urfkill.KillswitchStateUnblocked
 		}
 		newDontPoll := flightMode && !wirelessEnabled
 		p.log.Debugf("control: flightMode:%v wirelessEnabled:%v prevDontPoll:%v dontPoll:%v wakeupReq:%v holdsWakeLock:%v", flightMode, wirelessEnabled, dontPoll, newDontPoll, !t.IsZero(), holdsWakeLock)

=== modified file 'poller/poller_test.go'
--- poller/poller_test.go	2015-03-30 15:59:19 +0000
+++ poller/poller_test.go	2015-04-29 15:34:41 +0000
@@ -21,6 +21,7 @@
 
 	. "launchpad.net/gocheck"
 
+	"launchpad.net/ubuntu-push/bus/urfkill"
 	"launchpad.net/ubuntu-push/client/session"
 	helpers "launchpad.net/ubuntu-push/testing"
 )
@@ -90,6 +91,11 @@
 	s.myd = &myD{}
 }
 
+const (
+	wlanOn  = urfkill.KillswitchStateUnblocked
+	wlanOff = urfkill.KillswitchStateSoftBlocked
+)
+
 func (s *PrSuite) TestStep(c *C) {
 	p := &poller{
 		times:                Times{},
@@ -111,7 +117,7 @@
 	ch := make(chan string)
 	// now, run
 	filteredWakeUpCh := make(chan bool)
-	go p.control(wakeupCh, filteredWakeUpCh, false, nil, true, nil)
+	go p.control(wakeupCh, filteredWakeUpCh, false, nil, wlanOn, nil)
 	go func() { ch <- p.step(filteredWakeUpCh, doneCh, "old cookie") }()
 	select {
 	case s := <-ch:
@@ -138,8 +144,8 @@
 	filteredWakeUpCh := make(chan bool)
 	s.myd.watchWakeCh = make(chan bool, 1)
 	flightModeCh := make(chan bool)
-	wirelessModeCh := make(chan bool)
-	go p.control(wakeUpCh, filteredWakeUpCh, false, flightModeCh, true, wirelessModeCh)
+	wlanKillswitchStateCh := make(chan urfkill.KillswitchState)
+	go p.control(wakeUpCh, filteredWakeUpCh, false, flightModeCh, wlanOn, wlanKillswitchStateCh)
 
 	// works
 	err := p.requestWakeup()
@@ -157,17 +163,17 @@
 
 	// flight mode
 	flightModeCh <- true
-	wirelessModeCh <- false
+	wlanKillswitchStateCh <- wlanOff
 	err = p.requestWakeup()
 	c.Assert(err, IsNil)
 	c.Check(s.myd.watchWakeCh, HasLen, 0)
 
 	// wireless on
-	wirelessModeCh <- true
+	wlanKillswitchStateCh <- wlanOn
 	c.Check(<-s.myd.watchWakeCh, Equals, true)
 
 	// wireless off
-	wirelessModeCh <- false
+	wlanKillswitchStateCh <- wlanOff
 	// pending wakeup was cleared
 	c.Check(<-s.myd.watchWakeCh, Equals, false)