Merge lp:~chipaca/ubuntu-push/merge-automatic into lp:ubuntu-push

[John Lenton]

The individual branches that compose this merge were peer-reviewed separately, as indicated in the commit logs.

[John Lenton (chipaca)]

review: Approve

=== added directory 'bus/accounts'
=== added file 'bus/accounts/accounts.go'
--- bus/accounts/accounts.go	1970-01-01 00:00:00 +0000
+++ bus/accounts/accounts.go	2015-03-06 13:26:11 +0000
@@ -0,0 +1,310 @@
+/*
+ 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
+ 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/>.
+*/
+// accounts exposes some properties that're stored in org.freedesktop.Accounts
+// (specifically, the ones that we need are all under
+// com.ubuntu.touch.AccountsService.Sound).
+package accounts
+
+import (
+	"fmt"
+	"os/user"
+	"strings"
+	"sync"
+
+	"launchpad.net/go-dbus/v1"
+	"launchpad.net/go-xdg/v0"
+
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+// accounts lives on a well-known bus.Address.
+//
+// Note this one isn't it: the interface is for dbus.properties, and the path
+// is missing the UID.
+var BusAddress bus.Address = bus.Address{
+	Interface: "org.freedesktop.DBus.Properties",
+	Path:      "/org/freedesktop/Accounts/User",
+	Name:      "org.freedesktop.Accounts",
+}
+
+const accountsSoundIface = "com.ubuntu.touch.AccountsService.Sound"
+
+type Accounts interface {
+	// Start() sets up the asynchronous updating of properties, and does the first update.
+	Start() error
+	// Cancel() stops the asynchronous updating of properties.
+	Cancel() error
+	// SilentMode() tells you whether the device is in silent mode.
+	SilentMode() bool
+	// Vibrate() tells you whether the device is allowed to vibrate.
+	Vibrate() bool
+	// MessageSoundFile() tells you the default sound filename.
+	MessageSoundFile() string
+	String() string
+}
+
+// Accounts tracks the relevant bits of configuration. Nothing directly
+// accessible because it is updated asynchronously, so use the accessors.
+type accounts struct {
+	endp              bus.Endpoint
+	log               logger.Logger
+	silent            bool
+	vibrate           bool
+	vibrateSilentMode bool
+	messageSound      string
+	cancellable       bus.Cancellable
+	lck               sync.Mutex
+	updaters          map[string]func(dbus.Variant)
+}
+
+// sets up a new Accounts structure, ready to be Start()ed.
+func New(endp bus.Endpoint, log logger.Logger) Accounts {
+	a := &accounts{
+		endp: endp,
+		log:  log,
+	}
+
+	a.updaters = map[string]func(dbus.Variant){
+		"SilentMode":                       a.updateSilentMode,
+		"IncomingMessageVibrate":           a.updateVibrate,
+		"IncomingMessageVibrateSilentMode": a.updateVibrateSilentMode,
+		"IncomingMessageSound":             a.updateMessageSound,
+	}
+
+	return a
+}
+
+// sets up the asynchronous updating of properties, and does the first update.
+func (a *accounts) Start() error {
+	err := a.startWatch()
+	if err != nil {
+		return err
+	}
+	a.update()
+	return nil
+}
+
+// does sets up the watch on the PropertiesChanged signal. Separate from Start
+// because it holds a lock.
+func (a *accounts) startWatch() error {
+	cancellable, err := a.endp.WatchSignal("PropertiesChanged", a.propsHandler, a.bailoutHandler)
+	if err != nil {
+		a.log.Errorf("unable to watch for property changes: %v", err)
+		return err
+	}
+
+	a.lck.Lock()
+	defer a.lck.Unlock()
+	if a.cancellable != nil {
+		panic("tried to start Accounts twice?")
+	}
+	a.cancellable = cancellable
+
+	return nil
+}
+
+// cancel the asynchronous updating of properties.
+func (a *accounts) Cancel() error {
+	return a.cancellable.Cancel()
+}
+
+// slightly shorter than %#v
+func (a *accounts) String() string {
+	return fmt.Sprintf("&accounts{silent: %t, vibrate: %t, vibratesilent: %t, messageSound: %q}",
+		a.silent, a.vibrate, a.vibrateSilentMode, a.messageSound)
+}
+
+// merely log that the watch loop has bailed; not much we can do.
+func (a *accounts) bailoutHandler() {
+	a.log.Debugf("loop bailed out")
+}
+
+// handle PropertiesChanged, which is described in
+// http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties
+func (a *accounts) propsHandler(ns ...interface{}) {
+	if len(ns) != 3 {
+		a.log.Errorf("PropertiesChanged delivered %d things instead of 3.", len(ns))
+		return
+	}
+
+	iface, ok := ns[0].(string)
+	if !ok {
+		a.log.Errorf("PropertiesChanged 1st param not a string: %#v.", ns[0])
+		return
+	}
+	if iface != accountsSoundIface {
+		a.log.Debugf("PropertiesChanged for %#v, ignoring.", iface)
+		return
+	}
+	changed, ok := ns[1].(map[interface{}]interface{})
+	if !ok {
+		a.log.Errorf("PropertiesChanged 2nd param not a map: %#v.", ns[1])
+		return
+	}
+	if len(changed) != 0 {
+		// not seen in the wild, but easy to implement properly (ie
+		// using the values we're given) if it starts to
+		// happen. Meanwhile just do a full update.
+		a.log.Infof("PropertiesChanged provided 'changed'; reverting to full update.")
+		a.update()
+		return
+	}
+	invalid, ok := ns[2].([]interface{})
+	if !ok {
+		a.log.Errorf("PropertiesChanged 3rd param not a list of properties: %#v.", ns[2])
+		return
+	}
+	a.log.Debugf("props changed: %#v.", invalid)
+	switch len(invalid) {
+	case 0:
+		// nothing to do?
+		a.log.Debugf("PropertiesChanged 3rd param is empty; doing nothing.")
+	case 1:
+		// the common case right now
+		k, ok := invalid[0].(string)
+		if !ok {
+			a.log.Errorf("PropertiesChanged 3rd param's only entry not a string: %#v.", invalid[0])
+			return
+		}
+		updater, ok := a.updaters[k]
+		if ok {
+			var v dbus.Variant
+			err := a.endp.Call("Get", []interface{}{accountsSoundIface, k}, &v)
+			if err != nil {
+				a.log.Errorf("when calling Get for %s: %v", k, err)
+				return
+			}
+			a.log.Debugf("Get for %s got %#v.", k, v)
+			// updaters must be called with the lock held
+			a.lck.Lock()
+			defer a.lck.Unlock()
+			updater(v)
+			a.log.Debugf("updated %s.", k)
+		}
+	default:
+		// not seen in the wild, but we probably want to drop to a
+		// full update if getting more than one change anyway.
+		a.log.Infof("PropertiesChanged provided more than one 'invalid'; reverting to full update.")
+		a.update()
+	}
+}
+
+func (a *accounts) updateSilentMode(vsilent dbus.Variant) {
+	silent, ok := vsilent.Value.(bool)
+	if !ok {
+		a.log.Errorf("SilentMode needed a bool.")
+		return
+	}
+
+	a.silent = silent
+}
+
+func (a *accounts) updateVibrate(vvibrate dbus.Variant) {
+	vibrate, ok := vvibrate.Value.(bool)
+	if !ok {
+		a.log.Errorf("IncomingMessageVibrate needed a bool.")
+		return
+	}
+
+	a.vibrate = vibrate
+}
+
+func (a *accounts) updateVibrateSilentMode(vvibrateSilentMode dbus.Variant) {
+	vibrateSilentMode, ok := vvibrateSilentMode.Value.(bool)
+	if !ok {
+		a.log.Errorf("IncomingMessageVibrateSilentMode needed a bool.")
+		return
+	}
+
+	a.vibrateSilentMode = vibrateSilentMode
+}
+
+func (a *accounts) updateMessageSound(vsnd dbus.Variant) {
+	snd, ok := vsnd.Value.(string)
+	if !ok {
+		a.log.Errorf("IncomingMessageSound needed a string.")
+		return
+	}
+
+	for _, dir := range xdg.Data.Dirs()[1:] {
+		if dir[len(dir)-1] != '/' {
+			dir += "/"
+		}
+		if strings.HasPrefix(snd, dir) {
+			snd = snd[len(dir):]
+			break
+		}
+	}
+
+	a.messageSound = snd
+}
+
+func (a *accounts) update() {
+	props := make(map[string]dbus.Variant)
+	err := a.endp.Call("GetAll", []interface{}{accountsSoundIface}, &props)
+	if err != nil {
+		a.log.Errorf("when calling GetAll: %v", err)
+		return
+	}
+	a.log.Debugf("GetAll got: %#v", props)
+
+	a.lck.Lock()
+	defer a.lck.Unlock()
+
+	for name, updater := range a.updaters {
+		updater(props[name])
+	}
+}
+
+// is the device in silent mode?
+func (a *accounts) SilentMode() bool {
+	a.lck.Lock()
+	defer a.lck.Unlock()
+
+	return a.silent
+}
+
+// should notifications vibrate?
+func (a *accounts) Vibrate() bool {
+	a.lck.Lock()
+	defer a.lck.Unlock()
+
+	if a.silent {
+		return a.vibrateSilentMode
+	} else {
+		return a.vibrate
+	}
+}
+
+// what is the default sound file?
+func (a *accounts) MessageSoundFile() string {
+	a.lck.Lock()
+	defer a.lck.Unlock()
+
+	return a.messageSound
+}
+
+// the BusAddress should actually end with the UID of the user in question;
+// here we do what's needed to get that.
+func init() {
+	u, err := user.Current()
+	if err != nil {
+		panic(err)
+	}
+
+	BusAddress.Path += u.Uid
+}

=== added file 'bus/accounts/accounts_test.go'
--- bus/accounts/accounts_test.go	1970-01-01 00:00:00 +0000
+++ bus/accounts/accounts_test.go	2015-03-06 13:26:11 +0000
@@ -0,0 +1,271 @@
+/*
+ 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
+ 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 accounts
+
+import (
+	"errors"
+	"testing"
+
+	"launchpad.net/go-dbus/v1"
+	. "launchpad.net/gocheck"
+
+	testibus "launchpad.net/ubuntu-push/bus/testing"
+	helpers "launchpad.net/ubuntu-push/testing"
+	"launchpad.net/ubuntu-push/testing/condition"
+)
+
+// hook up gocheck
+func TestAcc(t *testing.T) { TestingT(t) }
+
+type AccSuite struct {
+	log *helpers.TestLogger
+}
+
+var _ = Suite(&AccSuite{})
+
+type TestCancellable struct {
+	canceled bool
+	err      error
+}
+
+func (t *TestCancellable) Cancel() error {
+	t.canceled = true
+	return t.err
+}
+
+func (s *AccSuite) SetUpTest(c *C) {
+	s.log = helpers.NewTestLogger(c, "debug")
+}
+
+func (s *AccSuite) TestBusAddressPathUidLoaded(c *C) {
+	c.Check(BusAddress.Path, Matches, `.*\d+`)
+}
+
+func (s *AccSuite) TestCancelCancelsCancellable(c *C) {
+	err := errors.New("cancel error")
+	t := &TestCancellable{err: err}
+	a := New(nil, s.log).(*accounts)
+	a.cancellable = t
+
+	c.Check(a.Cancel(), Equals, err)
+	c.Check(t.canceled, Equals, true)
+}
+
+func (s *AccSuite) TestStartReportsWatchError(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+	a := New(endp, s.log).(*accounts)
+	c.Assert(a, NotNil)
+
+	err := a.Start()
+	c.Check(err, NotNil)
+}
+
+func (s *AccSuite) TestStartSetsCancellable(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), true)
+	a := New(endp, s.log).(*accounts)
+	c.Assert(a, NotNil)
+
+	c.Check(a.cancellable, IsNil)
+	err := a.Start()
+	c.Check(err, IsNil)
+	c.Check(a.cancellable, NotNil)
+	a.Cancel()
+}
+
+func (s *AccSuite) TestStartPanicsIfCalledTwice(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), true, true)
+	a := New(endp, s.log).(*accounts)
+	c.Assert(a, NotNil)
+
+	c.Check(a.cancellable, IsNil)
+	err := a.Start()
+	c.Check(err, IsNil)
+	c.Check(func() { a.startWatch() }, PanicMatches, `.* twice\?`)
+	a.Cancel()
+}
+
+func (s *AccSuite) TestUpdateCallsUpdaters(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true),
+		map[string]dbus.Variant{"x": dbus.Variant{"hello"}})
+	a := New(endp, s.log).(*accounts)
+	c.Assert(a, NotNil)
+	var x dbus.Variant
+	a.updaters = map[string]func(dbus.Variant){
+		"x": func(v dbus.Variant) { x = v },
+	}
+	a.update()
+
+	c.Check(x.Value, Equals, "hello")
+}
+
+func (s *AccSuite) TestUpdateSilentModeBails(c *C) {
+	a := New(nil, s.log).(*accounts)
+	a.updateSilentMode(dbus.Variant{"rubbish"})
+	c.Check(s.log.Captured(), Matches, `(?ms)ERROR SilentMode needed a bool.`)
+}
+
+func (s *AccSuite) TestUpdateSilentModeWorks(c *C) {
+	a := New(nil, s.log).(*accounts)
+	c.Check(a.silent, Equals, false)
+	a.updateSilentMode(dbus.Variant{true})
+	c.Check(a.silent, Equals, true)
+}
+
+func (s *AccSuite) TestUpdateVibrateBails(c *C) {
+	a := New(nil, s.log).(*accounts)
+	a.updateVibrate(dbus.Variant{"rubbish"})
+	c.Check(s.log.Captured(), Matches, `(?ms)ERROR IncomingMessageVibrate needed a bool.`)
+}
+
+func (s *AccSuite) TestUpdateVibrateWorks(c *C) {
+	a := New(nil, s.log).(*accounts)
+	c.Check(a.vibrate, Equals, false)
+	a.updateVibrate(dbus.Variant{true})
+	c.Check(a.vibrate, Equals, true)
+}
+
+func (s *AccSuite) TestUpdateVibrateSilentModeBails(c *C) {
+	a := New(nil, s.log).(*accounts)
+	a.updateVibrateSilentMode(dbus.Variant{"rubbish"})
+	c.Check(s.log.Captured(), Matches, `(?ms)ERROR IncomingMessageVibrateSilentMode needed a bool.`)
+}
+
+func (s *AccSuite) TestUpdateVibrateSilentModeWorks(c *C) {
+	a := New(nil, s.log).(*accounts)
+	c.Check(a.vibrateSilentMode, Equals, false)
+	a.updateVibrateSilentMode(dbus.Variant{true})
+	c.Check(a.vibrateSilentMode, Equals, true)
+}
+
+func (s *AccSuite) TestUpdateMessageSoundBails(c *C) {
+	a := New(nil, s.log).(*accounts)
+	a.updateMessageSound(dbus.Variant{42})
+	c.Check(s.log.Captured(), Matches, `(?ms)ERROR IncomingMessageSound needed a string.`)
+}
+
+func (s *AccSuite) TestUpdateMessageSoundWorks(c *C) {
+	a := New(nil, s.log).(*accounts)
+	c.Check(a.messageSound, Equals, "")
+	a.updateMessageSound(dbus.Variant{"xyzzy"})
+	c.Check(a.messageSound, Equals, "xyzzy")
+}
+
+func (s *AccSuite) TestUpdateMessageSoundPrunesXDG(c *C) {
+	a := New(nil, s.log).(*accounts)
+	a.updateMessageSound(dbus.Variant{"/usr/share/xyzzy"})
+	c.Check(a.messageSound, Equals, "xyzzy")
+}
+
+func (s *AccSuite) TestPropsHandler(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+
+	// testing a series of bad args for propsHandler:  none,
+	New(endp, s.log).(*accounts).propsHandler()
+	c.Check(s.log.Captured(), Matches, `(?ms).*ERROR PropertiesChanged delivered 0 things.*`)
+	s.log.ResetCapture()
+
+	// bad type for all,
+	New(endp, s.log).(*accounts).propsHandler(nil, nil, nil)
+	c.Check(s.log.Captured(), Matches, `(?ms).*ERROR PropertiesChanged 1st param not a string.*`)
+	s.log.ResetCapture()
+
+	// wrong interface,
+	New(endp, s.log).(*accounts).propsHandler("xyzzy", nil, nil)
+	c.Check(s.log.Captured(), Matches, `(?ms).*DEBUG PropertiesChanged for "xyzzy", ignoring\..*`)
+	s.log.ResetCapture()
+
+	// bad type for 2nd and 3rd,
+	New(endp, s.log).(*accounts).propsHandler(accountsSoundIface, nil, nil)
+	c.Check(s.log.Captured(), Matches, `(?ms).*ERROR PropertiesChanged 2nd param not a map.*`)
+	s.log.ResetCapture()
+
+	// not-seen-in-the-wild 'changed' argument (first non-error outcome),
+	New(endp, s.log).(*accounts).propsHandler(accountsSoundIface, map[interface{}]interface{}{"x": "y"}, nil)
+	// tracking the update() via the GetAll call it generates (which will fail because of the testibus of Work(false) above)
+	c.Check(s.log.Captured(), Matches, `(?ms).*INFO PropertiesChanged provided 'changed'.*ERROR when calling GetAll.*`)
+	s.log.ResetCapture()
+
+	// bad type for 3rd (with empty 2nd),
+	New(endp, s.log).(*accounts).propsHandler(accountsSoundIface, map[interface{}]interface{}{}, nil)
+	c.Check(s.log.Captured(), Matches, `(?ms).*ERROR PropertiesChanged 3rd param not a list of properties.*`)
+	s.log.ResetCapture()
+
+	// bad type for elements of 3rd,
+	New(endp, s.log).(*accounts).propsHandler(accountsSoundIface, map[interface{}]interface{}{}, []interface{}{42})
+	c.Check(s.log.Captured(), Matches, `(?ms).*ERROR PropertiesChanged 3rd param's only entry not a string.*`)
+	s.log.ResetCapture()
+
+	// empty 3rd (not an error; hard to test "do ),
+	New(endp, s.log).(*accounts).propsHandler(accountsSoundIface, map[interface{}]interface{}{}, []interface{}{})
+	c.Check(s.log.Captured(), Matches, `(?ms).*DEBUG PropertiesChanged 3rd param is empty.*`)
+	s.log.ResetCapture()
+
+	// more than one 2rd (also not an error; again looking at the GetAll failure to confirm update() got called),
+	New(endp, s.log).(*accounts).propsHandler(accountsSoundIface, map[interface{}]interface{}{}, []interface{}{"hi", "there"})
+	c.Check(s.log.Captured(), Matches, `(?ms).*INFO.* reverting to full update.*ERROR when calling GetAll.*`)
+	s.log.ResetCapture()
+
+	// bus trouble for a single entry in the 3rd,
+	New(endp, s.log).(*accounts).propsHandler(accountsSoundIface, map[interface{}]interface{}{}, []interface{}{"SilentMode"})
+	c.Check(s.log.Captured(), Matches, `(?ms).*ERROR when calling Get for SilentMode.*`)
+	s.log.ResetCapture()
+
+	// and finally, the common case: a single entry in the 3rd param, that gets updated individually.
+	xOuter := dbus.Variant{"x"}
+	a := New(testibus.NewTestingEndpoint(nil, condition.Work(true), xOuter), s.log).(*accounts)
+	called := false
+	a.updaters = map[string]func(dbus.Variant){"xyzzy": func(x dbus.Variant) {
+		c.Check(x, Equals, xOuter)
+		called = true
+	}}
+	a.propsHandler(accountsSoundIface, map[interface{}]interface{}{}, []interface{}{"xyzzy"})
+	c.Check(called, Equals, true)
+}
+
+func (s *AccSuite) TestSilentMode(c *C) {
+	a := New(nil, s.log).(*accounts)
+	c.Check(a.SilentMode(), Equals, false)
+	a.silent = true
+	c.Check(a.SilentMode(), Equals, true)
+}
+
+func (s *AccSuite) TestVibrate(c *C) {
+	a := New(nil, s.log).(*accounts)
+	c.Check(a.Vibrate(), Equals, false)
+	a.vibrate = true
+	c.Check(a.Vibrate(), Equals, true)
+	a.silent = true
+	c.Check(a.Vibrate(), Equals, false)
+	a.vibrateSilentMode = true
+	c.Check(a.Vibrate(), Equals, true)
+	a.vibrate = false
+	c.Check(a.Vibrate(), Equals, true)
+}
+
+func (s *AccSuite) TestMessageSoundFile(c *C) {
+	a := New(nil, s.log).(*accounts)
+	c.Check(a.MessageSoundFile(), Equals, "")
+	a.messageSound = "xyzzy"
+	c.Check(a.MessageSoundFile(), Equals, "xyzzy")
+}
+
+func (s *AccSuite) TestString(c *C) {
+	a := New(nil, s.log).(*accounts)
+	a.vibrate = true
+	a.messageSound = "x"
+	c.Check(a.String(), Equals, `&accounts{silent: false, vibrate: true, vibratesilent: false, messageSound: "x"}`)
+}

=== modified file 'bus/connectivity/connectivity.go'
--- bus/connectivity/connectivity.go	2015-01-22 11:05:37 +0000
+++ bus/connectivity/connectivity.go	2015-03-06 13:26:11 +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
@@ -24,12 +24,14 @@
 
 import (
 	"errors"
+	"sync"
+	"time"
+
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/bus/networkmanager"
 	"launchpad.net/ubuntu-push/config"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/util"
-	"time"
 )
 
 // The configuration for ConnectedState, intended to be populated from a config file.
@@ -45,23 +47,56 @@
 	ConnectivityCheckMD5 string `json:"connectivity_check_md5"`
 }
 
-type connectedState struct {
+// ConnectedState helps tracking connectivity.
+type ConnectedState struct {
 	networkStateCh <-chan networkmanager.State
 	networkConCh   <-chan string
 	config         ConnectivityConfig
 	log            logger.Logger
 	endp           bus.Endpoint
 	connAttempts   uint32
-	webget         func(ch chan<- bool)
+	webchk         Webchecker
 	webgetCh       chan bool
 	currentState   networkmanager.State
 	lastSent       bool
 	timer          *time.Timer
+	doneLck        sync.Mutex
+	done           chan struct{}
+	canceled       bool
+	stateWatch     bus.Cancellable
+	conWatch       bus.Cancellable
+}
+
+// New makes a ConnectedState for connectivity tracking.
+//
+// The endpoint need not be dialed; Track()  will Dial() and
+// Close() it as it sees fit.
+func New(endp bus.Endpoint, config ConnectivityConfig, log logger.Logger) *ConnectedState {
+	wg := NewWebchecker(config.ConnectivityCheckURL, config.ConnectivityCheckMD5, 10*time.Second, log)
+	return &ConnectedState{
+		config: config,
+		log:    log,
+		endp:   endp,
+		webchk: wg,
+		done:   make(chan struct{}),
+	}
+}
+
+// cancel watches if any
+func (cs *ConnectedState) reset() {
+	if cs.stateWatch != nil {
+		cs.stateWatch.Cancel()
+		cs.stateWatch = nil
+	}
+	if cs.conWatch != nil {
+		cs.conWatch.Cancel()
+		cs.conWatch = nil
+	}
 }
 
 // start connects to the bus, gets the initial NetworkManager state, and sets
 // up the watch.
-func (cs *connectedState) start() networkmanager.State {
+func (cs *ConnectedState) start() networkmanager.State {
 	var initial networkmanager.State
 	var stateCh <-chan networkmanager.State
 	var primary string
@@ -72,8 +107,9 @@
 		cs.connAttempts += ar.Redial()
 		nm := networkmanager.New(cs.endp, cs.log)
 
+		cs.reset()
 		// set up the watch
-		stateCh, err = nm.WatchState()
+		stateCh, cs.stateWatch, err = nm.WatchState()
 		if err != nil {
 			cs.log.Debugf("failed to set up the state watch: %s", err)
 			goto Continue
@@ -87,15 +123,15 @@
 		}
 		cs.log.Debugf("got initial state of %s", initial)
 
+		conCh, cs.conWatch, err = nm.WatchPrimaryConnection()
+		if err != nil {
+			cs.log.Debugf("failed to set up the connection watch: %s", err)
+			goto Continue
+		}
+
 		primary = nm.GetPrimaryConnection()
 		cs.log.Debugf("primary connection starts as %#v", primary)
 
-		conCh, err = nm.WatchPrimaryConnection()
-		if err != nil {
-			cs.log.Debugf("failed to set up the connection watch: %s", err)
-			goto Continue
-		}
-
 		cs.networkStateCh = stateCh
 		cs.networkConCh = conCh
 
@@ -107,9 +143,11 @@
 	}
 }
 
-// connectedStateStep takes one step forwards in the “am I connected?”
+var errCanceled = errors.New("canceled")
+
+// step takes one step forwards in the “am I connected?”
 // answering state machine.
-func (cs *connectedState) connectedStateStep() (bool, error) {
+func (cs *ConnectedState) step() (bool, error) {
 	stabilizingTimeout := cs.config.StabilizingTimeout.Duration
 	recheckTimeout := cs.config.RecheckTimeout.Duration
 	log := cs.log
@@ -117,6 +155,8 @@
 Loop:
 	for {
 		select {
+		case <-cs.done:
+			return false, errCanceled
 		case <-cs.networkConCh:
 			cs.webgetCh = nil
 			cs.timer.Reset(stabilizingTimeout)
@@ -155,8 +195,13 @@
 		case <-cs.timer.C:
 			if cs.currentState == networkmanager.ConnectedGlobal {
 				log.Debugf("connectivity: timer signal, state: ConnectedGlobal, checking...")
-				cs.webgetCh = make(chan bool)
-				go cs.webget(cs.webgetCh)
+				// use a buffered channel, otherwise
+				// we may leak webcheckers that cannot
+				// send their result because we have
+				// cleared webgetCh and wont receive
+				// on it
+				cs.webgetCh = make(chan bool, 1)
+				go cs.webchk.Webcheck(cs.webgetCh)
 			}
 
 		case connected := <-cs.webgetCh:
@@ -173,35 +218,49 @@
 	return cs.lastSent, nil
 }
 
-// ConnectedState sends the initial NetworkManager state and changes to it
+// Track sends the initial NetworkManager state and changes to it
 // over the "out" channel. Sends "false" as soon as it detects trouble, "true"
 // after checking actual connectivity.
 //
-// The endpoint need not be dialed; connectivity will Dial() and Close()
-// it as it sees fit.
-func ConnectedState(endp bus.Endpoint, config ConnectivityConfig, log logger.Logger, out chan<- bool) {
-	wg := NewWebchecker(config.ConnectivityCheckURL, config.ConnectivityCheckMD5, 10*time.Second, log)
-	cs := &connectedState{
-		config: config,
-		log:    log,
-		endp:   endp,
-		webget: wg.Webcheck,
-	}
+func (cs *ConnectedState) Track(out chan<- bool) {
 
 Start:
-	log.Debugf("sending initial 'disconnected'.")
-	out <- false
+	cs.log.Debugf("sending initial 'disconnected'.")
+	select {
+	case <-cs.done:
+		return
+	case out <- false:
+	}
 	cs.lastSent = false
 	cs.currentState = cs.start()
+	defer cs.reset()
 	cs.timer = time.NewTimer(cs.config.StabilizingTimeout.Duration)
 
 	for {
-		v, err := cs.connectedStateStep()
+		v, err := cs.step()
+		if err == errCanceled {
+			return
+		}
 		if err != nil {
 			// tear it all down and start over
-			log.Errorf("%s", err)
+			cs.log.Errorf("%s", err)
 			goto Start
 		}
-		out <- v
+		select {
+		case <-cs.done:
+			return
+		case out <- v:
+		}
+	}
+}
+
+// Cancel stops the ConnectedState machinary.
+func (cs *ConnectedState) Cancel() {
+	cs.doneLck.Lock()
+	defer cs.doneLck.Unlock()
+	if !cs.canceled {
+		cs.canceled = true
+		close(cs.done)
+		cs.webchk.Close()
 	}
 }

=== modified file 'bus/connectivity/connectivity_test.go'
--- bus/connectivity/connectivity_test.go	2015-01-21 17:55:35 +0000
+++ bus/connectivity/connectivity_test.go	2015-03-06 13:26:11 +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
@@ -58,22 +58,37 @@
 	s.log = helpers.NewTestLogger(c, "debug")
 }
 
+var (
+	helloCon      = dbus.ObjectPath("hello")
+	helloConProps = map[string]dbus.Variant{"PrimaryConnection": dbus.Variant{helloCon}}
+)
+
 /*
-   tests for connectedState's Start() method
+   tests for ConnectedState's Start() method
 */
 
 // when given a working config and bus, Start() will work
 func (s *ConnSuite) TestStartWorks(c *C) {
-	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(networkmanager.Connecting))
-	cs := connectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(networkmanager.Connecting), helloCon)
+	cs := ConnectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+
+	nopTicker := make(chan []interface{})
+	testingbus.SetWatchSource(endp, "StateChanged", nopTicker)
+	testingbus.SetWatchSource(endp, "PropertiesChanged", nopTicker)
+	defer close(nopTicker)
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 }
 
 // if the bus fails a couple of times, we're still OK
 func (s *ConnSuite) TestStartRetriesConnect(c *C) {
-	endp := testingbus.NewTestingEndpoint(condition.Fail2Work(2), condition.Work(true), uint32(networkmanager.Connecting))
-	cs := connectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+	endp := testingbus.NewTestingEndpoint(condition.Fail2Work(2), condition.Work(true), uint32(networkmanager.Connecting), helloCon)
+	cs := ConnectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+
+	nopTicker := make(chan []interface{})
+	testingbus.SetWatchSource(endp, "StateChanged", nopTicker)
+	testingbus.SetWatchSource(endp, "PropertiesChanged", nopTicker)
+	defer close(nopTicker)
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 	c.Check(cs.connAttempts, Equals, uint32(3)) // 1 more than the Fail2Work
@@ -81,8 +96,13 @@
 
 // when the calls to NetworkManager fails for a bit, we're still OK
 func (s *ConnSuite) TestStartRetriesCall(c *C) {
-	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Fail2Work(5), uint32(networkmanager.Connecting))
-	cs := connectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Fail2Work(5), uint32(networkmanager.Connecting), helloCon)
+	cs := ConnectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+
+	nopTicker := make(chan []interface{})
+	testingbus.SetWatchSource(endp, "StateChanged", nopTicker)
+	testingbus.SetWatchSource(endp, "PropertiesChanged", nopTicker)
+	defer close(nopTicker)
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 
@@ -91,11 +111,19 @@
 
 // when some of the calls to NetworkManager fails for a bit, we're still OK
 func (s *ConnSuite) TestStartRetriesCall2(c *C) {
-	cond := condition.Chain(3, condition.Work(true), 1, condition.Work(false),
+	cond := condition.Chain(1, condition.Work(true), 1, condition.Work(false),
 		1, condition.Work(true))
 
-	endp := testingbus.NewTestingEndpoint(condition.Work(true), cond, uint32(networkmanager.Connecting))
-	cs := connectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+	endp := testingbus.NewTestingEndpoint(condition.Work(true), cond,
+		uint32(networkmanager.Connecting), helloCon,
+		uint32(networkmanager.Connecting), helloCon,
+	)
+	cs := ConnectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+
+	nopTicker := make(chan []interface{})
+	testingbus.SetWatchSource(endp, "StateChanged", nopTicker)
+	testingbus.SetWatchSource(endp, "PropertiesChanged", nopTicker)
+	defer close(nopTicker)
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 }
@@ -105,17 +133,25 @@
 // watch, we recover and try again.
 func (s *ConnSuite) TestStartRetriesWatch(c *C) {
 	nmcond := condition.Chain(
-		1, condition.Work(true), // 1 call to nm works
+		2, condition.Work(true), // 2 call to nm works
 		1, condition.Work(false), // 1 call to nm fails
 		0, condition.Work(true)) // and everything works from there on
 	endp := testingbus.NewTestingEndpoint(condition.Work(true), nmcond,
 		uint32(networkmanager.Connecting),
-		uint32(networkmanager.ConnectedGlobal))
-	cs := connectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+		uint32(networkmanager.Connecting),
+		helloCon,
+	)
+	cs := ConnectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+	watchTicker := make(chan []interface{}, 1)
+	nopTicker := make(chan []interface{})
+	testingbus.SetWatchSource(endp, "StateChanged", watchTicker)
+	testingbus.SetWatchSource(endp, "PropertiesChanged", nopTicker)
+	defer close(nopTicker)
+	defer close(watchTicker)
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 	c.Check(cs.connAttempts, Equals, uint32(2))
-	c.Check(<-cs.networkStateCh, Equals, networkmanager.Connecting)
+	watchTicker <- []interface{}{uint32(networkmanager.ConnectedGlobal)}
 	c.Check(<-cs.networkStateCh, Equals, networkmanager.ConnectedGlobal)
 }
 
