Merge lp:~pedronis/ubuntu-push/automatic-into-krillin-rtm into lp:ubuntu-push/krillin-rtm

[Samuele Pedroni]

[Bret Barker, Samuele Pedroni]
  * Partial fix of lp:1390663
     - Remove SessionStateSettle sleep on wake, + more debug logging.
     - Don't hold a lock for a long time on handleErrConn, trigger
       autoRedial on Error more actively.

  [John Lenton]
  * Refactor code maintaining session (better fix for lp:1390663)
  * Prune the XDG path from the beginning of accounts-set sound files.
  * Use accounts' settings from sound and haptic.
  * Add an explicit check and log message for nil error on webcheck's
    CopyN.
  * Move logging to info; improve logging of legacy helper errors;
    switch some logs to error from debug.

  [Bret Barker]
  * Add SIGQUIT handler to spit out stack dumps; more logging
    tweaks. [client, server]
  * Log line nums, enabled when logLevel = debug.

  [Samuele Pedroni]
  * Unit test improvements
  * Workaround gc issue with 1.3 and 32 bits.

  [Roberto Ralsina]
  * Example and docs improvements.

  [ Guillermo Gonzalez ]
  * When The server reply 401 on /register, make the DBus call to Register
    return ErrBadAuth instead of ErrBadRequest.
  * Fix click hook for legacy apps
  * Add ClearCookie method to the session and call it from handleAccountsChange.
  * click.AppId.SymbolicIcon() now tries to use X-Ubuntu-SymbolicIcon
    and then fallback to icon+"-symbolic"

[Roberto Alsina (ralsina)]

review: Approve

=== modified file '.precommit'
--- .precommit	2014-01-23 10:03:39 +0000
+++ .precommit	2015-03-26 16:42:21 +0000
@@ -5,25 +5,27 @@
 # And put this here-document in ~/.bazaar/plugins/precommit_script.py:
 <<EOF
 import os
-import subprocess
-from bzrlib.mutabletree import MutableTree
-from bzrlib import errors
-
-def start_commit_hook(*_):
-    """This hook will execute '.precommit' script from root path of the bazaar
-    branch. Commit will be canceled if precommit fails."""
-
-    # this hook only makes sense if a precommit file exist.
-    if not os.path.exists(".precommit"):
-        return
-    try:
-        subprocess.check_call(os.path.abspath(".precommit"))
-    # if precommit fails (process return not zero) cancel commit.
-    except subprocess.CalledProcessError:
-        raise errors.BzrError("pre commit check failed.")
-
-MutableTree.hooks.install_named_hook('start_commit', start_commit_hook,
-                                     'Run "precommit" script on start_commit')
+
+if not os.getenv("SKIP_COMMIT_HOOK"):
+    import subprocess
+    from bzrlib.mutabletree import MutableTree
+    from bzrlib import errors
+
+    def start_commit_hook(*_):
+        """This hook will execute '.precommit' script from root path of the bazaar
+        branch. Commit will be canceled if precommit fails."""
+
+        # this hook only makes sense if a precommit file exist.
+        if not os.path.exists(".precommit"):
+            return
+        try:
+            subprocess.check_call(os.path.abspath(".precommit"))
+        # if precommit fails (process return not zero) cancel commit.
+        except subprocess.CalledProcessError:
+            raise errors.BzrError("pre commit check failed (set SKIP_COMMIT_HOOK to skip).")
+
+    MutableTree.hooks.install_named_hook('start_commit', start_commit_hook,
+                                         'Run "precommit" script on start_commit')
 EOF
 
 make check-format # or whatever

=== modified file 'PACKAGE_DEPS'
--- PACKAGE_DEPS	2014-09-05 10:48:36 +0000
+++ PACKAGE_DEPS	2015-03-26 16:42:21 +0000
@@ -12,3 +12,4 @@
 libclick-0.4-dev
 liburl-dispatcher1-dev
 libaccounts-glib-dev
+system-image-dbus

=== 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-26 16:42:21 +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-26 16:42:21 +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 17:34:18 +0000
+++ bus/connectivity/connectivity.go	2015-03-26 16:42:21 +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-22 17:34:18 +0000
+++ bus/connectivity/connectivity_test.go	2015-03-26 16:42:21 +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-01-22 17:34:18 +0000
+++ bus/connectivity/webchecker.go	2015-03-26 16:42:21 +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 {
@@ -72,8 +74,11 @@
 	hash := md5.New()
 	_, err = io.CopyN(hash, response.Body, 1024)
 	if err != io.EOF {
-		wb.log.Errorf("reading %s, expecting EOF, got: %v",
-			wb.url, err)
+		if err == nil {
+			wb.log.Errorf("reading %s, but response body is larger than 1k.", wb.url)
+		} else {
+			wb.log.Errorf("reading %s, expecting EOF, got: %v", wb.url, err)
+		}
 		ch <- false
 		return
 	}
@@ -86,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	2014-03-20 12:24:33 +0000
+++ bus/connectivity/webchecker_test.go	2015-03-26 16:42:21 +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
@@ -18,7 +18,6 @@
 
 import (
 	. "launchpad.net/gocheck"
-	"launchpad.net/ubuntu-push/logger"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/util"
 	"net/http"
@@ -28,7 +27,7 @@
 
 type WebcheckerSuite struct {
 	timeouts []time.Duration
-	log      logger.Logger
+	log      *helpers.TestLogger
 }
 
 var _ = Suite(&WebcheckerSuite{})
@@ -82,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)
@@ -90,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)
@@ -101,9 +102,11 @@
 	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)
+	c.Check(s.log.Captured(), Matches, "(?ism).*content mismatch.*")
 }
 
 // Webchecker sends false if the download is too big
@@ -112,9 +115,11 @@
 	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)
+	c.Check(s.log.Captured(), Matches, "(?ism).*larger than 1k.*")
 }
 
 // Webchecker sends false if the request timeouts
@@ -130,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 17:34:18 +0000
+++ bus/endpoint.go	2015-03-26 16:42:21 +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-26 16:42:21 +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-26 16:42:21 +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 17:34:18 +0000
+++ bus/networkmanager/networkmanager.go	2015-03-26 16:42:21 +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-26 16:42:21 +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 17:34:18 +0000
+++ bus/notifications/raw.go	2015-03-26 16:42:21 +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-26 16:42:21 +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	2014-07-04 23:00:42 +0000
+++ bus/testing/testing_endpoint.go	2015-03-26 16:42:21 +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,27 +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 {
-					<-ticker
-				} else {
-					time.Sleep(10 * time.Millisecond)
+			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 {
+						break Receive
+					}
+					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")
 	}
 }
 
@@ -112,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-26 16:42:21 +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 'click/cappinfo/cappinfo.go'
--- click/cappinfo/cappinfo.go	2014-07-08 23:23:13 +0000
+++ click/cappinfo/cappinfo.go	2015-03-26 16:42:21 +0000
@@ -37,6 +37,26 @@
    g_free (desktop_id);
    return filename;
 }
+
+gchar* app_symbolic_icon_from_desktop_id (gchar* desktop_id) {
+    gchar* x_symbolic_icon;
+    GIcon* symbolic_icon;
+    GDesktopAppInfo* app_info = g_desktop_app_info_new (desktop_id);
+    if (app_info != NULL) {
+        if((x_symbolic_icon = g_desktop_app_info_get_string(app_info, "X-Ubuntu-SymbolicIcon"))) {
+            GFile *file;
+            file = g_file_new_for_path(x_symbolic_icon);
+            symbolic_icon = g_file_icon_new (file);
+            g_object_unref (file);
+            g_free(x_symbolic_icon);
+            g_object_unref (app_info);
+            return g_icon_to_string(symbolic_icon);
+        }
+        g_object_unref (app_info);
+    }
+    g_free (desktop_id);
+    return NULL;
+}
 */
 import "C"
 
@@ -45,3 +65,14 @@
 	defer C.g_free((C.gpointer)(name))
 	return C.GoString((*C.char)(name))
 }
+
+func appSymbolicIconFromDesktopId(desktopId string) string {
+	name := C.app_symbolic_icon_from_desktop_id((*C.gchar)(C.CString(desktopId)))
+	if name == nil {
+		return ""
+	}
+	defer C.g_free((C.gpointer)(name))
+	return C.GoString((*C.char)(name))
+}
+
+var AppSymbolicIconFromDesktopId = appSymbolicIconFromDesktopId

=== modified file 'click/cclick/cclick.go'
--- click/cclick/cclick.go	2014-07-07 22:04:30 +0000
+++ click/cclick/cclick.go	2015-03-26 16:42:21 +0000
@@ -51,6 +51,7 @@
 	}
 	ccu.cref = cref
 	runtime.SetFinalizer(holder, func(interface{}) {
+		ccu.cref = nil // 1.3 gc gets confused otherwise
 		C.g_object_unref((C.gpointer)(cref))
 	})
 	return nil

=== modified file 'click/click.go'
--- click/click.go	2014-08-15 10:32:51 +0000
+++ click/click.go	2015-03-26 16:42:21 +0000
@@ -146,6 +146,10 @@
 var symbolic = _symbolic
 
 func (app *AppId) SymbolicIcon() string {
+	symbolicIcon := cappinfo.AppSymbolicIconFromDesktopId(app.DesktopId())
+	if symbolicIcon != "" {
+		return symbolicIcon
+	}
 	return symbolic(app.Icon())
 }
 

=== modified file 'click/click_test.go'
--- click/click_test.go	2014-08-15 10:32:51 +0000
+++ click/click_test.go	2015-03-26 16:42:21 +0000
@@ -22,6 +22,8 @@
 	"testing"
 
 	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/click/cappinfo"
 )
 
 func TestClick(t *testing.T) { TestingT(t) }
@@ -200,3 +202,15 @@
 	c.Assert(err, IsNil)
 	c.Check(app.SymbolicIcon(), Equals, "xyzzy")
 }
+
+func (s *clickSuite) TestSymbolicFromDesktopFile(c *C) {
+	orig := cappinfo.AppSymbolicIconFromDesktopId
+	cappinfo.AppSymbolicIconFromDesktopId = func(desktopId string) string {
+		return "/foo/symbolic"
+	}
+	defer func() {
+		cappinfo.AppSymbolicIconFromDesktopId = orig
+	}()
+	app, _ := ParseAppId("com.ubuntu.clock_clock_1.2")
+	c.Check(app.SymbolicIcon(), Equals, "/foo/symbolic")
+}

=== modified file 'client/client.go'
--- client/client.go	2015-01-22 17:34:18 +0000
+++ client/client.go	2015-03-26 16:42:21 +0000
@@ -115,8 +115,7 @@
 	systemImageEndp    bus.Endpoint
 	systemImageInfo    *systemimage.InfoResult
 	connCh             chan bool
-	hasConnectivity    bool
-	session            *session.ClientSession
+	session            session.ClientSession
 	sessionConnectedCh chan uint32
 	pushService        PushService
 	postalService      PostalService
@@ -125,16 +124,20 @@
 	installedChecker   click.InstalledChecker
 	poller             poller.Poller
 	accountsCh         <-chan accounts.Changed
+	// session-side channels
+	broadcastCh     chan *session.BroadcastNotification
+	notificationsCh chan session.AddressedNotification
 }
 
 // Creates a new Ubuntu Push Notifications client-side daemon that will use
 // the given configuration file.
 func NewPushClient(configPath string, leveldbPath string) *PushClient {
-	client := new(PushClient)
-	client.configPath = configPath
-	client.leveldbPath = leveldbPath
-
-	return client
+	return &PushClient{
+		configPath:      configPath,
+		leveldbPath:     leveldbPath,
+		broadcastCh:     make(chan *session.BroadcastNotification),
+		notificationsCh: make(chan session.AddressedNotification),
+	}
 }
 
 var newIdentifier = identifier.New
@@ -206,6 +209,8 @@
 		AuthGetter:       client.getAuthorization,
 		AuthURL:          client.config.SessionURL,
 		AddresseeChecker: client,
+		BroadcastCh:      client.broadcastCh,
+		NotificationsCh:  client.notificationsCh,
 	}
 }
 
@@ -280,8 +285,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()
@@ -306,6 +313,7 @@
 		return err
 	}
 	client.session = sess
+	sess.KeepConnection()
 	client.poller = poller.New(client.derivePollerSetup())
 	return nil
 }
@@ -374,29 +382,6 @@
 	}
 }
 
-// handleConnState deals with connectivity events
-func (client *PushClient) handleConnState(hasConnectivity bool) {
-	client.log.Debugf("handleConnState: %v", hasConnectivity)
-	if client.hasConnectivity == hasConnectivity {
-		// nothing to do!
-		return
-	}
-	client.hasConnectivity = hasConnectivity
-	client.session.Close()
-	if hasConnectivity {
-		client.session.AutoRedial(client.sessionConnectedCh)
-	}
-}
-
-// handleErr deals with the session erroring out of its loop
-func (client *PushClient) handleErr(err error) {
-	// if we're not connected, we don't really care
-	client.log.Errorf("session exited: %s", err)
-	if client.hasConnectivity {
-		client.session.AutoRedial(client.sessionConnectedCh)
-	}
-}
-
 // filterBroadcastNotification finds out if the notification is about an actual
 // upgrade for the device. It expects msg.Decoded entries to look
 // like:
@@ -467,28 +452,18 @@
 	return nil
 }
 
-// handleAccountsChange deals with the user adding or removing (or
-// changing) the u1 account used to auth
-func (client *PushClient) handleAccountsChange() {
-	client.log.Infof("U1 account changed; restarting session")
-	client.session.ClearCookie()
-	client.session.Close()
-}
-
 // doLoop connects events with their handlers
-func (client *PushClient) doLoop(connhandler func(bool), bcasthandler func(*session.BroadcastNotification) error, ucasthandler func(session.AddressedNotification) error, errhandler func(error), unregisterhandler func(*click.AppId), accountshandler func()) {
+func (client *PushClient) doLoop(connhandler func(bool), bcasthandler func(*session.BroadcastNotification) error, ucasthandler func(session.AddressedNotification) error, unregisterhandler func(*click.AppId), accountshandler func()) {
 	for {
 		select {
 		case <-client.accountsCh:
 			accountshandler()
 		case state := <-client.connCh:
 			connhandler(state)
-		case bcast := <-client.session.BroadcastCh:
+		case bcast := <-client.broadcastCh:
 			bcasthandler(bcast)
-		case aucast := <-client.session.NotificationsCh:
+		case aucast := <-client.notificationsCh:
 			ucasthandler(aucast)
-		case err := <-client.session.ErrCh:
-			errhandler(err)
 		case count := <-client.sessionConnectedCh:
 			client.log.Debugf("session connected after %d attempts", count)
 		case app := <-client.unregisterCh:
@@ -510,12 +485,11 @@
 
 // Loop calls doLoop with the "real" handlers
 func (client *PushClient) Loop() {
-	client.doLoop(client.handleConnState,
+	client.doLoop(client.session.HasConnectivity,
 		client.handleBroadcastNotification,
 		client.handleUnicastNotification,
-		client.handleErr,
 		client.handleUnregister,
-		client.handleAccountsChange,
+		client.session.ResetCookie,
 	)
 }
 

=== modified file 'client/client_test.go'
--- client/client_test.go	2015-01-22 17:34:18 +0000
+++ client/client_test.go	2015-03-26 16:42:21 +0000
@@ -27,9 +27,11 @@
 	"os"
 	"path/filepath"
 	"reflect"
+	//"runtime"
 	"testing"
 	"time"
 
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
 
 	"launchpad.net/ubuntu-push/accounts"
@@ -41,7 +43,6 @@
 	clickhelp "launchpad.net/ubuntu-push/click/testing"
 	"launchpad.net/ubuntu-push/client/service"
 	"launchpad.net/ubuntu-push/client/session"
-	"launchpad.net/ubuntu-push/client/session/seenstate"
 	"launchpad.net/ubuntu-push/config"
 	"launchpad.net/ubuntu-push/identifier"
 	idtesting "launchpad.net/ubuntu-push/identifier/testing"
@@ -203,6 +204,10 @@
 	cs.writeTestConfig(nil)
 }
 
+func (cs *clientSuite) TearDownTest(c *C) {
+	//helpers.DumpGoroutines()
+}
+
 type sqlientSuite struct{ clientSuite }
 
 func (s *sqlientSuite) SetUpSuite(c *C) {
@@ -421,6 +426,8 @@
 		AuthGetter:       func(string) string { return "" },
 		AuthURL:          "xyzzy://",
 		AddresseeChecker: cli,
+		BroadcastCh:      make(chan *session.BroadcastNotification),
+		NotificationsCh:  make(chan session.AddressedNotification),
 	}
 	// sanity check that we are looking at all fields
 	vExpected := reflect.ValueOf(expected)
@@ -434,6 +441,11 @@
 	conf := cli.deriveSessionConfig(info)
 	// compare authGetter by string
 	c.Check(fmt.Sprintf("%#v", conf.AuthGetter), Equals, fmt.Sprintf("%#v", cli.getAuthorization))
+	// channels are ok as long as non-nil
+	conf.BroadcastCh = nil
+	conf.NotificationsCh = nil
+	expected.BroadcastCh = nil
+	expected.NotificationsCh = nil
 	// and set it to nil
 	conf.AuthGetter = nil
 	expected.AuthGetter = nil
@@ -515,10 +527,18 @@
 /*****************************************************************
     derivePollerSetup tests
 ******************************************************************/
+type derivePollerSession struct{}
+
+func (s *derivePollerSession) ResetCookie()                      {}
+func (s *derivePollerSession) State() session.ClientSessionState { return session.Unknown }
+func (s *derivePollerSession) HasConnectivity(bool)              {}
+func (s *derivePollerSession) KeepConnection() error             { return nil }
+func (s *derivePollerSession) StopKeepConnection()               {}
+
 func (cs *clientSuite) TestDerivePollerSetup(c *C) {
 	cs.writeTestConfig(map[string]interface{}{})
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.session = new(session.ClientSession)
+	cli.session = new(derivePollerSession)
 	err := cli.configure()
 	c.Assert(err, IsNil)
 	expected := &poller.PollerSetup{
@@ -647,11 +667,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{}})
-	testibus.SetWatchTicker(cEndp, make(chan bool))
+	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
@@ -667,6 +695,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)
@@ -690,21 +719,6 @@
 }
 
 /*****************************************************************
-    handleErr tests
-******************************************************************/
-
-func (cs *clientSuite) TestHandleErr(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	cli.systemImageInfo = siInfoRes
-	c.Assert(cli.initSessionAndPoller(), IsNil)
-	cs.log.ResetCapture()
-	cli.hasConnectivity = true
-	cli.handleErr(errors.New("bananas"))
-	c.Check(cs.log.Captured(), Matches, ".*session exited.*bananas\n")
-}
-
-/*****************************************************************
     seenStateFactory tests
 ******************************************************************/
 
@@ -712,6 +726,7 @@
 	cli := NewPushClient(cs.configPath, "")
 	ln, err := cli.seenStateFactory()
 	c.Assert(err, IsNil)
+	defer ln.Close()
 	c.Check(fmt.Sprintf("%T", ln), Equals, "*seenstate.memSeenState")
 }
 
@@ -719,63 +734,11 @@
 	cli := NewPushClient(cs.configPath, ":memory:")
 	ln, err := cli.seenStateFactory()
 	c.Assert(err, IsNil)
+	defer ln.Close()
 	c.Check(fmt.Sprintf("%T", ln), Equals, "*seenstate.sqliteSeenState")
 }
 
 /*****************************************************************
-    handleConnState tests
-******************************************************************/
-
-func (cs *clientSuite) TestHandleConnStateD2C(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	cli.systemImageInfo = siInfoRes
-	c.Assert(cli.initSessionAndPoller(), IsNil)
-
-	c.Assert(cli.hasConnectivity, Equals, false)
-	cli.handleConnState(true)
-	c.Check(cli.hasConnectivity, Equals, true)
-	c.Assert(cli.session, NotNil)
-}
-
-func (cs *clientSuite) TestHandleConnStateSame(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	// here we want to check that we don't do anything
-	c.Assert(cli.session, IsNil)
-	c.Assert(cli.hasConnectivity, Equals, false)
-	cli.handleConnState(false)
-	c.Check(cli.session, IsNil)
-
-	cli.hasConnectivity = true
-	cli.handleConnState(true)
-	c.Check(cli.session, IsNil)
-}
-
-func (cs *clientSuite) TestHandleConnStateC2D(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	cli.session, _ = session.NewSession(cli.config.Addr, cli.deriveSessionConfig(nil), cli.deviceId, seenstate.NewSeenState, cs.log)
-	cli.session.Dial()
-	cli.hasConnectivity = true
-
-	// cli.session.State() will be "Error" here, for now at least
-	c.Check(cli.session.State(), Not(Equals), session.Disconnected)
-	cli.handleConnState(false)
-	c.Check(cli.session.State(), Equals, session.Disconnected)
-}
-
-func (cs *clientSuite) TestHandleConnStateC2DPending(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	cli.session, _ = session.NewSession(cli.config.Addr, cli.deriveSessionConfig(nil), cli.deviceId, seenstate.NewSeenState, cs.log)
-	cli.hasConnectivity = true
-
-	cli.handleConnState(false)
-	c.Check(cli.session.State(), Equals, session.Disconnected)
-}
-
-/*****************************************************************
    filterBroadcastNotification tests
 ******************************************************************/
 
@@ -993,7 +956,6 @@
 var nopConn = func(bool) {}
 var nopBcast = func(*session.BroadcastNotification) error { return nil }
 var nopUcast = func(session.AddressedNotification) error { return nil }
-var nopError = func(error) {}
 var nopUnregister = func(*click.AppId) {}
 var nopAcct = func() {}
 
@@ -1006,7 +968,7 @@
 	c.Assert(cli.initSessionAndPoller(), IsNil)
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(func(bool) { ch <- true }, nopBcast, nopUcast, nopError, nopUnregister, nopAcct)
+	go cli.doLoop(func(bool) { ch <- true }, nopBcast, nopUcast, nopUnregister, nopAcct)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -1015,11 +977,11 @@
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSessionAndPoller(), IsNil)
-	cli.session.BroadcastCh = make(chan *session.BroadcastNotification, 1)
-	cli.session.BroadcastCh <- &session.BroadcastNotification{}
+	cli.broadcastCh = make(chan *session.BroadcastNotification, 1)
+	cli.broadcastCh <- &session.BroadcastNotification{}
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, func(_ *session.BroadcastNotification) error { ch <- true; return nil }, nopUcast, nopError, nopUnregister, nopAcct)
+	go cli.doLoop(nopConn, func(_ *session.BroadcastNotification) error { ch <- true; return nil }, nopUcast, nopUnregister, nopAcct)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -1028,24 +990,11 @@
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSessionAndPoller(), IsNil)
-	cli.session.NotificationsCh = make(chan session.AddressedNotification, 1)
-	cli.session.NotificationsCh <- session.AddressedNotification{}
-
-	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, nopBcast, func(session.AddressedNotification) error { ch <- true; return nil }, nopError, nopUnregister, nopAcct)
-	c.Check(takeNextBool(ch), Equals, true)
-}
-
-func (cs *clientSuite) TestDoLoopErr(c *C) {
-	cli := NewPushClient(cs.configPath, cs.leveldbPath)
-	cli.log = cs.log
-	cli.systemImageInfo = siInfoRes
-	c.Assert(cli.initSessionAndPoller(), IsNil)
-	cli.session.ErrCh = make(chan error, 1)
-	cli.session.ErrCh <- nil
-
-	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, nopBcast, nopUcast, func(error) { ch <- true }, nopUnregister, nopAcct)
+	cli.notificationsCh = make(chan session.AddressedNotification, 1)
+	cli.notificationsCh <- session.AddressedNotification{}
+
+	ch := make(chan bool, 1)
+	go cli.doLoop(nopConn, nopBcast, func(session.AddressedNotification) error { ch <- true; return nil }, nopUnregister, nopAcct)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -1058,7 +1007,7 @@
 	cli.unregisterCh <- app1
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, nopBcast, nopUcast, nopError, func(app *click.AppId) { c.Check(app.Original(), Equals, appId1); ch <- true }, nopAcct)
+	go cli.doLoop(nopConn, nopBcast, nopUcast, func(app *click.AppId) { c.Check(app.Original(), Equals, appId1); ch <- true }, nopAcct)
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -1072,7 +1021,7 @@
 	cli.accountsCh = acctCh
 
 	ch := make(chan bool, 1)
-	go cli.doLoop(nopConn, nopBcast, nopUcast, nopError, nopUnregister, func() { ch <- true })
+	go cli.doLoop(nopConn, nopBcast, nopUcast, nopUnregister, func() { ch <- true })
 	c.Check(takeNextBool(ch), Equals, true)
 }
 
@@ -1107,6 +1056,20 @@
     Loop() tests
 ******************************************************************/
 