@@ -144,7 +180,7 @@
 	}
 }
 
-func (rep *racyEndpoint) WatchSignal(member string, f func(...interface{}), d func()) error {
+func (rep *racyEndpoint) WatchSignal(member string, f func(...interface{}), d func()) (bus.Cancellable, error) {
 	if member == "StateChanged" {
 		// we count never having gotten the state as happening "after" now.
 		rep.lock.RLock()
@@ -157,7 +193,7 @@
 			d()
 		}()
 	}
-	return nil
+	return nil, nil
 }
 
 func (*racyEndpoint) Close()                                                        {}
@@ -186,7 +222,7 @@
 func (s *ConnSuite) TestStartAvoidsRace(c *C) {
 	for delta := time.Second; delta > 1; delta /= 2 {
 		rep := &racyEndpoint{delta: delta}
-		cs := connectedState{config: ConnectivityConfig{}, log: s.log, endp: rep}
+		cs := ConnectedState{config: ConnectivityConfig{}, log: s.log, endp: rep}
 		f := Commentf("when delta=%s", delta)
 		c.Assert(cs.start(), Equals, networkmanager.Connecting, f)
 		c.Assert(takeNext(cs.networkStateCh), Equals, networkmanager.ConnectedGlobal, f)
@@ -194,9 +230,18 @@
 }
 
 /*
-   tests for connectedStateStep()
+   tests for step()
 */
 
+type testWebchk func(ch chan<- bool)
+
+func (x testWebchk) Webcheck(ch chan<- bool) {
+	x(ch)
+}
+
+func (x testWebchk) Close() {
+}
+
 func (s *ConnSuite) TestSteps(c *C) {
 	var webget_p condition.Interface = condition.Work(true)
 	recheck_timeout := 50 * time.Millisecond
@@ -205,24 +250,24 @@
 		RecheckTimeout: config.ConfigTimeDuration{recheck_timeout},
 	}
 	ch := make(chan networkmanager.State, 10)
-	cs := &connectedState{
+	cs := &ConnectedState{
 		config:         cfg,
 		networkStateCh: ch,
 		timer:          time.NewTimer(time.Second),
 		log:            s.log,
-		webget:         func(ch chan<- bool) { ch <- webget_p.OK() },
+		webchk:         testWebchk(func(ch chan<- bool) { ch <- webget_p.OK() }),
 		lastSent:       false,
 	}
 	ch <- networkmanager.ConnectedGlobal
-	f, e := cs.connectedStateStep()
+	f, e := cs.step()
 	c.Check(e, IsNil)
 	c.Check(f, Equals, true)
 	ch <- networkmanager.Disconnected
 	ch <- networkmanager.ConnectedGlobal
-	f, e = cs.connectedStateStep()
+	f, e = cs.step()
 	c.Check(e, IsNil)
 	c.Check(f, Equals, false)
-	f, e = cs.connectedStateStep()
+	f, e = cs.step()
 	c.Check(e, IsNil)
 	c.Check(f, Equals, true)
 
@@ -230,7 +275,7 @@
 	webget_p = condition.Fail2Work(1)
 	ch <- networkmanager.Disconnected
 	ch <- networkmanager.ConnectedGlobal
-	f, e = cs.connectedStateStep()
+	f, e = cs.step()
 	c.Check(e, IsNil)
 	c.Check(f, Equals, false) // first false is from the Disconnected
 
@@ -239,7 +284,7 @@
 	_t := time.NewTimer(recheck_timeout / 2)
 
 	go func() {
-		f, e := cs.connectedStateStep()
+		f, e := cs.step()
 		c.Check(e, IsNil)
 		_ch <- f
 	}()
@@ -257,15 +302,15 @@
 	ch <- networkmanager.Disconnected    // this should not
 	ch <- networkmanager.ConnectedGlobal // this should trigger a 'true'
 
-	f, e = cs.connectedStateStep()
+	f, e = cs.step()
 	c.Check(e, IsNil)
 	c.Check(f, Equals, false)
-	f, e = cs.connectedStateStep()
+	f, e = cs.step()
 	c.Check(e, IsNil)
 	c.Check(f, Equals, true)
 
 	close(ch) // this should make it error out
-	_, e = cs.connectedStateStep()
+	_, e = cs.step()
 	c.Check(e, NotNil)
 }
 
@@ -285,32 +330,50 @@
 	}
 
 	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Work(true),
-		uint32(networkmanager.ConnectedGlobal),
-		uint32(networkmanager.Disconnected),
+		uint32(networkmanager.Disconnected),
+		helloCon,
+		uint32(networkmanager.Disconnected),
+		helloCon,
 	)
 
-	watchTicker := make(chan bool)
-	testingbus.SetWatchTicker(endp, watchTicker)
+	watchTicker := make(chan []interface{})
+	testingbus.SetWatchSource(endp, "StateChanged", watchTicker)
+	nopTicker := make(chan []interface{})
+	testingbus.SetWatchSource(endp, "PropertiesChanged", nopTicker)
 
 	out := make(chan bool)
 	dt := time.Second / 10
 	timer := time.NewTimer(dt)
-	go ConnectedState(endp, cfg, s.log, out)
+	cs := New(endp, cfg, s.log)
+	defer cs.Cancel()
+	go cs.Track(out)
 	var v bool
 	expecteds := []struct {
-		p bool
-		s string
-		n int
+		p    bool
+		s    string
+		todo string
 	}{
-		{false, "first state is always false", 0},
-		{true, "then it should be true as per ConnectedGlobal above", 0},
-		{false, "then it should be false (Disconnected)", 2},
-		{false, "then it should be false again because it's restarted", 2},
+		{false, "first state is always false", ""},
+		{true, "then it should be true as per ConnectedGlobal above", "ConnectedGlobal"},
+		{false, "then it should be false (Disconnected)", "Disconnected"},
+		{false, "then it should be false again because it's restarted", "close"},
 	}
 