+type loopSession struct{ hasConn bool }
+
+func (s *loopSession) ResetCookie() {}
+func (s *loopSession) State() session.ClientSessionState {
+	if s.hasConn {
+		return session.Connected
+	} else {
+		return session.Disconnected
+	}
+}
+func (s *loopSession) HasConnectivity(hasConn bool) { s.hasConn = hasConn }
+func (s *loopSession) KeepConnection() error        { return nil }
+func (s *loopSession) StopKeepConnection()          {}
+
 func (cs *clientSuite) TestLoop(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.connCh = make(chan bool)
@@ -1121,8 +1084,7 @@
 
 	c.Assert(cli.initSessionAndPoller(), IsNil)
 
-	cli.session.BroadcastCh = make(chan *session.BroadcastNotification)
-	cli.session.ErrCh = make(chan error)
+	cli.broadcastCh = make(chan *session.BroadcastNotification)
 
 	// we use tick() to make sure things have been through the
 	// event loop at least once before looking at things;
@@ -1130,6 +1092,10 @@
 	// at and the loop itself.
 	tick := func() { cli.sessionConnectedCh <- 42 }
 
+	c.Assert(cli.session, NotNil)
+	cli.session.StopKeepConnection()
+	cli.session = &loopSession{}
+
 	go cli.Loop()
 
 	// sessionConnectedCh to nothing in particular, but it'll help sync this test
@@ -1139,24 +1105,19 @@
 
 	// loop() should have connected:
 	//  * connCh to the connectivity checker
-	c.Check(cli.hasConnectivity, Equals, false)
+	c.Check(cli.session.State(), Equals, session.Disconnected)
 	cli.connCh <- true
 	tick()
-	c.Check(cli.hasConnectivity, Equals, true)
+	c.Check(cli.session.State(), Equals, session.Connected)
 	cli.connCh <- false
 	tick()
-	c.Check(cli.hasConnectivity, Equals, false)
+	c.Check(cli.session.State(), Equals, session.Disconnected)
 
 	//  * session.BroadcastCh to the notifications handler
 	c.Check(d.bcastCount, Equals, 0)
-	cli.session.BroadcastCh <- positiveBroadcastNotification
+	cli.broadcastCh <- positiveBroadcastNotification
 	tick()
 	c.Check(d.bcastCount, Equals, 1)
-
-	//  * session.ErrCh to the error handler
-	cli.session.ErrCh <- nil
-	tick()
-	c.Check(cs.log.Captured(), Matches, "(?ms).*session exited.*")
 }
 
 /*****************************************************************

=== modified file 'client/service/postal.go'
--- client/service/postal.go	2015-01-22 17:34:18 +0000
+++ client/service/postal.go	2015-03-26 16:42:21 +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-26 16:42:21 +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 'client/service/service.go'
--- client/service/service.go	2015-01-22 17:34:18 +0000
+++ client/service/service.go	2015-03-26 16:42:21 +0000
@@ -140,6 +140,8 @@
 		case resp.StatusCode >= http.StatusInternalServerError:
 			// XXX retry on 503
 			return nil, ErrBadServer
+		case resp.StatusCode == http.StatusUnauthorized:
+			return nil, ErrBadAuth
 		default:
 			return nil, ErrBadRequest
 		}

=== modified file 'client/service/service_test.go'
--- client/service/service_test.go	2014-08-06 09:01:59 +0000
+++ client/service/service_test.go	2015-03-26 16:42:21 +0000
@@ -19,6 +19,7 @@
 import (
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -179,7 +180,8 @@
 func (ss *serviceSuite) TestRegistrationWorks(c *C) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		buf := make([]byte, 256)
-		n, e := r.Body.Read(buf)
+		n := r.ContentLength
+		_, e := io.ReadFull(r.Body, buf[:n])
 		c.Assert(e, IsNil)
 		req := registrationRequest{}
 		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
@@ -240,6 +242,23 @@
 	c.Check(err, ErrorMatches, "unable to request registration: .*")
 }
 
+func (ss *serviceSuite) TestManageRegFailsOn401(c *C) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "Unauthorized", 401)
+	}))
+	defer ts.Close()
+	setup := &PushServiceSetup{
+		DeviceId:   "fake-device-id",
+		RegURL:     helpers.ParseURL(ts.URL),
+		AuthGetter: func(string) string { return "tok" },
+	}
+	svc := NewPushService(setup, ss.log)
+	svc.Bus = ss.bus
+	reg, err := svc.register(aPackageOnBus, []interface{}{anAppId}, nil)
+	c.Check(err, Equals, ErrBadAuth)
+	c.Check(reg, IsNil)
+}
+
 func (ss *serviceSuite) TestManageRegFailsOn40x(c *C) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "I'm a teapot", 418)
@@ -277,7 +296,8 @@
 func (ss *serviceSuite) TestManageRegFailsOnBadJSON(c *C) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		buf := make([]byte, 256)
-		n, e := r.Body.Read(buf)
+		n := r.ContentLength
+		_, e := io.ReadFull(r.Body, buf[:n])
 		c.Assert(e, IsNil)
 		req := registrationRequest{}
 		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
@@ -303,7 +323,8 @@
 func (ss *serviceSuite) TestManageRegFailsOnBadJSONDocument(c *C) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		buf := make([]byte, 256)
-		n, e := r.Body.Read(buf)
+		n := r.ContentLength
+		_, e := io.ReadFull(r.Body, buf[:n])
 		c.Assert(e, IsNil)
 		req := registrationRequest{}
 		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
@@ -329,7 +350,8 @@
 func (ss *serviceSuite) TestDBusUnregisterWorks(c *C) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		buf := make([]byte, 256)
-		n, e := r.Body.Read(buf)
+		n := r.ContentLength
+		_, e := io.ReadFull(r.Body, buf[:n])
 		c.Assert(e, IsNil)
 		req := registrationRequest{}
 		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)
@@ -356,7 +378,8 @@
 	invoked := make(chan bool, 1)
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		buf := make([]byte, 256)
-		n, e := r.Body.Read(buf)
+		n := r.ContentLength
+		_, e := io.ReadFull(r.Body, buf[:n])
 		c.Assert(e, IsNil)
 		req := registrationRequest{}
 		c.Assert(json.Unmarshal(buf[:n], &req), IsNil)

=== modified file 'client/session/seenstate/seenstate.go'
--- client/session/seenstate/seenstate.go	2014-05-14 17:42:24 +0000
+++ client/session/seenstate/seenstate.go	2015-03-26 16:42:21 +0000
@@ -28,8 +28,10 @@
 	// GetAll() returns a "simple" map of the current levels.
 	GetAllLevels() (map[string]int64, error)
 	// FilterBySeen filters notifications already seen, keep track
-	// of them as well
+	// of them as well.
 	FilterBySeen([]protocol.Notification) ([]protocol.Notification, error)
+	// Close closes state.
+	Close()
 }
 
 type memSeenState struct {
@@ -58,6 +60,9 @@
 	return acc, nil
 }
 
+func (m *memSeenState) Close() {
+}
+
 var _ SeenState = (*memSeenState)(nil)
 
 // NewSeenState returns an implementation of SeenState that is memory-based and

=== modified file 'client/session/seenstate/sqlseenstate.go'
--- client/session/seenstate/sqlseenstate.go	2014-05-14 17:42:24 +0000
+++ client/session/seenstate/sqlseenstate.go	2015-03-26 16:42:21 +0000
@@ -48,6 +48,11 @@
 	return &sqliteSeenState{db}, nil
 }
 
+// Closes closes the underlying db.
+func (ps *sqliteSeenState) Close() {
+	ps.db.Close()
+}
+
 func (ps *sqliteSeenState) SetLevel(level string, top int64) error {
 	_, err := ps.db.Exec("REPLACE INTO level_map (level, top) VALUES (?, ?)", level, top)
 	if err != nil {

=== modified file 'client/session/seenstate/sqlseenstate_test.go'
--- client/session/seenstate/sqlseenstate_test.go	2014-05-14 17:42:24 +0000
+++ client/session/seenstate/sqlseenstate_test.go	2015-03-26 16:42:21 +0000
@@ -112,6 +112,15 @@
 	c.Check(err, ErrorMatches, "cannot insert .*")
 }
 
+func (s *sqlsSuite) TestClose(c *C) {
+	dir := c.MkDir()
+	filename := dir + "test.db"
+	sqls, err := NewSqliteSeenState(filename)
+	c.Check(err, IsNil)
+	c.Assert(sqls, NotNil)
+	sqls.Close()
+}
+
 func (s *sqlsSuite) TestDropPrevThan(c *C) {
 	dir := c.MkDir()
 	filename := dir + "test.db"

=== modified file 'client/session/session.go'
--- client/session/session.go	2015-01-22 17:34:18 +0000
+++ client/session/session.go	2015-03-26 16:42:21 +0000
@@ -39,6 +39,14 @@
 	"launchpad.net/ubuntu-push/util"
 )
 
+type sessCmd uint8
+
+const (
+	cmdDisconnect sessCmd = iota
+	cmdConnect
+	cmdResetCookie
+)
+
 var (
 	wireVersionBytes = []byte{protocol.ProtocolWireVersion}
 )
@@ -70,10 +78,12 @@
 
 const (
 	Error ClientSessionState = iota
+	Pristine
 	Disconnected
 	Connected
 	Started
 	Running
+	Shutdown
 	Unknown
 )
 
@@ -83,10 +93,12 @@
 	}
 	return [Unknown]string{
 		"Error",
+		"Pristine",
 		"Disconnected",
 		"Connected",
 		"Started",
 		"Running",
+		"Shutdown",
 	}[s]
 }
 
@@ -118,10 +130,20 @@
 	AuthGetter             func(string) string
 	AuthURL                string
 	AddresseeChecker       AddresseeChecking
+	BroadcastCh            chan *BroadcastNotification
+	NotificationsCh        chan AddressedNotification
 }
 
 // ClientSession holds a client<->server session and its configuration.
-type ClientSession struct {
+type ClientSession interface {
+	ResetCookie()
+	State() ClientSessionState
+	HasConnectivity(bool)
+	KeepConnection() error
+	StopKeepConnection()
+}
+
+type clientSession struct {
 	// configuration
 	DeviceId string
 	ClientSessionConfig
@@ -145,25 +167,36 @@
 	proto        protocol.Protocol
 	pingInterval time.Duration
 	retrier      util.AutoRedialer
-	retrierLock  sync.Mutex
 	cookie       string
 	// status
-	stateP          *uint32
-	ErrCh           chan error
-	BroadcastCh     chan *BroadcastNotification
-	NotificationsCh chan AddressedNotification
+	stateLock sync.RWMutex
+	state     ClientSessionState
 	// authorization
 	auth string
 	// autoredial knobs
 	shouldDelayP    *uint32
 	lastAutoRedial  time.Time
-	redialDelay     func(*ClientSession) time.Duration
+	redialDelay     func(*clientSession) time.Duration
 	redialJitter    func(time.Duration) time.Duration
 	redialDelays    []time.Duration
 	redialDelaysIdx int
+	// connection events, and cookie reset requests, come in over here
+	cmdCh chan sessCmd
+	// last seen connection event is here
+	lastConn bool
+	// connection events are handled by this
+	connHandler func(bool)
+	// autoredial goes over here (xxx spurious goroutine involved)
+	doneCh chan uint32
+	// main loop errors out through here (possibly another spurious goroutine)
+	errCh chan error
+	// main loop errors are handled by this
+	errHandler func(error)
+	// look, a stopper!
+	stopCh chan struct{}
 }
 
-func redialDelay(sess *ClientSession) time.Duration {
+func redialDelay(sess *clientSession) time.Duration {
 	if sess.ShouldDelay() {
 		t := sess.redialDelays[sess.redialDelaysIdx]
 		if len(sess.redialDelays) > sess.redialDelaysIdx+1 {
@@ -178,8 +211,7 @@
 
 func NewSession(serverAddrSpec string, conf ClientSessionConfig,
 	deviceId string, seenStateFactory func() (seenstate.SeenState, error),
-	log logger.Logger) (*ClientSession, error) {
-	state := uint32(Disconnected)
+	log logger.Logger) (*clientSession, error) {
 	seenState, err := seenStateFactory()
 	if err != nil {
 		return nil, err
@@ -191,7 +223,7 @@
 		getHost = gethosts.New(deviceId, hostsEndpoint, conf.ExchangeTimeout)
 	}
 	var shouldDelay uint32 = 0
-	sess := &ClientSession{
+	sess := &clientSession{
 		ClientSessionConfig: conf,
 		getHost:             getHost,
 		fallbackHosts:       fallbackHosts,
@@ -200,10 +232,10 @@
 		Protocolator:        protocol.NewProtocol0,
 		SeenState:           seenState,
 		TLS:                 &tls.Config{},
-		stateP:              &state,
+		state:               Pristine,
 		timeSince:           time.Since,
 		shouldDelayP:        &shouldDelay,
-		redialDelay:         redialDelay,
+		redialDelay:         redialDelay, // NOTE there are tests that use calling sess.redialDelay as an indication of calling autoRedial!
 		redialDelays:        util.Timeouts(),
 	}
 	sess.redialJitter = sess.Jitter
@@ -215,62 +247,78 @@
 		}
 		sess.TLS.RootCAs = cp
 	}
+	sess.doneCh = make(chan uint32, 1)
+	sess.stopCh = make(chan struct{})
+	sess.cmdCh = make(chan sessCmd)
+	sess.errCh = make(chan error, 1)
+
+	// to be overridden by tests
+	sess.connHandler = sess.handleConn
+	sess.errHandler = sess.handleErr
+
 	return sess, nil
 }
 
-func (sess *ClientSession) ShouldDelay() bool {
+func (sess *clientSession) ShouldDelay() bool {
 	return atomic.LoadUint32(sess.shouldDelayP) != 0
 }
 
-func (sess *ClientSession) setShouldDelay() {
+func (sess *clientSession) setShouldDelay() {
 	atomic.StoreUint32(sess.shouldDelayP, uint32(1))
 }
 
-func (sess *ClientSession) clearShouldDelay() {
+func (sess *clientSession) clearShouldDelay() {
 	atomic.StoreUint32(sess.shouldDelayP, uint32(0))
 }
 
-func (sess *ClientSession) State() ClientSessionState {
-	return ClientSessionState(atomic.LoadUint32(sess.stateP))
-}
-
-func (sess *ClientSession) setState(state ClientSessionState) {
-	sess.Log.Debugf("session.setState: %s -> %s", ClientSessionState(atomic.LoadUint32(sess.stateP)), state)
-	atomic.StoreUint32(sess.stateP, uint32(state))
-}
-
-func (sess *ClientSession) setConnection(conn net.Conn) {
+func (sess *clientSession) State() ClientSessionState {
+	sess.stateLock.RLock()
+	defer sess.stateLock.RUnlock()
+	return sess.state
+}
+
+func (sess *clientSession) setState(state ClientSessionState) {
+	sess.stateLock.Lock()
+	defer sess.stateLock.Unlock()
+	sess.Log.Debugf("session.setState: %s -> %s", sess.state, state)
+	sess.state = state
+}
+
+func (sess *clientSession) setConnection(conn net.Conn) {
 	sess.connLock.Lock()
 	defer sess.connLock.Unlock()
 	sess.Connection = conn
 }
 
-func (sess *ClientSession) getConnection() net.Conn {
+func (sess *clientSession) getConnection() net.Conn {
 	sess.connLock.RLock()
 	defer sess.connLock.RUnlock()
 	return sess.Connection
 }
 
-func (sess *ClientSession) setCookie(cookie string) {
+func (sess *clientSession) setCookie(cookie string) {
 	sess.connLock.Lock()
 	defer sess.connLock.Unlock()
 	sess.cookie = cookie
 }
 
-func (sess *ClientSession) getCookie() string {
+func (sess *clientSession) getCookie() string {
 	sess.connLock.RLock()
 	defer sess.connLock.RUnlock()
 	return sess.cookie
 }
 
-func (sess *ClientSession) ClearCookie() {
-	sess.connLock.Lock()
-	defer sess.connLock.Unlock()
-	sess.cookie = ""
+func (sess *clientSession) ResetCookie() {
+	sess.cmdCh <- cmdResetCookie
+}
+
+func (sess *clientSession) resetCookie() {
+	sess.stopRedial()
+	sess.doClose(true)
 }
 
 // getHosts sets deliveryHosts possibly querying a remote endpoint
-func (sess *ClientSession) getHosts() error {
+func (sess *clientSession) getHosts() error {
 	if sess.getHost != nil {
 		if sess.deliveryHosts != nil && sess.timeSince(sess.deliveryHostsTimestamp) < sess.HostsCachingExpiryTime {
 			return nil
@@ -294,7 +342,7 @@
 
 // addAuthorization gets the authorization blob to send to the server
 // and adds it to the session.
-func (sess *ClientSession) addAuthorization() error {
+func (sess *clientSession) addAuthorization() error {
 	if sess.AuthGetter != nil {
 		sess.Log.Debugf("adding authorization")
 		sess.auth = sess.AuthGetter(sess.AuthURL)
@@ -302,13 +350,13 @@
 	return nil
 }
 
-func (sess *ClientSession) resetHosts() {
+func (sess *clientSession) resetHosts() {
 	sess.deliveryHosts = nil
 }
 
 // startConnectionAttempt/nextHostToTry help connect iterating over candidate hosts
 
-func (sess *ClientSession) startConnectionAttempt() {
+func (sess *clientSession) startConnectionAttempt() {
 	if sess.timeSince(sess.lastAttemptTimestamp) > sess.ExpectAllRepairedTime {
 		sess.tryHost = 0
 	}
@@ -319,7 +367,7 @@
 	sess.lastAttemptTimestamp = time.Now()
 }
 
-func (sess *ClientSession) nextHostToTry() string {
+func (sess *clientSession) nextHostToTry() string {
 	if sess.leftToTry == 0 {
 		return ""
 	}
@@ -331,7 +379,7 @@
 
 // we reached the Started state, we can retry with the same host if we
 // have to retry again
-func (sess *ClientSession) started() {
+func (sess *clientSession) started() {
 	sess.tryHost--
 	if sess.tryHost == -1 {
 		sess.tryHost = len(sess.deliveryHosts) - 1
@@ -341,7 +389,7 @@
 
 // connect to a server using the configuration in the ClientSession
 // and set up the connection.
-func (sess *ClientSession) connect() error {
+func (sess *clientSession) connect() error {
 	sess.setShouldDelay()
 	sess.startConnectionAttempt()
 	var err error
@@ -363,49 +411,47 @@
 	return nil
 }
 
-func (sess *ClientSession) stopRedial() {
-	sess.retrierLock.Lock()
-	defer sess.retrierLock.Unlock()
+func (sess *clientSession) stopRedial() {
 	if sess.retrier != nil {
 		sess.retrier.Stop()
 		sess.retrier = nil
 	}
 }
 
-func (sess *ClientSession) AutoRedial(doneCh chan uint32) {
+func (sess *clientSession) autoRedial() {
 	sess.stopRedial()
 	if time.Since(sess.lastAutoRedial) < 2*time.Second {
 		sess.setShouldDelay()
 	}
-	time.Sleep(sess.redialDelay(sess))
-	sess.retrierLock.Lock()
-	defer sess.retrierLock.Unlock()
+	// xxx should we really wait on the caller goroutine?
+	delay := sess.redialDelay(sess)
+	sess.Log.Debugf("session redial delay: %v, wait", delay)
+	time.Sleep(delay)
+	sess.Log.Debugf("session redial delay: %v, cont", delay)
 	if sess.retrier != nil {
 		panic("session AutoRedial: unexpected non-nil retrier.")
 	}
 	sess.retrier = util.NewAutoRedialer(sess)
 	sess.lastAutoRedial = time.Now()
-	go func() {
-		sess.retrierLock.Lock()
-		retrier := sess.retrier
-		sess.retrierLock.Unlock()
-		if retrier == nil {
-			sess.Log.Debugf("session autoredialer skipping retry: retrier has been set to nil.")
-			return
-		}
+	go func(retrier util.AutoRedialer) {
 		sess.Log.Debugf("session autoredialier launching Redial goroutine")
-		doneCh <- retrier.Redial()
-	}()
-}
-
-func (sess *ClientSession) Close() {
-	sess.stopRedial()
-	sess.doClose()
-}
-
-func (sess *ClientSession) doClose() {
+		// if the redialer has been stopped before calling Redial(), it'll return 0.
+		sess.doneCh <- retrier.Redial()
+	}(sess.retrier)
+}
+
+func (sess *clientSession) doClose(resetCookie bool) {
 	sess.connLock.Lock()
 	defer sess.connLock.Unlock()
+	if resetCookie {
+		sess.cookie = ""
+	}
+	sess.closeConnection()
+	sess.setState(Disconnected)
+}
+
+func (sess *clientSession) closeConnection() {
+	// *must be called with connLock held*
 	if sess.Connection != nil {
 		sess.Connection.Close()
 		// we ignore Close errors, on purpose (the thinking being that
@@ -413,11 +459,10 @@
 		// you could do to recover at this stage).
 		sess.Connection = nil
 	}
-	sess.setState(Disconnected)
 }
 
 // handle "ping" messages
-func (sess *ClientSession) handlePing() error {
+func (sess *clientSession) handlePing() error {
 	err := sess.proto.WriteMessage(protocol.PingPongMsg{Type: "pong"})
 	if err == nil {
 		sess.Log.Debugf("ping.")
@@ -429,7 +474,7 @@
 	return err
 }
 
-func (sess *ClientSession) decodeBroadcast(bcast *serverMsg) *BroadcastNotification {
+func (sess *clientSession) decodeBroadcast(bcast *serverMsg) *BroadcastNotification {
 	decoded := make([]map[string]interface{}, 0)
 	for _, p := range bcast.Payloads {
 		var v map[string]interface{}
@@ -447,7 +492,7 @@
 }
 
 // handle "broadcast" messages
-func (sess *ClientSession) handleBroadcast(bcast *serverMsg) error {
+func (sess *clientSession) handleBroadcast(bcast *serverMsg) error {
 	err := sess.SeenState.SetLevel(bcast.ChanId, bcast.TopLevel)
 	if err != nil {
 		sess.setState(Error)
@@ -478,7 +523,7 @@
 }
 
 // handle "notifications" messages
-func (sess *ClientSession) handleNotifications(ucast *serverMsg) error {
+func (sess *clientSession) handleNotifications(ucast *serverMsg) error {
 	notifs, err := sess.SeenState.FilterBySeen(ucast.Notifications)
 	if err != nil {
 		sess.setState(Error)
@@ -512,7 +557,7 @@
 }
 
 // handle "connbroken" messages
-func (sess *ClientSession) handleConnBroken(connBroken *serverMsg) error {
+func (sess *clientSession) handleConnBroken(connBroken *serverMsg) error {
 	sess.setState(Error)
 	reason := connBroken.Reason
 	err := fmt.Errorf("server broke connection: %s", reason)
@@ -525,7 +570,7 @@
 }
 
 // handle "setparams" messages
-func (sess *ClientSession) handleSetParams(setParams *serverMsg) error {
+func (sess *clientSession) handleSetParams(setParams *serverMsg) error {
 	if setParams.SetCookie != "" {
 		sess.setCookie(setParams.SetCookie)
 	}
@@ -533,7 +578,7 @@
 }
 
 // loop runs the session with the server, emits a stream of events.
-func (sess *ClientSession) loop() error {
+func (sess *clientSession) loop() error {
 	var err error
 	var recv serverMsg
 	sess.setState(Running)
@@ -571,7 +616,7 @@
 }
 
 // Call this when you've connected and want to start looping.
-func (sess *ClientSession) start() error {
+func (sess *clientSession) start() error {
 	conn := sess.getConnection()
 	err := conn.SetDeadline(time.Now().Add(sess.ExchangeTimeout))
 	if err != nil {
@@ -634,8 +679,8 @@
 
 // run calls connect, and if it works it calls start, and if it works
 // it runs loop in a goroutine, and ships its return value over ErrCh.
-func (sess *ClientSession) run(closer func(), authChecker, hostGetter, connecter, starter, looper func() error) error {
-	closer()
+func (sess *clientSession) run(closer func(bool), authChecker, hostGetter, connecter, starter, looper func() error) error {
+	closer(false)
 	if err := authChecker(); err != nil {
 		return err
 	}
@@ -646,17 +691,14 @@
 	if err == nil {
 		err = starter()
 		if err == nil {
-			sess.ErrCh = make(chan error, 1)
-			sess.BroadcastCh = make(chan *BroadcastNotification)
-			sess.NotificationsCh = make(chan AddressedNotification)
-			go func() { sess.ErrCh <- looper() }()
+			go func() { sess.errCh <- looper() }()
 		}
 	}
 	return err
 }
 
 // This Jitter returns a random time.Duration somewhere in [-spread, spread].
-func (sess *ClientSession) Jitter(spread time.Duration) time.Duration {
+func (sess *clientSession) Jitter(spread time.Duration) time.Duration {
 	if spread < 0 {
 		panic("spread must be non-negative")
 	}
@@ -666,7 +708,7 @@
 
 // Dial takes the session from newly created (or newly disconnected)
 // to running the main loop.
-func (sess *ClientSession) Dial() error {
+func (sess *clientSession) Dial() error {
 	if sess.Protocolator == nil {
 		// a missing protocolator means you've willfully overridden
 		// it; returning an error here would prompt AutoRedial to just
@@ -676,6 +718,90 @@
 	return sess.run(sess.doClose, sess.addAuthorization, sess.getHosts, sess.connect, sess.start, sess.loop)
 }
 
+func (sess *clientSession) shutdown() {
+	sess.Log.Infof("session shutting down.")
+	sess.connLock.Lock()
+	defer sess.connLock.Unlock()
+	sess.stopRedial()
+	sess.closeConnection()
+}
+
+func (sess *clientSession) doKeepConnection() {
+	for {
+		select {
+		case cmd := <-sess.cmdCh:
+			switch cmd {
+			case cmdConnect:
+				sess.connHandler(true)
+			case cmdDisconnect:
+				sess.connHandler(false)
+			case cmdResetCookie:
+				sess.resetCookie()
+			}
+		case <-sess.stopCh:
+			sess.shutdown()
+			return
+		case n := <-sess.doneCh:
+			// if n == 0, the redialer aborted. If you do
+			// anything other than log it, keep that in mind.
+			sess.Log.Debugf("connected after %d attempts.", n)
+		case err := <-sess.errCh:
+			sess.errHandler(err)
+		}
+	}
+}
+
+func (sess *clientSession) handleConn(hasConn bool) {
+	sess.lastConn = hasConn
+
+	// Note this does not depend on the current state!  That's because Dial
+	// starts with doClose, which gets you to Disconnected even if you're
+	// connected, and you can call Close when Disconnected without it
+	// losing its stuff.
+	if hasConn {
+		sess.autoRedial()
+	} else {
+		sess.stopRedial()
+		sess.doClose(false)
+	}
+}
+
+func (sess *clientSession) handleErr(err error) {
+	sess.Log.Errorf("session error'ed out with %v", err)
+	// State() == Error mostly defends interrupting an ongoing
+	// autoRedial if we went quickly already through hasConn =
+	// false => hasConn = true
+	if sess.State() == Error && sess.lastConn {
+		sess.autoRedial()
+	}
+}
+
+func (sess *clientSession) KeepConnection() error {
+	sess.stateLock.Lock()
+	defer sess.stateLock.Unlock()
+	if sess.state != Pristine {
+		return errors.New("don't call KeepConnection() on a non-pristine session.")
+	}
+	sess.state = Disconnected
+
+	go sess.doKeepConnection()
+
+	return nil
+}
+
+func (sess *clientSession) StopKeepConnection() {
+	sess.setState(Shutdown)
+	close(sess.stopCh)
+}
+
+func (sess *clientSession) HasConnectivity(hasConn bool) {
+	if hasConn {
+		sess.cmdCh <- cmdConnect
+	} else {
+		sess.cmdCh <- cmdDisconnect
+	}
+}
+
 func init() {
 	rand.Seed(time.Now().Unix()) // good enough for us (we're not using it for crypto)
 }

=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-10-23 19:30:24 +0000
+++ client/session/session_test.go	2015-03-26 16:42:21 +0000
@@ -162,6 +162,7 @@
 
 func (*brokenSeenState) SetLevel(string, int64) error            { return errors.New("broken.") }
 func (*brokenSeenState) GetAllLevels() (map[string]int64, error) { return nil, errors.New("broken.") }
+func (*brokenSeenState) Close()                                  {}
 func (*brokenSeenState) FilterBySeen([]protocol.Notification) ([]protocol.Notification, error) {
 	return nil, errors.New("broken.")
 }
@@ -189,6 +190,24 @@
 	cs.lvls = func() (seenstate.SeenState, error) { return seenstate.NewSqliteSeenState(":memory:") }
 }
 
+func (cs *clientSessionSuite) TestStateString(c *C) {
+	for _, i := range []struct {
+		v ClientSessionState
+		s string
+	}{
+		{Error, "Error"},
+		{Pristine, "Pristine"},
+		{Disconnected, "Disconnected"},
+		{Connected, "Connected"},
+		{Started, "Started"},
+		{Running, "Running"},
+		{Shutdown, "Shutdown"},
+		{Unknown, fmt.Sprintf("??? (%d)", Unknown)},
+	} {
+		c.Check(i.v.String(), Equals, i.s)
+	}
+}
+
 /****************************************************************
   parseServerAddrSpec() tests
 ****************************************************************/