+	defer func() {
+		if watchTicker != nil {
+			close(watchTicker)
+		}
+	}()
+	defer close(nopTicker)
 	for i, expected := range expecteds {
-		for j := 0; j < expected.n; j++ {
-			watchTicker <- true
+		switch expected.todo {
+		case "ConnectedGlobal":
+			watchTicker <- []interface{}{uint32(networkmanager.ConnectedGlobal)}
+		case "Disconnected":
+			watchTicker <- []interface{}{uint32(networkmanager.Disconnected)}
+		case "close":
+			close(watchTicker)
+			watchTicker = nil
 		}
 		timer.Reset(dt)
 		select {
@@ -335,31 +398,41 @@
 
 	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Work(true),
 		uint32(networkmanager.ConnectedGlobal),
-		map[string]dbus.Variant{"PrimaryConnection": dbus.Variant{dbus.ObjectPath("hello")}},
+		helloCon,
 	)
 
-	watchTicker := make(chan bool)
-	testingbus.SetWatchTicker(endp, watchTicker)
+	watchTicker := make(chan []interface{})
+	testingbus.SetWatchSource(endp, "PropertiesChanged", watchTicker)
+	nopTicker := make(chan []interface{})
+	testingbus.SetWatchSource(endp, "StateChanged", nopTicker)
 
 	out := make(chan bool)
 	dt := time.Second / 10
 	timer := time.NewTimer(dt)
-	go ConnectedState(endp, cfg, s.log, out)
+	cs := New(endp, cfg, s.log)
+	defer cs.Cancel()
+	go cs.Track(out)
 	var v bool
 	expecteds := []struct {
-		p bool
-		s string
-		n int
+		p           bool
+		s           string
+		changedConn bool
 	}{
-		{false, "first state is always false", 0},
-		{true, "then it should be true as per ConnectedGlobal above", 0},
-		{false, "then, false (PrimaryConnection changed)", 2},
-		{true, "then it should be true (webcheck passed)", 0},
+		{false, "first state is always false", false},
+		{true, "then it should be true as per ConnectedGlobal above", false},
+		{false, "then, false (PrimaryConnection changed)", true},
+		{true, "then it should be true (webcheck passed)", false},
 	}
 
+	defer func() {
+		if watchTicker != nil {
+			close(watchTicker)
+		}
+	}()
+	defer close(nopTicker)
 	for i, expected := range expecteds {
-		for j := 0; j < expected.n; j++ {
-			watchTicker <- true
+		if expected.changedConn {
+			watchTicker <- []interface{}{helloConProps}
 		}
 		timer.Reset(dt)
 		select {

=== modified file 'bus/connectivity/webchecker.go'
--- bus/connectivity/webchecker.go	2015-02-05 13:38:31 +0000
+++ bus/connectivity/webchecker.go	2015-03-06 13:26:11 +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
@@ -40,6 +40,8 @@
 	// contents match the target. If so, then it sends true; if anything
 	// fails, it sends false.
 	Webcheck(chan<- bool)
+	// Close idle connections.
+	Close()
 }
 
 type webchecker struct {
@@ -89,3 +91,7 @@
 		ch <- false
 	}
 }
+
+func (wb *webchecker) Close() {
+	wb.cli.Transport.(*http13.Transport).CloseIdleConnections()
+}

=== modified file 'bus/connectivity/webchecker_test.go'
--- bus/connectivity/webchecker_test.go	2015-02-05 13:38:31 +0000
+++ bus/connectivity/webchecker_test.go	2015-03-06 13:26:11 +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
@@ -81,6 +81,7 @@
 	defer ts.Close()
 
 	ck := NewWebchecker(ts.URL, staticHash, 5*time.Second, s.log)
+	defer ck.Close()
 	ch := make(chan bool, 1)
 	ck.Webcheck(ch)
 	c.Check(<-ch, Equals, true)
@@ -89,6 +90,7 @@
 // Webchecker sends false if the download fails.
 func (s *WebcheckerSuite) TestActualFails(c *C) {
 	ck := NewWebchecker("garbage://", "", 5*time.Second, s.log)
+	defer ck.Close()
 	ch := make(chan bool, 1)
 	ck.Webcheck(ch)
 	c.Check(<-ch, Equals, false)
@@ -100,6 +102,7 @@
 	defer ts.Close()
 
 	ck := NewWebchecker(ts.URL, staticHash, 5*time.Second, s.log)
+	defer ck.Close()
 	ch := make(chan bool, 1)
 	ck.Webcheck(ch)
 	c.Check(<-ch, Equals, false)
@@ -112,6 +115,7 @@
 	defer ts.Close()
 
 	ck := NewWebchecker(ts.URL, bigHash, 5*time.Second, s.log)
+	defer ck.Close()
 	ch := make(chan bool, 1)
 	ck.Webcheck(ch)
 	c.Check(<-ch, Equals, false)
@@ -131,6 +135,7 @@
 	}()
 
 	ck := NewWebchecker(ts.URL, bigHash, time.Second, s.log)
+	defer ck.Close()
 	ch := make(chan bool, 1)
 	ck.Webcheck(ch)
 	c.Check(<-ch, Equals, false)

=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2015-01-22 09:52:07 +0000
+++ bus/endpoint.go	2015-03-06 13:26:11 +0000
@@ -35,10 +35,15 @@
 type BusMethod func(string, []interface{}, []interface{}) ([]interface{}, error)
 type DispatchMap map[string]BusMethod
 
+// Cancellable can be canceled.
+type Cancellable interface {
+	Cancel() error
+}
+
 // bus.Endpoint represents the DBus connection itself.
 type Endpoint interface {
 	GrabName(allowReplacement bool) <-chan error
-	WatchSignal(member string, f func(...interface{}), d func()) error
+	WatchSignal(member string, f func(...interface{}), d func()) (Cancellable, error)
 	WatchMethod(DispatchMap, string, ...interface{})
 	Signal(string, string, []interface{}) error
 	Call(member string, args []interface{}, rvs ...interface{}) error
@@ -123,16 +128,16 @@
 // sends the values over a channel, and d() would close the channel.
 //
 // XXX: untested
-func (endp *endpoint) WatchSignal(member string, f func(...interface{}), d func()) error {
+func (endp *endpoint) WatchSignal(member string, f func(...interface{}), d func()) (Cancellable, error) {
 	watch, err := endp.proxy.WatchSignal(endp.addr.Interface, member)
 	if err != nil {
 		endp.log.Debugf("failed to set up the watch: %s", err)
-		return err
+		return nil, err
 	}
 
 	go endp.unpackMessages(watch, f, d, member)
 
-	return nil
+	return watch, nil
 }
 
 // Call() invokes the provided member method (on the name, path and
@@ -324,6 +329,6 @@
 		}
 		f(endp.unpackOneMsg(msg, member)...)
 	}
-	endp.log.Errorf("got not-OK from %s watch", member)
+	endp.log.Debugf("got not-OK from %s watch", member)
 	d()
 }

=== modified file 'bus/haptic/haptic.go'
--- bus/haptic/haptic.go	2014-08-08 01:07:38 +0000
+++ bus/haptic/haptic.go	2015-03-06 13:26:11 +0000
@@ -20,6 +20,7 @@
 
 import (
 	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/bus/accounts"
 	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
@@ -36,12 +37,13 @@
 type Haptic struct {
 	bus      bus.Endpoint
 	log      logger.Logger
+	acc      accounts.Accounts
 	fallback *launch_helper.Vibration
 }
 
 // New returns a new Haptic that'll use the provided bus.Endpoint
-func New(endp bus.Endpoint, log logger.Logger, fallback *launch_helper.Vibration) *Haptic {
-	return &Haptic{endp, log, fallback}
+func New(endp bus.Endpoint, log logger.Logger, acc accounts.Accounts, fallback *launch_helper.Vibration) *Haptic {
+	return &Haptic{endp, log, acc, fallback}
 }
 
 // Present presents the notification via a vibrate pattern
@@ -50,6 +52,11 @@
 		panic("please check notification is not nil before calling present")
 	}
 
+	if !haptic.acc.Vibrate() {
+		haptic.log.Debugf("[%s] vibrate disabled by user.", nid)
+		return false
+	}
+
 	vib := notification.Vibration(haptic.fallback)
 	if vib == nil {
 		haptic.log.Debugf("[%s] notification has no Vibrate.", nid)

=== modified file 'bus/haptic/haptic_test.go'
--- bus/haptic/haptic_test.go	2014-08-08 01:07:38 +0000
+++ bus/haptic/haptic_test.go	2015-03-06 13:26:11 +0000
@@ -35,20 +35,36 @@
 type hapticSuite struct {
 	log *helpers.TestLogger
 	app *click.AppId
-}
+	acc *mockAccounts
+}
+
+type mockAccounts struct {
+	vib bool
+	sil bool
+	snd string
+	err error
+}
+
+func (m *mockAccounts) Start() error             { return m.err }
+func (m *mockAccounts) Cancel() error            { return m.err }
+func (m *mockAccounts) SilentMode() bool         { return m.sil }
+func (m *mockAccounts) Vibrate() bool            { return m.vib }
+func (m *mockAccounts) MessageSoundFile() string { return m.snd }
+func (m *mockAccounts) String() string           { return "<mockAccounts>" }
 
 var _ = Suite(&hapticSuite{})
 
 func (hs *hapticSuite) SetUpTest(c *C) {
 	hs.log = helpers.NewTestLogger(c, "debug")
 	hs.app = clickhelp.MustParseAppId("com.example.test_test-app_0")
+	hs.acc = &mockAccounts{true, false, "xyzzy", nil}
 }
 
 // checks that Present() actually calls VibratePattern
 func (hs *hapticSuite) TestPresentPresents(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
 
-	ec := New(endp, hs.log, nil)
+	ec := New(endp, hs.log, hs.acc, nil)
 	notif := launch_helper.Notification{RawVibration: json.RawMessage(`{"pattern": [200, 100], "repeat": 2}`)}
 	c.Check(ec.Present(hs.app, "nid", &notif), Equals, true)
 	callArgs := testibus.GetCallArgs(endp)
@@ -61,7 +77,7 @@
 func (hs *hapticSuite) TestPresentDefaultsRepeatTo1(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
 
-	ec := New(endp, hs.log, nil)
+	ec := New(endp, hs.log, hs.acc, nil)
 	// note: no Repeat:
 	notif := launch_helper.Notification{RawVibration: json.RawMessage(`{"pattern": [200, 100]}`)}
 	c.Check(ec.Present(hs.app, "nid", &notif), Equals, true)
@@ -76,7 +92,7 @@
 func (hs *hapticSuite) TestSkipIfMissing(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
 
-	ec := New(endp, hs.log, nil)
+	ec := New(endp, hs.log, hs.acc, nil)
 	// no Vibration in the notificaton
 	c.Check(ec.Present(hs.app, "", &launch_helper.Notification{}), Equals, false)
 	// empty Vibration
@@ -85,11 +101,24 @@
 	c.Check(ec.Present(hs.app, "", &launch_helper.Notification{RawVibration: json.RawMessage(`{}`)}), Equals, false)
 }
 
+// check that Present() does not present if the accounts' Vibrate() returns false
+func (hs *hapticSuite) TestPresentSkipsIfVibrateDisabled(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+	fallback := &launch_helper.Vibration{Pattern: []uint32{200, 100}, Repeat: 2}
+
+	ec := New(endp, hs.log, hs.acc, fallback)
+	notif := launch_helper.Notification{RawVibration: json.RawMessage(`true`)}
+	c.Assert(ec.Present(hs.app, "nid", &notif), Equals, true)
+	// ok!
+	hs.acc.vib = false
+	c.Check(ec.Present(hs.app, "nid", &notif), Equals, false)
+}
+
 // check that Present() panics if the notification is nil
 func (hs *hapticSuite) TestPanicsIfNil(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
 
-	ec := New(endp, hs.log, nil)
+	ec := New(endp, hs.log, hs.acc, nil)
 	// no notification at all
 	c.Check(func() { ec.Present(hs.app, "", nil) }, Panics, `please check notification is not nil before calling present`)
 }
@@ -99,7 +128,7 @@
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
 	fallback := &launch_helper.Vibration{Pattern: []uint32{200, 100}, Repeat: 2}
 
-	ec := New(endp, hs.log, fallback)
+	ec := New(endp, hs.log, hs.acc, fallback)
 	notif := launch_helper.Notification{RawVibration: json.RawMessage(`false`)}
 	c.Check(ec.Present(hs.app, "nid", &notif), Equals, false)
 	notif = launch_helper.Notification{RawVibration: json.RawMessage(`true`)}

=== modified file 'bus/networkmanager/networkmanager.go'
--- bus/networkmanager/networkmanager.go	2015-01-22 09:52:07 +0000
+++ bus/networkmanager/networkmanager.go	2015-03-06 13:26:11 +0000
@@ -42,13 +42,13 @@
 	GetState() State
 	// WatchState listens for changes to NetworkManager's state, and sends
 	// them out over the channel returned.
-	WatchState() (<-chan State, error)
+	WatchState() (<-chan State, bus.Cancellable, error)
 	// GetPrimaryConnection fetches and returns NetworkManager's current
 	// primary connection.
 	GetPrimaryConnection() string
 	// WatchPrimaryConnection listens for changes of NetworkManager's
 	// Primary Connection, and sends it out over the channel returned.
-	WatchPrimaryConnection() (<-chan string, error)
+	WatchPrimaryConnection() (<-chan string, bus.Cancellable, error)
 }
 
 type networkManager struct {
@@ -85,9 +85,9 @@
 	return State(v)
 }
 
-func (nm *networkManager) WatchState() (<-chan State, error) {
+func (nm *networkManager) WatchState() (<-chan State, bus.Cancellable, error) {
 	ch := make(chan State)
-	err := nm.bus.WatchSignal("StateChanged",
+	w, err := nm.bus.WatchSignal("StateChanged",
 		func(ns ...interface{}) {
 			stint, ok := ns[0].(uint32)
 			if !ok {
@@ -101,10 +101,10 @@
 		func() { close(ch) })
 	if err != nil {
 		nm.log.Debugf("Failed to set up the watch: %s", err)
-		return nil, err
+		return nil, nil, err
 	}
 
-	return ch, nil
+	return ch, w, nil
 }
 
 func (nm *networkManager) GetPrimaryConnection() string {
@@ -124,9 +124,9 @@
 	return string(v)
 }
 
-func (nm *networkManager) WatchPrimaryConnection() (<-chan string, error) {
+func (nm *networkManager) WatchPrimaryConnection() (<-chan string, bus.Cancellable, error) {
 	ch := make(chan string)
-	err := nm.bus.WatchSignal("PropertiesChanged",
+	w, err := nm.bus.WatchSignal("PropertiesChanged",
 		func(ppsi ...interface{}) {
 			pps, ok := ppsi[0].(map[string]dbus.Variant)
 			if !ok {
@@ -147,8 +147,8 @@
 		}, func() { close(ch) })
 	if err != nil {
 		nm.log.Debugf("failed to set up the watch: %s", err)
-		return nil, err
+		return nil, nil, err
 	}
 
-	return ch, nil
+	return ch, w, nil
 }

=== modified file 'bus/networkmanager/networkmanager_test.go'
--- bus/networkmanager/networkmanager_test.go	2014-04-04 12:01:42 +0000
+++ bus/networkmanager/networkmanager_test.go	2015-03-06 13:26:11 +0000
@@ -90,8 +90,9 @@
 func (s *NMSuite) TestWatchState(c *C) {
 	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), uint32(Unknown), uint32(Asleep), uint32(ConnectedGlobal))
 	nm := New(tc, s.log)
-	ch, err := nm.WatchState()
-	c.Check(err, IsNil)
+	ch, w, err := nm.WatchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
 	l := []State{<-ch, <-ch, <-ch}
 	c.Check(l, DeepEquals, []State{Unknown, Asleep, ConnectedGlobal})
 }
@@ -99,7 +100,7 @@
 // WatchState returns on error if the dbus call fails
 func (s *NMSuite) TestWatchStateFails(c *C) {
 	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
-	_, err := nm.WatchState()
+	_, _, err := nm.WatchState()
 	c.Check(err, NotNil)
 }
 
@@ -107,8 +108,9 @@
 func (s *NMSuite) TestWatchStateClosesOnWatchBail(c *C) {
 	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true))
 	nm := New(tc, s.log)
-	ch, err := nm.WatchState()
-	c.Check(err, IsNil)
+	ch, w, err := nm.WatchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
 	_, ok := <-ch
 	c.Check(ok, Equals, false)
 }
@@ -117,8 +119,9 @@
 func (s *NMSuite) TestWatchStateSurvivesRubbishValues(c *C) {
 	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), "a")
 	nm := New(tc, s.log)
-	ch, err := nm.WatchState()
-	c.Check(err, IsNil)
+	ch, w, err := nm.WatchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
 	_, ok := <-ch
 	c.Check(ok, Equals, false)
 }
@@ -164,8 +167,9 @@
 		mkPriConMap("/b/2"),
 		mkPriConMap("/c/3"))
 	nm := New(tc, s.log)
-	ch, err := nm.WatchPrimaryConnection()
-	c.Check(err, IsNil)
+	ch, w, err := nm.WatchPrimaryConnection()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
 	l := []string{<-ch, <-ch, <-ch}
 	c.Check(l, DeepEquals, []string{"/a/1", "/b/2", "/c/3"})
 }
@@ -173,7 +177,7 @@
 // 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()
+	_, _, err := nm.WatchPrimaryConnection()
 	c.Check(err, NotNil)
 }
 
@@ -181,8 +185,9 @@
 func (s *NMSuite) TestWatchPrimaryConnectionClosesOnWatchBail(c *C) {
 	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true))
 	nm := New(tc, s.log)
-	ch, err := nm.WatchPrimaryConnection()
-	c.Check(err, IsNil)
+	ch, w, err := nm.WatchPrimaryConnection()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
 	_, ok := <-ch
 	c.Check(ok, Equals, false)
 }
@@ -191,8 +196,9 @@
 func (s *NMSuite) TestWatchPrimaryConnectionSurvivesRubbishValues(c *C) {
 	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), "a")
 	nm := New(tc, s.log)
-	ch, err := nm.WatchPrimaryConnection()
+	ch, w, err := nm.WatchPrimaryConnection()
 	c.Assert(err, IsNil)
+	defer w.Cancel()
 	_, ok := <-ch
 	c.Check(ok, Equals, false)
 }
@@ -204,8 +210,9 @@
 		map[string]dbus.Variant{"PrimaryConnection": dbus.Variant{dbus.ObjectPath("42")}},
 	)
 	nm := New(tc, s.log)
-	ch, err := nm.WatchPrimaryConnection()
+	ch, w, err := nm.WatchPrimaryConnection()
 	c.Assert(err, IsNil)
+	defer w.Cancel()
 	v, ok := <-ch
 	c.Check(ok, Equals, true)
 	c.Check(v, Equals, "42")
@@ -218,8 +225,9 @@
 		map[string]dbus.Variant{"PrimaryConnection": dbus.Variant{dbus.ObjectPath("42")}},
 	)
 	nm := New(tc, s.log)
-	ch, err := nm.WatchPrimaryConnection()
+	ch, w, err := nm.WatchPrimaryConnection()
 	c.Assert(err, IsNil)