@@ -211,10 +230,15 @@
   NewSession() tests
 ****************************************************************/
 
-var dummyConf = ClientSessionConfig{}
+func dummyConf() ClientSessionConfig {
+	return ClientSessionConfig{
+		BroadcastCh:     make(chan *BroadcastNotification, 5),
+		NotificationsCh: make(chan AddressedNotification, 5),
+	}
+}
 
 func (cs *clientSessionSuite) TestNewSessionPlainWorks(c *C) {
-	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+	sess, err := NewSession("foo:443", dummyConf(), "", cs.lvls, cs.log)
 	c.Check(sess, NotNil)
 	c.Check(err, IsNil)
 	c.Check(sess.fallbackHosts, DeepEquals, []string{"foo:443"})
@@ -224,11 +248,13 @@
 	c.Check(sess.redialDelays, DeepEquals, util.Timeouts())
 	// but no root CAs set
 	c.Check(sess.TLS.RootCAs, IsNil)
-	c.Check(sess.State(), Equals, Disconnected)
+	c.Check(sess.State(), Equals, Pristine)
+	c.Check(sess.stopCh, NotNil)
+	c.Check(sess.cmdCh, NotNil)
 }
 
 func (cs *clientSessionSuite) TestNewSessionHostEndpointWorks(c *C) {
-	sess, err := NewSession("http://foo/hosts", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("http://foo/hosts", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	c.Check(sess.getHost, NotNil)
 }
@@ -254,7 +280,7 @@
 
 func (cs *clientSessionSuite) TestNewSessionBadSeenStateFails(c *C) {
 	ferr := func() (seenstate.SeenState, error) { return nil, errors.New("Busted.") }
-	sess, err := NewSession("", dummyConf, "wah", ferr, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", ferr, cs.log)
 	c.Check(sess, IsNil)
 	c.Assert(err, NotNil)
 }
@@ -265,7 +291,7 @@
 
 func (cs *clientSessionSuite) TestGetHostsFallback(c *C) {
 	fallback := []string{"foo:443", "bar:443"}
-	sess := &ClientSession{fallbackHosts: fallback}
+	sess := &clientSession{fallbackHosts: fallback}
 	err := sess.getHosts()
 	c.Assert(err, IsNil)
 	c.Check(sess.deliveryHosts, DeepEquals, fallback)
@@ -283,14 +309,14 @@
 
 func (cs *clientSessionSuite) TestGetHostsRemote(c *C) {
 	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
-	sess := &ClientSession{getHost: hostGetter, timeSince: time.Since}
+	sess := &clientSession{getHost: hostGetter, timeSince: time.Since}
 	err := sess.getHosts()
 	c.Assert(err, IsNil)
 	c.Check(sess.deliveryHosts, DeepEquals, []string{"foo:443", "bar:443"})
 }
 
 func (cs *clientSessionSuite) TestGetHostsRemoteError(c *C) {
-	sess, err := NewSession("", dummyConf, "", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	hostsErr := errors.New("failed")
 	hostGetter := &testHostGetter{"", nil, hostsErr}
@@ -303,7 +329,7 @@
 
 func (cs *clientSessionSuite) TestGetHostsRemoteCaching(c *C) {
 	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
-	sess := &ClientSession{
+	sess := &clientSession{
 		getHost: hostGetter,
 		ClientSessionConfig: ClientSessionConfig{
 			HostsCachingExpiryTime: 2 * time.Hour,
@@ -328,7 +354,7 @@
 
 func (cs *clientSessionSuite) TestGetHostsRemoteCachingReset(c *C) {
 	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
-	sess := &ClientSession{
+	sess := &clientSession{
 		getHost: hostGetter,
 		ClientSessionConfig: ClientSessionConfig{
 			HostsCachingExpiryTime: 2 * time.Hour,
@@ -355,7 +381,7 @@
 
 func (cs *clientSessionSuite) TestAddAuthorizationAddsAuthorization(c *C) {
 	url := "xyzzy://"
-	sess := &ClientSession{Log: cs.log}
+	sess := &clientSession{Log: cs.log}
 	sess.AuthGetter = func(url string) string { return url + " auth'ed" }
 	sess.AuthURL = url
 	c.Assert(sess.auth, Equals, "")
@@ -365,7 +391,7 @@
 }
 
 func (cs *clientSessionSuite) TestAddAuthorizationSkipsIfUnset(c *C) {
-	sess := &ClientSession{Log: cs.log}
+	sess := &clientSession{Log: cs.log}
 	sess.AuthGetter = nil
 	c.Assert(sess.auth, Equals, "")
 	err := sess.addAuthorization()
@@ -379,7 +405,7 @@
 
 func (cs *clientSessionSuite) TestStartConnectionAttempt(c *C) {
 	since := time.Since(time.Time{})
-	sess := &ClientSession{
+	sess := &clientSession{
 		ClientSessionConfig: ClientSessionConfig{
 			ExpectAllRepairedTime: 10 * time.Second,
 		},
@@ -403,7 +429,7 @@
 
 func (cs *clientSessionSuite) TestStartConnectionAttemptNoHostsPanic(c *C) {
 	since := time.Since(time.Time{})
-	sess := &ClientSession{
+	sess := &clientSession{
 		ClientSessionConfig: ClientSessionConfig{
 			ExpectAllRepairedTime: 10 * time.Second,
 		},
@@ -415,7 +441,7 @@
 }
 
 func (cs *clientSessionSuite) TestNextHostToTry(c *C) {
-	sess := &ClientSession{
+	sess := &clientSession{
 		deliveryHosts: []string{"foo:443", "bar:443", "baz:443"},
 		tryHost:       0,
 		leftToTry:     3,
@@ -438,7 +464,7 @@
 }
 
 func (cs *clientSessionSuite) TestStarted(c *C) {
-	sess, err := NewSession("", dummyConf, "", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 
 	sess.deliveryHosts = []string{"foo:443", "bar:443", "baz:443"}
@@ -457,7 +483,7 @@
 ****************************************************************/
 
 func (cs *clientSessionSuite) TestConnectFailsWithNoAddress(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{"nowhere"}
 	sess.clearShouldDelay()
@@ -471,7 +497,7 @@
 	srv, err := net.Listen("tcp", "localhost:0")
 	c.Assert(err, IsNil)
 	defer srv.Close()
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{srv.Addr().String()}
 	sess.clearShouldDelay()
@@ -486,7 +512,7 @@
 	srv, err := net.Listen("tcp", "localhost:0")
 	c.Assert(err, IsNil)
 	defer srv.Close()
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{"nowhere", srv.Addr().String()}
 	sess.clearShouldDelay()
@@ -501,7 +527,7 @@
 func (cs *clientSessionSuite) TestConnectConnectFail(c *C) {
 	srv, err := net.Listen("tcp", "localhost:0")
 	c.Assert(err, IsNil)
-	sess, err := NewSession(srv.Addr().String(), dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession(srv.Addr().String(), dummyConf(), "wah", cs.lvls, cs.log)
 	srv.Close()
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{srv.Addr().String()}
@@ -512,101 +538,58 @@
 	c.Check(sess.State(), Equals, Error)
 }
 
-/****************************************************************
-  Close() tests
-****************************************************************/
-
-func (cs *clientSessionSuite) TestClose(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
-	c.Assert(err, IsNil)
-	sess.Connection = &testConn{Name: "TestClose"}
-	sess.Close()
-	c.Check(sess.Connection, IsNil)
-	c.Check(sess.State(), Equals, Disconnected)
-}
-
-func (cs *clientSessionSuite) TestCloseTwice(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
-	c.Assert(err, IsNil)
-	sess.Connection = &testConn{Name: "TestCloseTwice"}
-	sess.Close()
-	c.Check(sess.Connection, IsNil)
-	sess.Close()
-	c.Check(sess.Connection, IsNil)
-	c.Check(sess.State(), Equals, Disconnected)
-}
-
-func (cs *clientSessionSuite) TestCloseFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
-	c.Assert(err, IsNil)
-	sess.Connection = &testConn{Name: "TestCloseFails", CloseCondition: condition.Work(false)}
-	sess.Close()
-	c.Check(sess.Connection, IsNil) // nothing you can do to clean up anyway
-	c.Check(sess.State(), Equals, Disconnected)
-}
-
-type derp struct{ stopped bool }
-
-func (*derp) Redial() uint32 { return 0 }
-func (d *derp) Stop()        { d.stopped = true }
-
-func (cs *clientSessionSuite) TestCloseStopsRetrier(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
-	c.Assert(err, IsNil)
-	ar := new(derp)
-	sess.retrier = ar
-	c.Check(ar.stopped, Equals, false)
-	sess.Close()
-	c.Check(ar.stopped, Equals, true)
-	sess.Close() // double close check
-	c.Check(ar.stopped, Equals, true)
-}
-
-/****************************************************************
-  AutoRedial() tests
-****************************************************************/
+type dumbRetrier struct{ stopped bool }
+
+func (*dumbRetrier) Redial() uint32 { return 0 }
+func (d *dumbRetrier) Stop()        { d.stopped = true }
+
+// /****************************************************************
+//   AutoRedial() tests
+// ****************************************************************/
 
 func (cs *clientSessionSuite) TestAutoRedialWorks(c *C) {
 	// checks that AutoRedial sets up a retrier and tries redialing it
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
-	ar := new(derp)
+	ar := new(dumbRetrier)
 	sess.retrier = ar
 	c.Check(ar.stopped, Equals, false)
-	sess.AutoRedial(nil)
+	sess.autoRedial()
+	defer sess.stopRedial()
 	c.Check(ar.stopped, Equals, true)
 }
 
 func (cs *clientSessionSuite) TestAutoRedialStopsRetrier(c *C) {
 	// checks that AutoRedial stops the previous retrier
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
-	ch := make(chan uint32)
+	sess.doneCh = make(chan uint32)
 	c.Check(sess.retrier, IsNil)
-	sess.AutoRedial(ch)
+	sess.autoRedial()
 	c.Assert(sess.retrier, NotNil)
 	sess.retrier.Stop()
-	c.Check(<-ch, Not(Equals), 0)
+	c.Check(<-sess.doneCh, Not(Equals), 0)
 }
 
 func (cs *clientSessionSuite) TestAutoRedialCallsRedialDelay(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	// NOTE there are tests that use calling redialDelay as an indication of calling autoRedial!
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	flag := false
-	sess.redialDelay = func(sess *ClientSession) time.Duration { flag = true; return 0 }
-	sess.AutoRedial(nil)
+	sess.redialDelay = func(sess *clientSession) time.Duration { flag = true; return 0 }
+	sess.autoRedial()
 	c.Check(flag, Equals, true)
 }
 
 func (cs *clientSessionSuite) TestAutoRedialSetsRedialDelayIfTooQuick(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
-	sess.redialDelay = func(sess *ClientSession) time.Duration { return 0 }
-	sess.AutoRedial(nil)
+	sess.redialDelay = func(sess *clientSession) time.Duration { return 0 }
+	sess.autoRedial()
 	c.Check(sess.ShouldDelay(), Equals, false)
 	sess.stopRedial()
 	sess.clearShouldDelay()
-	sess.AutoRedial(nil)
+	sess.autoRedial()
 	c.Check(sess.ShouldDelay(), Equals, true)
 }
 
@@ -615,29 +598,23 @@
 ****************************************************************/
 
 type msgSuite struct {
-	sess   *ClientSession
+	sess   *clientSession
 	upCh   chan interface{}
 	downCh chan interface{}
-	errCh  chan error
 }
 
 var _ = Suite(&msgSuite{})
 
 func (s *msgSuite) SetUpTest(c *C) {
 	var err error
-	conf := ClientSessionConfig{
-		ExchangeTimeout: time.Millisecond,
-	}
+	conf := dummyConf()
+	conf.ExchangeTimeout = time.Millisecond
 	s.sess, err = NewSession("", conf, "wah", seenstate.NewSeenState, helpers.NewTestLogger(c, "debug"))
 	c.Assert(err, IsNil)
 	s.sess.Connection = &testConn{Name: "TestHandle*"}
-	s.errCh = make(chan error, 1)
 	s.upCh = make(chan interface{}, 5)
 	s.downCh = make(chan interface{}, 5)
 	s.sess.proto = &testProtocol{up: s.upCh, down: s.downCh}
-	// make the message channel buffered
-	s.sess.BroadcastCh = make(chan *BroadcastNotification, 5)
-	s.sess.NotificationsCh = make(chan AddressedNotification, 5)
 }
 
 func (s *msgSuite) TestHandlePingWorks(c *C) {
@@ -693,10 +670,10 @@
 			json.RawMessage(`{"img1/m1":[102,"tubular"]}`),
 		},
 	}
-	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleBroadcast(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
-	c.Check(<-s.errCh, Equals, nil)
+	c.Check(<-s.sess.errCh, Equals, nil)
 	c.Assert(len(s.sess.BroadcastCh), Equals, 1)
 	c.Check(<-s.sess.BroadcastCh, DeepEquals, &BroadcastNotification{
 		TopLevel: 2,
@@ -725,11 +702,11 @@
 		TopLevel: 2,
 		Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
 	}
-	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleBroadcast(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	failure := errors.New("ACK ACK ACK")
 	s.upCh <- failure
-	c.Assert(<-s.errCh, Equals, failure)
+	c.Assert(<-s.sess.errCh, Equals, failure)
 	c.Check(s.sess.State(), Equals, Error)
 }
 
@@ -743,10 +720,10 @@
 		TopLevel: 2,
 		Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
 	}
-	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleBroadcast(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
-	c.Check(<-s.errCh, IsNil)
+	c.Check(<-s.sess.errCh, IsNil)
 	c.Check(len(s.sess.BroadcastCh), Equals, 0)
 }
 
@@ -761,10 +738,10 @@
 		TopLevel: 2,
 		Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
 	}
-	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleBroadcast(msg) }()
 	s.upCh <- nil // ack ok
 	// start returns with error
-	c.Check(<-s.errCh, Not(Equals), nil)
+	c.Check(<-s.sess.errCh, Not(Equals), nil)
 	c.Check(s.sess.State(), Equals, Error)
 	// no message sent out
 	c.Check(len(s.sess.BroadcastCh), Equals, 0)
@@ -777,10 +754,10 @@
 	s.sess.setShouldDelay()
 
 	msg := &serverMsg{Type: "broadcast"}
-	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleBroadcast(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
-	c.Check(<-s.errCh, IsNil)
+	c.Check(<-s.sess.errCh, IsNil)
 
 	c.Check(s.sess.ShouldDelay(), Equals, false)
 }
@@ -789,10 +766,10 @@
 	s.sess.setShouldDelay()
 
 	msg := &serverMsg{Type: "broadcast"}
-	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleBroadcast(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- errors.New("bcast")
-	c.Check(<-s.errCh, NotNil)
+	c.Check(<-s.sess.errCh, NotNil)
 
 	c.Check(s.sess.ShouldDelay(), Equals, true)
 }
@@ -842,10 +819,10 @@
 	msg.NotificationsMsg = protocol.NotificationsMsg{
 		Notifications: []protocol.Notification{n1, n2},
 	}
-	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleNotifications(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
-	c.Check(<-s.errCh, Equals, nil)
+	c.Check(<-s.sess.errCh, Equals, nil)
 	c.Check(s.sess.ShouldDelay(), Equals, false)
 	c.Assert(s.sess.NotificationsCh, HasLen, 2)
 	app1, err := click.ParseAppId("com.example.app1_app1")
@@ -888,10 +865,10 @@
 	msg.NotificationsMsg = protocol.NotificationsMsg{
 		Notifications: []protocol.Notification{n1, n2},
 	}
-	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleNotifications(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
-	c.Check(<-s.errCh, Equals, nil)
+	c.Check(<-s.sess.errCh, Equals, nil)
 	c.Check(s.sess.ShouldDelay(), Equals, false)
 	c.Assert(s.sess.NotificationsCh, HasLen, 1)
 	app2, err := click.ParseAppId("com.example.app2_app2")
@@ -923,10 +900,10 @@
 	msg.NotificationsMsg = protocol.NotificationsMsg{
 		Notifications: []protocol.Notification{n1, n2},
 	}
-	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleNotifications(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
-	c.Check(<-s.errCh, Equals, nil)
+	c.Check(<-s.sess.errCh, Equals, nil)
 	c.Assert(s.sess.NotificationsCh, HasLen, 2)
 	app1, err := click.ParseAppId("com.example.app1_app1")
 	c.Assert(err, IsNil)
@@ -943,10 +920,10 @@
 	c.Check(ac.ops, HasLen, 3)
 
 	// second time they get ignored
-	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleNotifications(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
-	c.Check(<-s.errCh, Equals, nil)
+	c.Check(<-s.sess.errCh, Equals, nil)
 	c.Assert(s.sess.NotificationsCh, HasLen, 0)
 	c.Check(ac.ops, HasLen, 4)
 }
@@ -963,11 +940,11 @@
 	msg.NotificationsMsg = protocol.NotificationsMsg{
 		Notifications: []protocol.Notification{n1},
 	}
-	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleNotifications(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	failure := errors.New("ACK ACK ACK")
 	s.upCh <- failure
-	c.Assert(<-s.errCh, Equals, failure)
+	c.Assert(<-s.sess.errCh, Equals, failure)
 	c.Check(s.sess.State(), Equals, Error)
 	// didn't get to clear
 	c.Check(s.sess.ShouldDelay(), Equals, true)
@@ -986,10 +963,10 @@
 	msg.NotificationsMsg = protocol.NotificationsMsg{
 		Notifications: []protocol.Notification{n1},
 	}
-	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
+	go func() { s.sess.errCh <- s.sess.handleNotifications(msg) }()
 	s.upCh <- nil // ack ok
 	// start returns with error
-	c.Check(<-s.errCh, Not(Equals), nil)
+	c.Check(<-s.sess.errCh, Not(Equals), nil)
 	c.Check(s.sess.State(), Equals, Error)
 	// no message sent out
 	c.Check(len(s.sess.NotificationsCh), Equals, 0)
@@ -1010,8 +987,8 @@
 	msg.ConnBrokenMsg = protocol.ConnBrokenMsg{
 		Reason: "REASON",
 	}
-	go func() { s.errCh <- s.sess.handleConnBroken(msg) }()
-	c.Check(<-s.errCh, ErrorMatches, "server broke connection: REASON")
+	go func() { s.sess.errCh <- s.sess.handleConnBroken(msg) }()
+	c.Check(<-s.sess.errCh, ErrorMatches, "server broke connection: REASON")
 	c.Check(s.sess.State(), Equals, Error)
 }
 
@@ -1022,8 +999,8 @@
 		Reason: protocol.BrokenHostMismatch,
 	}
 	s.sess.deliveryHosts = []string{"foo:443", "bar:443"}
-	go func() { s.errCh <- s.sess.handleConnBroken(msg) }()
-	c.Check(<-s.errCh, ErrorMatches, "server broke connection: host-mismatch")
+	go func() { s.sess.errCh <- s.sess.handleConnBroken(msg) }()
+	c.Check(<-s.sess.errCh, ErrorMatches, "server broke connection: host-mismatch")
 	c.Check(s.sess.State(), Equals, Error)
 	// hosts were reset
 	c.Check(s.sess.deliveryHosts, IsNil)
@@ -1041,14 +1018,14 @@
 	(*msgSuite)(s).SetUpTest(c)
 	s.sess.Connection.(*testConn).Name = "TestLoop*"
 	go func() {
-		s.errCh <- s.sess.loop()
+		s.sess.errCh <- s.sess.loop()
 	}()
 }
 
 func (s *loopSuite) TestLoopReadError(c *C) {
 	c.Check(s.sess.State(), Equals, Running)
 	s.upCh <- errors.New("Read")
-	err := <-s.errCh
+	err := <-s.sess.errCh
 	c.Check(err, ErrorMatches, "Read")
 	c.Check(s.sess.State(), Equals, Error)
 }
@@ -1060,7 +1037,7 @@
 	c.Check(takeNext(s.downCh), Equals, protocol.PingPongMsg{Type: "pong"})
 	failure := errors.New("pong")
 	s.upCh <- failure
-	c.Check(<-s.errCh, Equals, failure)
+	c.Check(<-s.sess.errCh, Equals, failure)
 }
 
 func (s *loopSuite) TestLoopLoopsDaLoop(c *C) {
@@ -1073,7 +1050,7 @@
 	}
 	failure := errors.New("pong")
 	s.upCh <- failure
-	c.Check(<-s.errCh, Equals, failure)
+	c.Check(<-s.sess.errCh, Equals, failure)
 }
 
 func (s *loopSuite) TestLoopBroadcast(c *C) {
@@ -1090,7 +1067,7 @@
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	failure := errors.New("ack")
 	s.upCh <- failure
-	c.Check(<-s.errCh, Equals, failure)
+	c.Check(<-s.sess.errCh, Equals, failure)
 }
 
 func (s *loopSuite) TestLoopNotifications(c *C) {
@@ -1110,7 +1087,7 @@
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	failure := errors.New("ack")
 	s.upCh <- failure
-	c.Check(<-s.errCh, Equals, failure)
+	c.Check(<-s.sess.errCh, Equals, failure)
 }
 
 func (s *loopSuite) TestLoopSetParams(c *C) {
@@ -1123,7 +1100,7 @@
 	s.upCh <- setParams
 	failure := errors.New("fail")
 	s.upCh <- failure
-	c.Assert(<-s.errCh, Equals, failure)
+	c.Assert(<-s.sess.errCh, Equals, failure)
 	c.Check(s.sess.getCookie(), Equals, "COOKIE")
 }
 
@@ -1135,7 +1112,7 @@
 	}
 	c.Check(takeNext(s.downCh), Equals, "deadline 1ms")
 	s.upCh <- broken
-	c.Check(<-s.errCh, NotNil)
+	c.Check(<-s.sess.errCh, NotNil)
 }
 
 func (s *loopSuite) TestLoopConnWarn(c *C) {
@@ -1156,7 +1133,7 @@
 	s.upCh <- warn
 	s.upCh <- connwarn
 	s.upCh <- failure
-	c.Check(<-s.errCh, Equals, failure)
+	c.Check(<-s.sess.errCh, Equals, failure)
 	c.Check(log.Captured(),
 		Matches, `(?ms).* warning: XXX$.*`)
 	c.Check(log.Captured(),
@@ -1167,7 +1144,7 @@
   start() tests
 ****************************************************************/
 func (cs *clientSessionSuite) TestStartFailsIfSetDeadlineFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartFailsIfSetDeadlineFails",
 		DeadlineCondition: condition.Work(false)} // setdeadline will fail
@@ -1177,7 +1154,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartFailsIfWriteFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartFailsIfWriteFails",
 		WriteCondition: condition.Work(false)} // write will fail
@@ -1187,7 +1164,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartFailsIfGetLevelsFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.SeenState = &brokenSeenState{}
 	sess.Connection = &testConn{Name: "TestStartConnectMessageFails"}
@@ -1207,7 +1184,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartConnectMessageFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartConnectMessageFails"}
 	errCh := make(chan error, 1)
@@ -1234,7 +1211,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartConnackReadError(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartConnackReadError"}
 	errCh := make(chan error, 1)
@@ -1258,7 +1235,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartBadConnack(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartBadConnack"}
 	errCh := make(chan error, 1)
@@ -1282,7 +1259,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartNotConnack(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartBadConnack"}
 	errCh := make(chan error, 1)
@@ -1349,13 +1326,31 @@
   run() tests
 ****************************************************************/
 
+func (cs *clientSessionSuite) TestRunCallsCloserWithFalse(c *C) {
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	failure := errors.New("bail")
+	has_closed := false
+	with_false := false
+	err = sess.run(
+		func(b bool) { has_closed = true; with_false = !b },
+		func() error { return failure },
+		nil,
+		nil,
+		nil,
+		nil)
+	c.Check(err, Equals, failure)
+	c.Check(has_closed, Equals, true)
+	c.Check(with_false, Equals, true)
+}
+
 func (cs *clientSessionSuite) TestRunBailsIfAuthCheckFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	failure := errors.New("TestRunBailsIfAuthCheckFails")
 	has_closed := false
 	err = sess.run(
-		func() { has_closed = true },
+		func(bool) { has_closed = true },
 		func() error { return failure },
 		nil,
 		nil,
@@ -1366,12 +1361,12 @@
 }
 
 func (cs *clientSessionSuite) TestRunBailsIfHostGetterFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	failure := errors.New("TestRunBailsIfHostGetterFails")
 	has_closed := false
 	err = sess.run(
-		func() { has_closed = true },
+		func(bool) { has_closed = true },
 		func() error { return nil },
 		func() error { return failure },
 		nil,
@@ -1382,11 +1377,11 @@
 }
 
 func (cs *clientSessionSuite) TestRunBailsIfConnectFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	failure := errors.New("TestRunBailsIfConnectFails")
 	err = sess.run(
-		func() {},
+		func(bool) {},
 		func() error { return nil },
 		func() error { return nil },
 		func() error { return failure },
@@ -1396,11 +1391,11 @@
 }
 
 func (cs *clientSessionSuite) TestRunBailsIfStartFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	failure := errors.New("TestRunBailsIfStartFails")
 	err = sess.run(
-		func() {},
+		func(bool) {},
 		func() error { return nil },
 		func() error { return nil },
 		func() error { return nil },
@@ -1410,16 +1405,12 @@
 }
 
 func (cs *clientSessionSuite) TestRunRunsEvenIfLoopFails(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
-	// just to make a point: until here we haven't set ErrCh & BroadcastCh (no
-	// biggie if this stops being true)
-	c.Check(sess.ErrCh, IsNil)
-	c.Check(sess.BroadcastCh, IsNil)
 	failureCh := make(chan error) // must be unbuffered
 	notf := &BroadcastNotification{}
 	err = sess.run(
-		func() {},
+		func(bool) {},
 		func() error { return nil },
 		func() error { return nil },
 		func() error { return nil },
@@ -1427,12 +1418,12 @@
 		func() error { sess.BroadcastCh <- notf; return <-failureCh })
 	c.Check(err, Equals, nil)
 	// if run doesn't error it sets up the channels
-	c.Assert(sess.ErrCh, NotNil)
+	c.Assert(sess.errCh, NotNil)
 	c.Assert(sess.BroadcastCh, NotNil)
 	c.Check(<-sess.BroadcastCh, Equals, notf)
 	failure := errors.New("TestRunRunsEvenIfLoopFails")
 	failureCh <- failure
-	c.Check(<-sess.ErrCh, Equals, failure)
+	c.Check(<-sess.errCh, Equals, failure)
 	// so now you know it was running in a goroutine :)
 }
 
@@ -1441,7 +1432,7 @@
 ****************************************************************/
 
 func (cs *clientSessionSuite) TestJitter(c *C) {
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	num_tries := 20       // should do the math
 	spread := time.Second //
@@ -1473,20 +1464,23 @@
 
 func (cs *clientSessionSuite) TestDialPanics(c *C) {
 	// one last unhappy test
-	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Protocolator = nil
 	c.Check(sess.Dial, PanicMatches, ".*protocol constructor.")
 }
 
 var (
-	dialTestTimeout = 100 * time.Millisecond
-	dialTestConf    = ClientSessionConfig{
-		ExchangeTimeout: dialTestTimeout,
-		PEM:             helpers.TestCertPEMBlock,
-	}
+	dialTestTimeout = 300 * time.Millisecond
 )
 
+func dialTestConf() ClientSessionConfig {
+	conf := dummyConf()
+	conf.ExchangeTimeout = dialTestTimeout
+	conf.PEM = helpers.TestCertPEMBlock
+	return conf
+}
+
 func (cs *clientSessionSuite) TestDialBadServerName(c *C) {
 	// a borked server name
 	lst, err := tls.Listen("tcp", "localhost:0", helpers.TestTLSServerConfig)
@@ -1505,7 +1499,7 @@
 	}))
 	defer ts.Close()
 
-	sess, err := NewSession(ts.URL, dialTestConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession(ts.URL, dialTestConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	tconn := &testConn{}
 	sess.Connection = tconn
@@ -1550,7 +1544,7 @@
 	}))
 	defer ts.Close()
 
-	sess, err := NewSession(ts.URL, dialTestConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession(ts.URL, dialTestConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	tconn := &testConn{CloseCondition: condition.Fail2Work(10)}
 	sess.Connection = tconn
@@ -1584,7 +1578,7 @@
 
 	// 2. "connect" (but on the fake protcol above! woo)
 
-	c.Check(takeNext(downCh), Equals, "deadline 100ms")
+	c.Check(takeNext(downCh), Equals, fmt.Sprintf("deadline %v", dialTestTimeout))
 	_, ok := takeNext(downCh).(protocol.ConnectMsg)
 	c.Check(ok, Equals, true)
 	upCh <- nil // no error
@@ -1597,7 +1591,7 @@
 	// 3. "loop"
 
 	// ping works,
-	c.Check(takeNext(downCh), Equals, "deadline 110ms")
+	c.Check(takeNext(downCh), Equals, fmt.Sprintf("deadline %v", dialTestTimeout+10*time.Millisecond))
 	upCh <- protocol.PingPongMsg{Type: "ping"}
 	c.Check(takeNext(downCh), Equals, protocol.PingPongMsg{Type: "pong"})
 	upCh <- nil
@@ -1613,7 +1607,7 @@
 		TopLevel: 2,
 		Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
 	}
-	c.Check(takeNext(downCh), Equals, "deadline 110ms")
+	c.Check(takeNext(downCh), Equals, fmt.Sprintf("deadline %v", dialTestTimeout+10*time.Millisecond))
 	upCh <- b
 	c.Check(takeNext(downCh), Equals, protocol.AckMsg{"ack"})
 	upCh <- nil
@@ -1625,21 +1619,21 @@
 	c.Check(levels, DeepEquals, map[string]int64{"0": 2})
 
 	// and ping still work even after that.
-	c.Check(takeNext(downCh), Equals, "deadline 110ms")
+	c.Check(takeNext(downCh), Equals, fmt.Sprintf("deadline %v", dialTestTimeout+10*time.Millisecond))
 	upCh <- protocol.PingPongMsg{Type: "ping"}
 	c.Check(takeNext(downCh), Equals, protocol.PingPongMsg{Type: "pong"})
 	failure := errors.New("pongs")
 	upCh <- failure
-	c.Check(<-sess.ErrCh, Equals, failure)
+	c.Check(<-sess.errCh, Equals, failure)
 }
 
 func (cs *clientSessionSuite) TestDialWorksDirect(c *C) {
 	// happy path thoughts
 	lst, err := tls.Listen("tcp", "localhost:0", helpers.TestTLSServerConfig)
 	c.Assert(err, IsNil)
-	sess, err := NewSession(lst.Addr().String(), dialTestConf, "wah", cs.lvls, cs.log)
+	sess, err := NewSession(lst.Addr().String(), dialTestConf(), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
-	defer sess.Close()
+	defer sess.StopKeepConnection()
 
 	upCh := make(chan interface{}, 5)
 	downCh := make(chan interface{}, 5)
@@ -1658,7 +1652,7 @@
 ****************************************************************/
 
 func (cs *clientSessionSuite) TestShouldDelay(c *C) {
-	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+	sess, err := NewSession("foo:443", dummyConf(), "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	c.Check(sess.ShouldDelay(), Equals, false)
 	sess.setShouldDelay()
@@ -1668,7 +1662,7 @@
 }
 
 func (cs *clientSessionSuite) TestRedialDelay(c *C) {
-	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+	sess, err := NewSession("foo:443", dummyConf(), "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.redialDelays = []time.Duration{17, 42}
 	n := 0
@@ -1689,15 +1683,207 @@
 }
 
 /****************************************************************
-  ClearCookie() tests
+  ResetCookie() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestClearCookie(c *C) {
-	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+func (cs *clientSessionSuite) TestResetCookie(c *C) {
+	sess, err := NewSession("foo:443", dummyConf(), "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
+	c.Assert(sess.KeepConnection(), IsNil)
+	defer sess.StopKeepConnection()
 	c.Check(sess.getCookie(), Equals, "")
 	sess.setCookie("COOKIE")
 	c.Check(sess.getCookie(), Equals, "COOKIE")
-	sess.ClearCookie()
+	sess.ResetCookie()
 	c.Check(sess.getCookie(), Equals, "")
 }
+
+/****************************************************************
+  KeepConnection() (and related) tests
+****************************************************************/
+
+func (cs *clientSessionSuite) TestKeepConnectionDoesNothingIfNotConnected(c *C) {
+	// how do you test "does nothing?"
+	sess, err := NewSession("foo:443", dummyConf(), "", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	c.Assert(sess, NotNil)
+	c.Assert(sess.State(), Equals, Pristine)
+	c.Assert(sess.KeepConnection(), IsNil)
+	defer sess.StopKeepConnection()
+	// stopCh is meant to be used just for closing it, but abusing
+	// it for testing seems the right thing to do: this ensures
+	// the thing is ticking along before we check the state of
+	// stuff.
+	sess.stopCh <- struct{}{}
+	c.Check(sess.State(), Equals, Disconnected)
+}
+
+func (cs *clientSessionSuite) TestYouCantCallKeepConnectionTwice(c *C) {
+	sess, err := NewSession("foo:443", dummyConf(), "", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	c.Assert(sess, NotNil)
+	c.Assert(sess.State(), Equals, Pristine)
+	c.Assert(sess.KeepConnection(), IsNil)
+	defer sess.StopKeepConnection()
+	c.Check(sess.KeepConnection(), NotNil)
+}
+
+func (cs *clientSessionSuite) TestStopKeepConnectionShutsdown(c *C) {
+	sess, err := NewSession("foo:443", dummyConf(), "", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	c.Assert(sess, NotNil)
+	sess.StopKeepConnection()
+	c.Check(sess.State(), Equals, Shutdown)
+}
+
+func (cs *clientSessionSuite) TestHasConnectivityTriggersConnectivityHandler(c *C) {
+	sess, err := NewSession("foo:443", dummyConf(), "", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	c.Assert(sess, NotNil)
+	testCh := make(chan bool)
+	sess.connHandler = func(p bool) { testCh <- p }
+	go sess.doKeepConnection()
+	defer sess.StopKeepConnection()
+	sess.HasConnectivity(true)
+	c.Check(<-testCh, Equals, true)
+	sess.HasConnectivity(false)
+	c.Check(<-testCh, Equals, false)
+}
+
+func (cs *clientSessionSuite) TestDoneChIsEmptiedAndLogged(c *C) {
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	sess.doneCh = make(chan uint32) // unbuffered
+
+	sess.KeepConnection()
+	defer sess.StopKeepConnection()
+
+	sess.doneCh <- 23
+	sess.doneCh <- 24 // makes sure the first one has been processed before checking
+
+	c.Check(cs.log.Captured(),
+		Matches, `(?ms).* connected after 23 attempts\.`)
+}
+
+func (cs *clientSessionSuite) TestErrChIsEmptiedAndLoggedAndAutoRedial(c *C) {
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	ch := make(chan struct{}, 1)
+	sess.errCh = make(chan error) // unbuffered
+	sess.redialDelay = func(sess *clientSession) time.Duration { ch <- struct{}{}; return 0 }
+	sess.lastConn = true // -> autoRedial, if the session is in Disconnected
+
+	sess.KeepConnection()
+	defer sess.StopKeepConnection()
+
+	sess.setState(Error)
+	sess.errCh <- errors.New("potato")
+	select {
+	case <-ch:
+		// all ok
+	case <-time.After(100 * time.Millisecond):
+		c.Fatalf("redialDelay not called (-> autoRedial not called)?")
+	}
+
+	c.Check(cs.log.Captured(),
+		Matches, `(?ms).* session error.*potato`)
+}
+
+func (cs *clientSessionSuite) TestErrChIsEmptiedAndLoggedNoAutoRedial(c *C) {
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	ch := make(chan struct{}, 1)
+	sess.errCh = make(chan error) // unbuffered
+	sess.redialDelay = func(sess *clientSession) time.Duration { ch <- struct{}{}; return 0 }
+	sess.connHandler = func(bool) {}
+	sess.lastConn = false // so, no autoredial
+
+	sess.KeepConnection()
+	defer sess.StopKeepConnection()
+
+	sess.errCh <- errors.New("potato")
+	c.Assert(sess.State(), Equals, Disconnected)
+	select {
+	case <-ch:
+		c.Fatalf("redialDelay called (-> autoRedial called) when disconnected?")
+	case <-time.After(100 * time.Millisecond):
+		// all ok
+	}
+
+	c.Check(cs.log.Captured(),
+		Matches, `(?ms).* session error.*potato`)
+}
+
+func (cs *clientSessionSuite) TestHandleConnConnFromConnected(c *C) {
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	ch := make(chan struct{}, 1)
+	sess.redialDelay = func(sess *clientSession) time.Duration { ch <- struct{}{}; return 0 }
+	sess.state = Connected
+	sess.lastConn = true
+	sess.handleConn(true)
+	c.Check(sess.lastConn, Equals, true)
+
+	select {
+	case <-ch:
+		// all ok
+	case <-time.After(100 * time.Millisecond):
+		c.Fatalf("redialDelay not called (-> autoRedial not called)?")
+	}
+}
+
+func (cs *clientSessionSuite) TestHandleConnConnFromDisconnected(c *C) {
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	ch := make(chan struct{}, 1)
+	sess.redialDelay = func(sess *clientSession) time.Duration { ch <- struct{}{}; return 0 }
+	sess.state = Disconnected
+	sess.lastConn = false
+	sess.handleConn(true)
+	c.Check(sess.lastConn, Equals, true)
+
+	select {
+	case <-ch:
+		// all ok
+	case <-time.After(100 * time.Millisecond):
+		c.Fatalf("redialDelay not called (-> autoRedial not called)?")
+	}
+}
+
+func (cs *clientSessionSuite) TestHandleConnNotConnFromDisconnected(c *C) {
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	ch := make(chan struct{}, 1)
+	sess.redialDelay = func(sess *clientSession) time.Duration { ch <- struct{}{}; return 0 }
+	sess.state = Disconnected
+	sess.lastConn = false
+	sess.handleConn(false)
+	c.Check(sess.lastConn, Equals, false)
+
+	select {
+	case <-ch:
+		c.Fatalf("redialDelay called (-> autoRedial called)?")
+	case <-time.After(100 * time.Millisecond):
+		// all ok
+	}
+	c.Check(cs.log.Captured(), Matches, `(?ms).*-> Disconnected`)
+}
+
+func (cs *clientSessionSuite) TestHandleConnNotConnFromConnected(c *C) {
+	sess, err := NewSession("", dummyConf(), "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	ch := make(chan struct{}, 1)
+	sess.redialDelay = func(sess *clientSession) time.Duration { ch <- struct{}{}; return 0 }
+	sess.state = Connected
+	sess.lastConn = true
+	sess.handleConn(false)
+	c.Check(sess.lastConn, Equals, false)
+
+	select {
+	case <-ch:
+		c.Fatalf("redialDelay called (-> autoRedial called)?")
+	case <-time.After(100 * time.Millisecond):
+		// all ok
+	}
+	c.Check(cs.log.Captured(), Matches, `(?ms).*-> Disconnected`)
+}

=== added file 'docs/Makefile'
--- docs/Makefile	1970-01-01 00:00:00 +0000
+++ docs/Makefile	2015-03-26 16:42:21 +0000
@@ -0,0 +1,4 @@
+all: *txt *svg
+	rst2html --link-stylesheet highlevel.txt highlevel.html
+	rst2html --link-stylesheet lowlevel.txt lowlevel.html
+

=== modified file 'docs/_common.txt'
--- docs/_common.txt	2014-09-05 14:49:44 +0000
+++ docs/_common.txt	2015-03-26 16:42:21 +0000
@@ -7,46 +7,22 @@
 The helper receives two arguments ``infile`` and ``outfile``. The message is delivered via ``infile`` and the transformed
 version is placed in ``outfile``.
 
-This is the simplest possible useful helper, which simply passes the message through unchanged::
-
-    #!/usr/bin/python3
-
-    import sys
-    f1, f2 = sys.argv[1:3]
-    open(f2, "w").write(open(f1).read())
-
-Helpers need to be added to the click package manifest::
-
-    {
-        "name": "com.ubuntu.developer.ralsina.hello",
-        "description": "description of hello",
-        "framework": "ubuntu-sdk-14.10-qml-dev2",
-        "architecture": "all",
-        "title": "hello",
-        "hooks": {
-            "hello": {
-                "apparmor": "hello.json",
-                "desktop": "hello.desktop"
-            },
-            "helloHelper": {
-                "apparmor": "helloHelper-apparmor.json",
-                "push-helper": "helloHelper.json"
-            }
-        },
-        "version": "0.2",
-        "maintainer": "Roberto Alsina <[e-mail]>"
-    }
+This is the simplest possible useful helper, which simply passes the message through unchanged:
+
+.. include:: example-client/helloHelper
+   :literal:
+
+Helpers need to be added to the click package manifest:
+
+.. include:: example-client/manifest.json
+   :literal:
 
 Here, we created a helloHelper entry in hooks that has an apparmor profile and an additional JSON file for the push-helper hook.
 
-helloHelper-apparmor.json must contain **only** the push-notification-client policy group::
+helloHelper-apparmor.json must contain **only** the push-notification-client policy group and the ubuntu-push-helper template:
 
-    {
-        "policy_groups": [
-            "push-notification-client"
-        ],
-        "policy_version": 1.2
-    }
+.. include:: example-client/helloHelper-apparmor.json
+   :literal:
 
 And helloHelper.json must have at least a exec key with the path to the helper executable relative to the json, and optionally
 an app_id key containing the short id of one of the apps in the package (in the format packagename_appname without a version).
@@ -138,15 +114,10 @@
 Security
 ~~~~~~~~
 
-To use the push API, applications need to request permission in their security profile, using something like this::
+To use the push API, applications need to request permission in their security profile, using something like this:
 
-    {
-        "policy_groups": [
-            "networking",
-            "push-notification-client"
-        ],
-        "policy_version": 1.2
-    }
+.. include:: example-client/hello.json
+   :literal:
 
 
 Ubuntu Push Server API
@@ -184,3 +155,46 @@
 :clear_pending: Discards all previous pending notifications. Usually in response to getting a "too-many-pending" error.
 :replace_tag: If there's a pending notification with the same tag, delete it before queuing this new one.
 :data: A JSON object.
+
+Limitations of the Server API
+-----------------------------
+
+The push notification infrastructure is meant to help ensuring timely
+delivery of application notifications if the device is online or
+timely informing the device user about application notifications that
+were pending when the device comes back online. This in the face of
+applications not being allowed to be running all the time, and
+avoiding the resource cost of many applications all polling different services
+frequently.
+
+The push notification infrastructure is architected to guarantee at
+least best-effort with respect to these goals and beyond it, on the
+other end applications should not expect to be able to use and only
+rely on the push notification infrastructure to store application
+messages if they want ensure all their notification or messages are
+delivered, the infrastructure is not intended to be the only long term
+"inbox" storage for an application.
+
+To preserve overall throughput the infrastructure imposes some limits
+on applications:
+
+ * message data payload is limited to 2K
+
+ * when inserted all messages need to specify an expiration date after
+   which they can be dropped and not delivered
+
+ * an application is limited in the number of messages per token
+   (application/user/device combination) that can be undelivered/pending at the
+   same time (100 currently)
+
+replace_tag can be used to implement notifications for which the newest
+one replace the previous one if pending.
+
+clear_pending can be used to be deal with a pending message limit
+reached, possibly substituting the current undelivered messages with a
+more generic one.
+
+Applications using the push notification HTTP API should be robust
+against receiving 503 errors, retrying after waiting with increasing
+back-off. Later rate limits (signaled with the 429 status) may also come
+into play.

=== modified file 'docs/example-client/components/ChatClient.qml'
--- docs/example-client/components/ChatClient.qml	2014-09-05 14:40:39 +0000
+++ docs/example-client/components/ChatClient.qml	2015-03-26 16:42:21 +0000
@@ -60,8 +60,8 @@
         if (options["enabled"]) {
             data["data"]["notification"] = {
                 "card": {
-                    "summary": nick + " says: " + message["message"],
-                    "body": "",
+                    "summary": nick + " says:",
+                    "body": message["message"],
                     "popup": options["popup"],
                     "persist": options["persist"],
                     "actions": ["appid://com.ubuntu.developer.ralsina.hello/hello/current-user-version"]

=== modified file 'docs/example-client/helloHelper-apparmor.json'
--- docs/example-client/helloHelper-apparmor.json	2014-09-05 14:40:39 +0000
+++ docs/example-client/helloHelper-apparmor.json	2015-03-26 16:42:21 +0000
@@ -1,4 +1,5 @@
 {
+    "template": "ubuntu-push-helper",
     "policy_groups": [
         "push-notification-client"
     ],

=== modified file 'docs/example-client/main.qml'
--- docs/example-client/main.qml	2014-09-10 14:38:40 +0000
+++ docs/example-client/main.qml	2015-03-26 16:42:21 +0000
@@ -26,9 +26,42 @@
         property alias nickEnabled: nickEdit.enabled
     }
 
+    states: [
+        State {
+            name: "no-push-token"
+            when: (pushClient.token == "")
+            PropertyChanges { target: nickEdit; readOnly: true}
+            PropertyChanges { target: nickEdit; focus: true}
+            PropertyChanges { target: messageEdit; enabled: false}
+            PropertyChanges { target: loginButton; enabled: false}
+            PropertyChanges { target: loginButton; text: "Login"}
+        },
+        State {
+            name: "push-token-not-registered"
+            when: ((pushClient.token != "") && (chatClient.registered == false))
+            PropertyChanges { target: nickEdit; readOnly: false}
+            PropertyChanges { target: nickEdit; text: ""}
+            PropertyChanges { target: nickEdit; focus: true}
+            PropertyChanges { target: messageEdit; enabled: false}
+            PropertyChanges { target: loginButton; enabled: true}
+            PropertyChanges { target: loginButton; text: "Login"}
+        },
+        State {
+            name: "registered"
+            when: ((pushClient.token != "") && (chatClient.registered == true))
+            PropertyChanges { target: nickEdit; readOnly: true}
+            PropertyChanges { target: nickEdit; text: "Your nick is " + chatClient.nick}
+            PropertyChanges { target: messageEdit; focus: true}
+            PropertyChanges { target: messageEdit; enabled: true}
+            PropertyChanges { target: loginButton; enabled: true}
+            PropertyChanges { target: loginButton; text: "Logout"}
+        }
+    ]
+
+    state: "no-push-token"
+
     ChatClient {
         id: chatClient
-        onRegisteredChanged: {nickEdit.registered()}
         onError: {messageList.handle_error(msg)}
         token: pushClient.token
     }
@@ -38,13 +71,16 @@
         Component.onCompleted: {
             notificationsChanged.connect(messageList.handle_notifications)
             error.connect(messageList.handle_error)
+            onTokenChanged: {
+                console.log("foooooo")
+            }
         }
         appId: "com.ubuntu.developer.ralsina.hello_hello"
+
     }
 
     TextField {
         id: nickEdit
-        focus: true
         placeholderText: "Your nickname"
         inputMethodHints: Qt.ImhNoAutoUppercase | Qt.ImhNoPredictiveText | Qt.ImhPreferLowercase
         anchors.left: parent.left
@@ -53,31 +89,17 @@
         anchors.leftMargin: units.gu(.5)
         anchors.rightMargin: units.gu(1)
         anchors.topMargin: units.gu(.5)
-        function registered() {
-            readOnly = true
-            text = "Your nick is " + chatClient.nick
-            messageEdit.focus = true
-            messageEdit.enabled = true
-            loginButton.text = "Logout"
-        }
         onAccepted: { loginButton.clicked() }
     }
 
     Button {
         id: loginButton
-        text: chatClient.rgistered? "Logout": "Login"
         anchors.top: nickEdit.top
         anchors.right: parent.right
         anchors.rightMargin: units.gu(.5)
         onClicked: {
             if (chatClient.nick) { // logout
                 chatClient.nick = ""
-                text = "Login"
-                nickEdit.enabled = true
-                nickEdit.readOnly = false
-                nickEdit.text = ""
-                nickEdit.focus = true
-                messageEdit.enabled = false
             } else { // login
                 chatClient.nick = nickEdit.text
             }
@@ -94,7 +116,6 @@
         anchors.rightMargin: units.gu(.5)
         anchors.leftMargin: units.gu(.5)
         placeholderText: "Your message"
-        enabled: false
         onAccepted: {
             console.log("sending " + text)
             var idx = text.indexOf(":")
@@ -210,7 +231,7 @@
             right: parent.right
             bottom: parent.bottom
         }
-        height: item1.height * 7
+        height: item1.height * 9
         UbuntuShape {
             anchors.fill: parent
             color: Theme.palette.normal.overlay
@@ -268,6 +289,14 @@
                         value: 42
                     }
                 }
+                Button {
+                    text: "Set Counter Via Plugin"
+                    onClicked: { pushClient.count = counterSlider.value; }
+                }
+                Button {
+                    text: "Clear Persistent Notifications"
+                    onClicked: { pushClient.clearPersistent([]); }
+                }
             }
         }
     }

=== modified file 'docs/example-client/manifest.json'
--- docs/example-client/manifest.json	2014-09-10 14:38:31 +0000
+++ docs/example-client/manifest.json	2015-03-26 16:42:21 +0000
@@ -1,7 +1,7 @@
 {
     "architecture": "all",
     "description": "Example app for Ubuntu push notifications.",
-    "framework": "ubuntu-sdk-14.10-dev2",
+    "framework": "ubuntu-sdk-14.10",
     "hooks": {
         "hello": {
             "apparmor": "hello.json",
@@ -15,5 +15,5 @@
     "maintainer": "Roberto Alsina <[e-mail]>",
     "name": "com.ubuntu.developer.ralsina.hello",
     "title": "Hello",
-    "version": "0.4.2"
+    "version": "0.4.4"
 }

=== modified file 'docs/example-server/app.js'
--- docs/example-server/app.js	2014-09-05 14:57:17 +0000
+++ docs/example-server/app.js	2015-03-26 16:42:21 +0000
@@ -182,22 +182,40 @@
     */
     if (cfg.play_notify_form) {
         app.post("/play-notify-form", function(req, resp) {
-            resp.type('text/plain')
-            if (!req.body.data||!req.body.nick) {
-                resp.send(400, "invalid/empty fields\n")
-                return
-            }
-            var data
-            try {
-                data = JSON.parse(req.body.data)
-            } catch(e) {
-                resp.send(400, "data is not JSON\n")
-                return
+            if (!req.body.message||!req.body.nick) {