+	defer w.Cancel()
 	v, ok := <-ch
 	c.Check(ok, Equals, true)
 	c.Check(v, Equals, "42")

=== modified file 'bus/notifications/raw.go'
--- bus/notifications/raw.go	2015-01-22 09:52:07 +0000
+++ bus/notifications/raw.go	2015-03-06 13:26:11 +0000
@@ -93,7 +93,7 @@
 // and sends them over the channel provided
 func (raw *RawNotifications) WatchActions() (<-chan *RawAction, error) {
 	ch := make(chan *RawAction)
-	err := raw.bus.WatchSignal("ActionInvoked",
+	_, err := raw.bus.WatchSignal("ActionInvoked",
 		func(ns ...interface{}) {
 			if len(ns) != 2 {
 				raw.log.Debugf("ActionInvoked delivered %d things instead of 2", len(ns))

=== modified file 'bus/notifications/raw_test.go'
--- bus/notifications/raw_test.go	2014-08-15 10:33:04 +0000
+++ bus/notifications/raw_test.go	2015-03-06 13:26:11 +0000
@@ -111,14 +111,16 @@
 	errstr string
 	endp   bus.Endpoint
 	works  bool
+	src    chan []interface{}
 }
 
 func (s *RawSuite) TestWatchActionsToleratesDBusWeirdness(c *C) {
 	X := func(errstr string, args ...interface{}) tst {
-		endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), args)
-		// stop the endpoint from closing the channel:
-		testibus.SetWatchTicker(endp, make(chan bool))
-		return tst{errstr, endp, errstr == ""}
+		endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true))
+		src := make(chan []interface{}, 1)
+		testibus.SetWatchSource(endp, "ActionInvoked", src)
+		src <- args
+		return tst{errstr, endp, errstr == "", src}
 	}
 
 	ts := []tst{
@@ -146,6 +148,7 @@
 		}
 		c.Check(s.log.Captured(), Matches, `(?ms).*`+t.errstr+`.*`)
 		s.log.ResetCapture()
+		close(t.src)
 	}
 
 }

=== modified file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	2015-01-29 09:48:40 +0000
+++ bus/testing/testing_endpoint.go	2015-03-06 13:26:11 +0000
@@ -36,13 +36,15 @@
 }
 
 type testingEndpoint struct {
-	dialCond    condition.Interface
-	callCond    condition.Interface
-	retvals     [][]interface{}
-	watchTicker chan bool
-	watchLck    sync.RWMutex
-	callArgs    []callArgs
-	callArgsLck sync.RWMutex
+	dialCond     condition.Interface
+	callCond     condition.Interface
+	usedLck      sync.Mutex
+	used         int
+	retvals      [][]interface{}
+	watchSources map[string]chan []interface{}
+	watchLck     sync.RWMutex
+	callArgs     []callArgs
+	callArgsLck  sync.RWMutex
 }
 
 // Build a bus.Endpoint that calls OK() on its condition before returning
@@ -51,7 +53,7 @@
 // NOTE: Call() always returns the first return value; Watch() will provide
 // each of them in turn, irrespective of whether Call has been called.
 func NewMultiValuedTestingEndpoint(dialCond condition.Interface, callCond condition.Interface, retvalses ...[]interface{}) bus.Endpoint {
-	return &testingEndpoint{dialCond: dialCond, callCond: callCond, retvals: retvalses}
+	return &testingEndpoint{dialCond: dialCond, callCond: callCond, retvals: retvalses, watchSources: make(map[string]chan []interface{})}
 }
 
 func NewTestingEndpoint(dialCond condition.Interface, callCond condition.Interface, retvals ...interface{}) bus.Endpoint {
@@ -59,15 +61,15 @@
 	for i, x := range retvals {
 		retvalses[i] = []interface{}{x}
 	}
-	return &testingEndpoint{dialCond: dialCond, callCond: callCond, retvals: retvalses}
+	return &testingEndpoint{dialCond: dialCond, callCond: callCond, retvals: retvalses, watchSources: make(map[string]chan []interface{})}
 }
 
-// If SetWatchTicker is called with a non-nil watchTicker, it is used
-// instead of the default timeout to wait while sending values over
-// WatchSignal. Set it to nil again to restore default behaviour.
-func SetWatchTicker(tc bus.Endpoint, watchTicker chan bool) {
+// If SetWatchSource is called with a non-nil watchSource, it is used
+// instead of the default timeout and retvals to get values to send
+// over WatchSignal. Set it to nil again to restore default behaviour.
+func SetWatchSource(tc bus.Endpoint, member string, watchSource chan []interface{}) {
 	tc.(*testingEndpoint).watchLck.Lock()
-	tc.(*testingEndpoint).watchTicker = watchTicker
+	tc.(*testingEndpoint).watchSources[member] = watchSource
 	tc.(*testingEndpoint).watchLck.Unlock()
 }
 
@@ -78,31 +80,77 @@
 	return tc.(*testingEndpoint).callArgs
 }
 
+type watchCancel struct {
+	done      chan struct{}
+	cancelled chan struct{}
+	lck       sync.Mutex
+	member    string
+}
+
+// this waits for actual cancelllation for test convenience
+func (wc *watchCancel) Cancel() error {
+	wc.lck.Lock()
+	defer wc.lck.Unlock()
+	if wc.cancelled != nil {
+		close(wc.cancelled)
+		wc.cancelled = nil
+		<-wc.done
+	}
+	return nil
+}
+
 // See Endpoint's WatchSignal. This WatchSignal will check its condition to
 // decide whether to return an error, or provide each of its return values
-func (tc *testingEndpoint) WatchSignal(member string, f func(...interface{}), d func()) error {
+// or values from the previously set watchSource for member.
+func (tc *testingEndpoint) WatchSignal(member string, f func(...interface{}), d func()) (bus.Cancellable, error) {
 	if tc.callCond.OK() {
+		cancelled := make(chan struct{})
+		done := make(chan struct{})
 		go func() {
-			for _, v := range tc.retvals {
-				f(v...)
-				tc.watchLck.RLock()
-				ticker := tc.watchTicker
-				tc.watchLck.RUnlock()
-				if ticker != nil {
-					_, ok := <-ticker
+			tc.watchLck.RLock()
+			source := tc.watchSources[member]
+			tc.watchLck.RUnlock()
+			if source == nil {
+				tc.usedLck.Lock()
+				idx := tc.used
+				tc.used++
+				tc.usedLck.Unlock()
+				source = make(chan []interface{})
+				go func() {
+				Feed:
+					for _, v := range tc.retvals[idx:] {
+						select {
+						case source <- v:
+						case <-cancelled:
+							break Feed
+						}
+						select {
+						case <-time.After(10 * time.Millisecond):
+						case <-cancelled:
+							break Feed
+						}
+					}
+					close(source)
+				}()
+			}
+		Receive:
+			for {
+				select {
+				case v, ok := <-source:
 					if !ok {
-						// bail out
-						return
+						break Receive
 					}
-				} else {
-					time.Sleep(10 * time.Millisecond)
+					f(v...)
+				case <-cancelled:
+					break Receive
 				}
 			}
 			d()
+			close(done)
 		}()
-		return nil
+		return &watchCancel{cancelled: cancelled, done: done, member: member}, nil
 	} else {
-		return errors.New("no way")
+		return nil, errors.New("no way")
 	}
 }
 
@@ -116,20 +164,24 @@
 	if tc.callCond.OK() {
 		expected := len(rvs)
 		var provided int
-		if len(tc.retvals) == 0 {
+		tc.usedLck.Lock()
+		idx := tc.used
+		tc.used++
+		tc.usedLck.Unlock()
+		if len(tc.retvals) <= idx {
 			if expected != 0 {
 				panic("No return values provided!")
 			}
 			provided = 0
 		} else {
-			provided = len(tc.retvals[0])
+			provided = len(tc.retvals[idx])
 		}
 		if provided != expected {
 			return errors.New("provided/expected return vals mismatch")
 		}
 		if provided != 0 {
 			x := dbus.NewMethodCallMessage("", "", "", "")
-			err := x.AppendArgs(tc.retvals[0]...)
+			err := x.AppendArgs(tc.retvals[idx]...)
 			if err != nil {
 				return err
 			}

=== modified file 'bus/testing/testing_endpoint_test.go'
--- bus/testing/testing_endpoint_test.go	2014-07-04 23:00:42 +0000
+++ bus/testing/testing_endpoint_test.go	2015-03-06 13:26:11 +0000
@@ -17,11 +17,13 @@
 package testing
 
 import (
+	"testing"
+	"time"
+
 	. "launchpad.net/gocheck"
+
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/testing/condition"
-	"testing"
-	"time"
 )
 
 // hook up gocheck
@@ -100,8 +102,9 @@
 	var m, n uint32 = 42, 17
 	endp := NewTestingEndpoint(nil, condition.Work(true), m, n)
 	ch := make(chan uint32)
-	e := endp.WatchSignal("what", func(us ...interface{}) { ch <- us[0].(uint32) }, func() { close(ch) })
-	c.Check(e, IsNil)
+	w, e := endp.WatchSignal("which", func(us ...interface{}) { ch <- us[0].(uint32) }, func() { close(ch) })
+	c.Assert(e, IsNil)
+	defer w.Cancel()
 	c.Check(<-ch, Equals, m)
 	c.Check(<-ch, Equals, n)
 }
@@ -110,8 +113,9 @@
 func (s *TestingEndpointSuite) TestWatchDestructor(c *C) {
 	endp := NewTestingEndpoint(nil, condition.Work(true))
 	ch := make(chan uint32)
-	e := endp.WatchSignal("what", func(us ...interface{}) {}, func() { close(ch) })
-	c.Check(e, IsNil)
+	w, e := endp.WatchSignal("what", func(us ...interface{}) {}, func() { close(ch) })
+	c.Assert(e, IsNil)
+	defer w.Cancel()
 	_, ok := <-ch
 	c.Check(ok, Equals, false)
 }
@@ -130,25 +134,28 @@
 // Test that WatchSignal() with a negative condition returns an error.
 func (s *TestingEndpointSuite) TestWatchFails(c *C) {
 	endp := NewTestingEndpoint(nil, condition.Work(false))
-	e := endp.WatchSignal("what", func(us ...interface{}) {}, func() {})
+	w, e := endp.WatchSignal("what", func(us ...interface{}) {}, func() {})
 	c.Check(e, NotNil)
+	c.Check(w, IsNil)
 }
 
-// Test WatchSignal can use the WatchTicker instead of a timeout (if
+// Test WatchSignal can use a watchSource instead of a timeout and retvals (if
 // the former is not nil)
-func (s *TestingEndpointSuite) TestWatchTicker(c *C) {
-	watchTicker := make(chan bool, 3)
-	watchTicker <- true
-	watchTicker <- true
-	watchTicker <- true
+func (s *TestingEndpointSuite) TestWatchSources(c *C) {
+	watchTicker := make(chan []interface{}, 3)
+	watchTicker <- []interface{}{true}
+	watchTicker <- []interface{}{true}
+	watchTicker <- []interface{}{true}
 	c.Assert(len(watchTicker), Equals, 3)
 
 	endp := NewTestingEndpoint(nil, condition.Work(true), 0, 0)
-	SetWatchTicker(endp, watchTicker)
+	SetWatchSource(endp, "what", watchTicker)
 	ch := make(chan int)
-	e := endp.WatchSignal("what", func(us ...interface{}) {}, func() { close(ch) })
-	c.Check(e, IsNil)
+	w, e := endp.WatchSignal("what", func(us ...interface{}) {}, func() { close(ch) })
+	c.Assert(e, IsNil)
+	defer w.Cancel()
 
+	close(watchTicker)
 	// wait for the destructor to be called
 	select {
 	case <-time.Tick(10 * time.Millisecond):
@@ -156,8 +163,21 @@
 	case <-ch:
 	}
 
-	// now if all went well, the ticker will have been tuck twice.
-	c.Assert(len(watchTicker), Equals, 1)
+	// now if all went well, the ticker will have been exhausted.
+	c.Assert(len(watchTicker), Equals, 0)
+}
+
+// Test that WatchSignal() calls the destructor callback when canceled.
+func (s *TestingEndpointSuite) TestWatchCancel(c *C) {
+	endp := NewTestingEndpoint(nil, condition.Work(true))
+	ch := make(chan uint32)
+	w, e := endp.WatchSignal("what", func(us ...interface{}) {}, func() { close(ch) })
+	c.Assert(e, IsNil)
+	defer w.Cancel()
+	SetWatchSource(endp, "what", make(chan []interface{}))
+	w.Cancel()
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
 }
 
 // Tests that GetProperty() works

=== modified file 'client/client.go'
--- client/client.go	2015-01-26 21:00:27 +0000
+++ client/client.go	2015-03-06 13:26:11 +0000
@@ -280,8 +280,10 @@
 
 // takeTheBus starts the connection(s) to D-Bus and sets up associated event channels
 func (client *PushClient) takeTheBus() error {
-	go connectivity.ConnectedState(client.connectivityEndp,
-		client.config.ConnectivityConfig, client.log, client.connCh)
+	fmt.Println("FOO")
+	cs := connectivity.New(client.connectivityEndp,
+		client.config.ConnectivityConfig, client.log)
+	go cs.Track(client.connCh)
 	util.NewAutoRedialer(client.systemImageEndp).Redial()
 	sysimg := systemimage.New(client.systemImageEndp, client.log)
 	info, err := sysimg.Info()

=== modified file 'client/client_test.go'
--- client/client_test.go	2015-02-06 13:09:16 +0000
+++ client/client_test.go	2015-03-06 13:26:11 +0000
@@ -31,6 +31,7 @@
 	"testing"
 	"time"
 
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
 
 	"launchpad.net/ubuntu-push/accounts"
@@ -205,12 +206,7 @@
 }
 
 func (cs *clientSuite) TearDownTest(c *C) {
-	//fmt.Println("GOROUTINE# ", runtime.NumGoroutine())
-	/*
-	   var x [16*1024]byte
-	   sz := runtime.Stack(x[:], true)
-	   fmt.Println(string(x[:sz]))
-	*/
+	//helpers.DumpGoroutines()
 }
 
 type sqlientSuite struct{ clientSuite }
@@ -657,13 +653,19 @@
 	// testing endpoints
 	cCond := condition.Fail2Work(7)
 	cEndp := testibus.NewTestingEndpoint(cCond, condition.Work(true),
-		uint32(networkmanager.ConnectedGlobal),
+		uint32(networkmanager.Connecting),
+		dbus.ObjectPath("hello"),
+		uint32(networkmanager.Connecting),
+		dbus.ObjectPath("hello"),
 	)
 	siCond := condition.Fail2Work(2)
 	siEndp := testibus.NewMultiValuedTestingEndpoint(siCond, condition.Work(true), []interface{}{int32(101), "mako", "daily", "Unknown", map[string]string{}})
-	tickerCh := make(chan bool)
-	testibus.SetWatchTicker(cEndp, tickerCh)
+	tickerCh := make(chan []interface{})
+	nopTickerCh := make(chan []interface{})
+	testibus.SetWatchSource(cEndp, "StateChanged", tickerCh)
+	testibus.SetWatchSource(cEndp, "PropertiesChanged", nopTickerCh)
 	defer close(tickerCh)
+	defer close(nopTickerCh)
 	// ok, create the thing
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
@@ -679,6 +681,7 @@
 	c.Assert(cli.takeTheBus(), IsNil)
 
 	c.Check(takeNextBool(cli.connCh), Equals, false)
+	tickerCh <- []interface{}{uint32(networkmanager.ConnectedGlobal)}
 	c.Check(takeNextBool(cli.connCh), Equals, true)
 	// the connectivity endpoint retried until connected
 	c.Check(cCond.OK(), Equals, true)

=== modified file 'client/service/postal.go'
--- client/service/postal.go	2015-01-21 17:21:42 +0000
+++ client/service/postal.go	2015-03-06 13:26:11 +0000
@@ -24,6 +24,7 @@
 	"code.google.com/p/go-uuid/uuid"
 
 	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/bus/accounts"
 	"launchpad.net/ubuntu-push/bus/emblemcounter"
 	"launchpad.net/ubuntu-push/bus/haptic"
 	"launchpad.net/ubuntu-push/bus/notifications"
@@ -75,6 +76,7 @@
 	// the endpoints are only exposed for testing from client
 	// XXX: uncouple some more so this isn't necessary
 	EmblemCounterEndp bus.Endpoint
+	AccountsEndp      bus.Endpoint
 	HapticEndp        bus.Endpoint
 	NotificationsEndp bus.Endpoint
 	UnityGreeterEndp  bus.Endpoint
@@ -82,6 +84,7 @@
 	// presenters:
 	Presenters    []Presenter
 	emblemCounter *emblemcounter.EmblemCounter
+	accounts      accounts.Accounts
 	haptic        *haptic.Haptic
 	notifications *notifications.RawNotifications
 	sound         *sounds.Sound
@@ -117,6 +120,7 @@
 	svc.fallbackSound = setup.FallbackSound
 	svc.NotificationsEndp = bus.SessionBus.Endpoint(notifications.BusAddress, log)
 	svc.EmblemCounterEndp = bus.SessionBus.Endpoint(emblemcounter.BusAddress, log)
+	svc.AccountsEndp = bus.SystemBus.Endpoint(accounts.BusAddress, log)
 	svc.HapticEndp = bus.SessionBus.Endpoint(haptic.BusAddress, log)
 	svc.UnityGreeterEndp = bus.SessionBus.Endpoint(unitygreeter.BusAddress, log)
 	svc.WindowStackEndp = bus.SessionBus.Endpoint(windowstack.BusAddress, log)
@@ -158,8 +162,13 @@
 	svc.urlDispatcher = urldispatcher.New(svc.Log)
 	svc.notifications = notifications.Raw(svc.NotificationsEndp, svc.Log)
 	svc.emblemCounter = emblemcounter.New(svc.EmblemCounterEndp, svc.Log)
-	svc.haptic = haptic.New(svc.HapticEndp, svc.Log, svc.fallbackVibration)
-	svc.sound = sounds.New(svc.Log, svc.fallbackSound)
+	svc.accounts = accounts.New(svc.AccountsEndp, svc.Log)
+	err = svc.accounts.Start()
+	if err != nil {
+		return err
+	}
+	svc.haptic = haptic.New(svc.HapticEndp, svc.Log, svc.accounts, svc.fallbackVibration)
+	svc.sound = sounds.New(svc.Log, svc.accounts, svc.fallbackSound)
 	svc.messagingMenu = messaging.New(svc.Log)
 	svc.Presenters = []Presenter{
 		svc.notifications,
@@ -228,6 +237,7 @@
 	}{
 		{"notifications", svc.NotificationsEndp},
 		{"emblemcounter", svc.EmblemCounterEndp},
+		{"accounts", svc.AccountsEndp},
 		{"haptic", svc.HapticEndp},
 		{"unitygreeter", svc.UnityGreeterEndp},
 		{"windowstack", svc.WindowStackEndp},

=== modified file 'client/service/postal_test.go'
--- client/service/postal_test.go	2014-09-09 22:54:04 +0000
+++ client/service/postal_test.go	2015-03-06 13:26:11 +0000
@@ -169,6 +169,8 @@
 	hapticBus       bus.Endpoint
 	unityGreeterBus bus.Endpoint
 	winStackBus     bus.Endpoint
+	accountsBus     bus.Endpoint
+	accountsCh      chan []interface{}
 	fakeLauncher    *fakeHelperLauncher
 	getTempDir      func(string) (string, error)
 	oldIsBlisted    func(*click.AppId) bool
@@ -194,6 +196,7 @@
 	ps.bus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true))
 	ps.notifBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true))
 	ps.counterBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true))
+	ps.accountsBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), map[string]dbus.Variant{"IncomingMessageVibrate": dbus.Variant{true}})
 	ps.hapticBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true))
 	ps.unityGreeterBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), false)
 	ps.winStackBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), []windowstack.WindowsInfo{})
@@ -206,11 +209,15 @@
 		tmpDir := filepath.Join(d, pkgName)
 		return tmpDir, os.MkdirAll(tmpDir, 0700)
 	}
+
+	ps.accountsCh = make(chan []interface{})
+	testibus.SetWatchSource(ps.accountsBus, "PropertiesChanged", ps.accountsCh)
 }
 
 func (ps *postalSuite) TearDownTest(c *C) {
 	isBlacklisted = ps.oldIsBlisted
 	launch_helper.GetTempDir = ps.getTempDir
+	close(ps.accountsCh)
 }
 
 func (ts *trivialPostalSuite) SetUpTest(c *C) {
@@ -227,6 +234,7 @@
 	pst.Bus = ps.bus
 	pst.NotificationsEndp = ps.notifBus
 	pst.EmblemCounterEndp = ps.counterBus
+	pst.AccountsEndp = ps.accountsBus
 	pst.HapticEndp = ps.hapticBus
 	pst.UnityGreeterEndp = ps.unityGreeterBus
 	pst.WindowStackEndp = ps.winStackBus
@@ -544,6 +552,7 @@
 	svc := NewPostalService(ps.cfg, ps.log)
 	svc.Bus = endp
 	svc.EmblemCounterEndp = endp
+	svc.AccountsEndp = ps.accountsBus
 	svc.HapticEndp = endp
 	svc.NotificationsEndp = endp
 	svc.UnityGreeterEndp = ps.unityGreeterBus
@@ -552,6 +561,10 @@
 	svc.fallbackVibration = &launch_helper.Vibration{Pattern: []uint32{1}}
 	c.Assert(svc.Start(), IsNil)
 
+	nopTicker := make(chan []interface{})
+	testibus.SetWatchSource(endp, "ActionInvoked", nopTicker)
+	defer close(nopTicker)
+
 	// Persist is false so we just check the log
 	card := &launch_helper.Card{Icon: "icon-value", Summary: "summary-value", Body: "body-value", Popup: true, Persist: false}
 	vib := json.RawMessage(`true`)
@@ -837,6 +850,10 @@
 }
 
 func (ps *postalSuite) TestBlacklisted(c *C) {
+	ps.winStackBus = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), []windowstack.WindowsInfo{},
+		[]windowstack.WindowsInfo{},
+		[]windowstack.WindowsInfo{},
+		[]windowstack.WindowsInfo{})
 	svc := ps.replaceBuses(NewPostalService(ps.cfg, ps.log))
 	svc.Start()
 	ps.blacklisted = false

=== modified file 'debian/changelog'
--- debian/changelog	2015-02-09 11:08:02 +0000
+++ debian/changelog	2015-03-06 13:26:11 +0000
@@ -1,42 +1,54 @@
+ubuntu-push (0.68-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ John R. Lenton ]
+  * Use settings from org.freedesktop.Accounts for silent mode, when to
+    vibrate, and default sound. [client] (LP: #1426418, LP: #1427702)
+
+  [ Samuele "Yak Shaver of the Year" Pedroni ]
+  * Closing webchecker (avoids leaving goroutines around in testing). [client]
+  * WatchSignal cancelling, and connectivity exposed cancelling, make
+    connectivity start not leave watches behind (more goroutine
+    cleanup). [client]
+  * TestTakeTheBusWorks doesn't block anymore, fixed leaking of
+    webcheckers. [client]
+
+ -- John R. Lenton <[e-mail]>  Fri, 06 Mar 2015 10:50:34 +0000
+
 ubuntu-push (0.67+15.04.20150209-0ubuntu1) vivid; urgency=medium
 
   [ John R. Lenton ]
   * Updated precommit script. [dev]
-
   * Include code examples in docs (instead of repeating). [docs]
+  * Cleanup and improve logging, and make log messages more
+    consistent. [client]
+  * Partially work around bug lp:1390663 in a minimally intrusive way
+    (real fix will have to wait). [client]
+  * Add an explicit check and log message for nil error on webcheck's
+    CopyN. [client]
 
+  [ Samuele Pedroni ]
   * Make tests more robust in the face of go 1.3 [client, server]
-
   * Introduce StartClientAuthFlex for acceptance tests: Start a client
     with auth, take a devId regexp, don't check any client event; support
     connbroken in acceptanceclient. [server]
-
-  * Cleanup and improve logging, and make log messages more
-    consistent. [client]
-
-  * Partially work around bug lp:1390663 in a minimally intrusive way
-    (real fix will have to wait). [client]
-
+  * Clean up goroutines in tests. [client]
+  * Workaround gc issue with 1.3 and 32 bits. Fixes FTBFS. [client]
+
+  [ Bret Barker ]
   * Add SIGQUIT handler to spit out stack dumps; more logging
     tweaks. [client, server]
+  * Log line nums, enabled when logLevel = debug. [client server]
 
+  [ Roberto Alsina ]
   * Adds a couple of buttons to exercise more APIs, version bump to
     0.44. [sample app]
 
+  [ Guillermo Gonzalez ]
   * Add APIError to server/acceptance/kit that includes the body for
     debugging. [server]
-
   * Add DisableKeepAlives and MaxIdleConnsPerHost to the APIClient
     SetupClient method. [server]
 
-  * Clean up goroutines in tests. [client]
-
-  * Add an explicit check and log message for nil error on webcheck's CopyN. [client]
-
-  * Log line nums, enabled when logLevel = debug. [client server]
-
-  * Workaround gc issue with 1.3 and 32 bits. Fixes FTBFS. [client]
-
  -- Ubuntu daily release <[e-mail]>  Mon, 09 Feb 2015 11:08:02 +0000
 
 ubuntu-push (0.66+15.04.20141211-0ubuntu1) vivid; urgency=medium

=== modified file 'sounds/sounds.go'
--- sounds/sounds.go	2014-08-08 09:03:42 +0000
+++ sounds/sounds.go	2015-03-06 13:26:11 +0000
@@ -25,6 +25,7 @@
 
 	"launchpad.net/go-xdg/v0"
 
+	"launchpad.net/ubuntu-push/bus/accounts"
 	"launchpad.net/ubuntu-push/click"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
@@ -33,15 +34,17 @@
 type Sound struct {
 	player   string
 	log      logger.Logger
+	acc      accounts.Accounts
 	fallback string
 	dataDirs func() []string
 	dataFind func(string) (string, error)
 }
 
-func New(log logger.Logger, fallback string) *Sound {
+func New(log logger.Logger, acc accounts.Accounts, fallback string) *Sound {
 	return &Sound{
 		player:   "paplay",
 		log:      log,
+		acc:      acc,
 		fallback: fallback,
 		dataDirs: xdg.Data.Dirs,
 		dataFind: xdg.Data.Find,
@@ -53,7 +56,17 @@
 		panic("please check notification is not nil before calling present")
 	}
 
-	sound := notification.Sound(snd.fallback)
+	if snd.acc.SilentMode() {
+		snd.log.Debugf("[%s] no sounds: silent mode on.", nid)
+		return false
+	}
+
+	fallback := snd.acc.MessageSoundFile()
+	if fallback == "" {
+		fallback = snd.fallback
+	}
+
+	sound := notification.Sound(fallback)
 	if sound == "" {
 		snd.log.Debugf("[%s] notification has no Sound: %#v", nid, sound)
 		return false

=== modified file 'sounds/sounds_test.go'
--- sounds/sounds_test.go	2014-08-08 09:03:42 +0000
+++ sounds/sounds_test.go	2015-03-06 13:26:11 +0000
@@ -36,25 +36,42 @@
 type soundsSuite struct {
 	log *helpers.TestLogger
 	app *click.AppId
+	acc *mockAccounts
 }
 
 var _ = Suite(&soundsSuite{})
 
+type mockAccounts struct {
+	vib bool
+	sil bool
+	snd string
+	err error
+}
+
+func (m *mockAccounts) Start() error             { return m.err }
+func (m *mockAccounts) Cancel() error            { return m.err }
+func (m *mockAccounts) SilentMode() bool         { return m.sil }
+func (m *mockAccounts) Vibrate() bool            { return m.vib }
+func (m *mockAccounts) MessageSoundFile() string { return m.snd }
+func (m *mockAccounts) String() string           { return "<mockAccounts>" }
+
 func (ss *soundsSuite) SetUpTest(c *C) {
 	ss.log = helpers.NewTestLogger(c, "debug")
 	ss.app = clickhelp.MustParseAppId("com.example.test_test_0")
+	ss.acc = &mockAccounts{true, false, "", nil}
 }
 
 func (ss *soundsSuite) TestNew(c *C) {
-	s := New(ss.log, "foo")
+	s := New(ss.log, ss.acc, "foo")
 	c.Check(s.log, Equals, ss.log)
 	c.Check(s.player, Equals, "paplay")
 	c.Check(s.fallback, Equals, "foo")
+	c.Check(s.acc, Equals, ss.acc)
 }
 
 func (ss *soundsSuite) TestPresent(c *C) {
 	s := &Sound{
-		player: "echo", log: ss.log,
+		player: "echo", log: ss.log, acc: ss.acc,
 		dataFind: func(s string) (string, error) { return s, nil },
 	}
 
@@ -65,7 +82,7 @@
 
 func (ss *soundsSuite) TestPresentSimple(c *C) {
 	s := &Sound{
-		player: "echo", log: ss.log,
+		player: "echo", log: ss.log, acc: ss.acc,
 		dataFind: func(s string) (string, error) { return s, nil },
 		fallback: "fallback",
 	}
@@ -73,12 +90,18 @@
 	c.Check(s.Present(ss.app, "",
 		&launch_helper.Notification{RawSound: json.RawMessage(`true`)}), Equals, true)
 	c.Check(ss.log.Captured(), Matches, `(?sm).* playing sound com.example.test/fallback using echo`)
+	ss.acc.snd = "from-prefs"
+	ss.log.ResetCapture()
+	c.Check(s.Present(ss.app, "",
+		&launch_helper.Notification{RawSound: json.RawMessage(`true`)}), Equals, true)
+	c.Check(ss.log.Captured(), Matches, `(?sm).* playing sound com.example.test/from-prefs using echo`)
 }
 
 func (ss *soundsSuite) TestPresentFails(c *C) {
 	s := &Sound{
 		player:   "/",
 		log:      ss.log,
+		acc:      ss.acc,
 		dataFind: func(string) (string, error) { return "", errors.New("nope") },
 		dataDirs: func() []string { return []string{""} },
 	}
@@ -107,6 +130,7 @@
 	s := &Sound{
 		player:   "/",
 		log:      ss.log,
+		acc:      ss.acc,
 		dataFind: func(string) (string, error) { return "", errors.New("nope") },
 		dataDirs: func() []string { return []string{""} },
 	}
@@ -120,6 +144,7 @@
 	s := &Sound{
 		player:   "/",
 		log:      ss.log,
+		acc:      ss.acc,
 		dataFind: func(string) (string, error) { return "", errors.New("nope") },
 		dataDirs: func() []string { return []string{""} },
 	}
@@ -128,3 +153,19 @@
 	c.Check(err, IsNil)
 	c.Check(sound, Equals, "bar")
 }
+
+func (ss *soundsSuite) TestSkipIfSilentMode(c *C) {
+	s := &Sound{
+		player:   "echo",
+		log:      ss.log,
+		acc:      ss.acc,
+		fallback: "fallback",
+		dataFind: func(s string) (string, error) { return s, nil },
+	}
+
+	c.Check(s.Present(ss.app, "",
+		&launch_helper.Notification{RawSound: json.RawMessage(`true`)}), Equals, true)
+	ss.acc.sil = true
+	c.Check(s.Present(ss.app, "",
+		&launch_helper.Notification{RawSound: json.RawMessage(`true`)}), Equals, false)
+}

=== modified file 'testing/helpers.go'
--- testing/helpers.go	2015-01-22 09:52:07 +0000
+++ testing/helpers.go	2015-03-06 13:26:11 +0000
@@ -170,3 +170,12 @@
 	}
 	return purl
 }
+
+// DumpGoroutines dumps current goroutines.
+func DumpGoroutines() {
+	var buf [64 * 1024]byte
+	sz := runtime.Stack(buf[:], true)
+	dump := string(buf[:sz])
+	fmt.Println(dump)
+	fmt.Println("#goroutines#", strings.Count("\n"+dump, "\ngoroutine "))
+}