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

[Roberto Alsina]

Merge changes from ubuntu-push automatic branch:

  * Avoid rare race in kindpool_test.go
  * Interface with account-polld's dbus api.
  * Powerd integration.
  * Use symbolic icon for secondary icon in notification.
  * Log legacy helper failures.

[lp:~ralsina/ubuntu-push/merge-automatic]

121. By PS Jenkins bot on 2014-08-25

* Avoid rare race in kindpool_test.go
* Interface with account-polld's dbus api.
* Powerd integration.
* Use symbolic icon for secondary icon in notification.
* Log legacy helper failures.

=== modified file 'bus/notifications/raw.go'
--- bus/notifications/raw.go	2014-07-27 00:58:08 +0000
+++ bus/notifications/raw.go	2014-08-25 16:38:20 +0000
@@ -144,7 +144,7 @@
 	}
 
 	hints := make(map[string]*dbus.Variant)
-	hints["x-canonical-secondary-icon"] = &dbus.Variant{app.Icon()}
+	hints["x-canonical-secondary-icon"] = &dbus.Variant{app.SymbolicIcon()}
 
 	appId := app.Original()
 	actions := make([]string, 2*len(card.Actions))

=== modified file 'bus/notifications/raw_test.go'
--- bus/notifications/raw_test.go	2014-07-27 00:58:08 +0000
+++ bus/notifications/raw_test.go	2014-08-25 16:38:20 +0000
@@ -210,6 +210,19 @@
 	c.Check(hints["x-canonical-secondary-icon"], NotNil)
 }
 
+func (s *RawSuite) TestPresentUsesSymbolic(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	raw := Raw(endp, s.log)
+	worked := raw.Present(s.app, "notifId", &launch_helper.Notification{Card: &launch_helper.Card{Summary: "summary", Popup: true}})
+	c.Assert(worked, Equals, true)
+	callArgs := testibus.GetCallArgs(endp)
+	c.Assert(callArgs, HasLen, 1)
+	c.Assert(callArgs[0].Args, HasLen, 8)
+	hints, ok := callArgs[0].Args[6].(map[string]*dbus.Variant)
+	c.Assert(ok, Equals, true)
+	c.Check(hints["x-canonical-secondary-icon"].Value.(string), Equals, "-symbolic")
+}
+
 func (s *RawSuite) TestPresentNoNotificationPanics(c *C) {
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, s.log)

=== added directory 'bus/polld'
=== added file 'bus/polld/polld.go'
--- bus/polld/polld.go	1970-01-01 00:00:00 +0000
+++ bus/polld/polld.go	2014-08-25 16:38:20 +0000
@@ -0,0 +1,68 @@
+/*
+ Copyright 2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// Package polld wraps the account-polld dbus interface
+package polld
+
+import (
+	"errors"
+
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+var (
+	ErrUnconfigured = errors.New("unconfigured.")
+)
+
+// polld lives on a well-known bus.Address
+var BusAddress bus.Address = bus.Address{
+	Interface: "com.ubuntu.AccountPolld",
+	Path:      "/com/ubuntu/AccountPolld",
+	Name:      "com.ubuntu.AccountPolld",
+}
+
+type Polld interface {
+	Poll() error
+	WatchDones() (<-chan bool, error)
+}
+
+type polld struct {
+	endp bus.Endpoint
+	log  logger.Logger
+}
+
+func New(endp bus.Endpoint, log logger.Logger) Polld {
+	return &polld{endp, log}
+}
+
+func (p *polld) Poll() error {
+	if p.endp == nil {
+		return ErrUnconfigured
+	}
+	return p.endp.Call("Poll", nil)
+}
+
+func (p *polld) WatchDones() (<-chan bool, error) {
+	if p.endp == nil {
+		return nil, ErrUnconfigured
+	}
+	ch := make(chan bool)
+	p.endp.WatchSignal("Done", func(...interface{}) {
+		ch <- true
+	}, func() { close(ch) })
+	return ch, nil
+}

=== added file 'bus/polld/polld_test.go'
--- bus/polld/polld_test.go	1970-01-01 00:00:00 +0000
+++ bus/polld/polld_test.go	2014-08-25 16:38:20 +0000
@@ -0,0 +1,86 @@
+/*
+ Copyright 2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package polld
+
+import (
+	"testing"
+	"time"
+
+	. "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 TestPolld(t *testing.T) { TestingT(t) }
+
+type PdSuite struct {
+	log *helpers.TestLogger
+}
+
+var _ = Suite(&PdSuite{})
+
+func (s *PdSuite) SetUpTest(c *C) {
+	s.log = helpers.NewTestLogger(c, "debug")
+}
+
+func (s *PdSuite) TestPollWorks(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+	pd := New(endp, s.log)
+	err := pd.Poll()
+	c.Assert(err, IsNil)
+	args := testibus.GetCallArgs(endp)
+	c.Assert(args, HasLen, 1)
+	c.Check(args[0].Member, Equals, "Poll")
+	c.Check(args[0].Args, IsNil)
+}
+
+func (s *PdSuite) TestPollUnconfigured(c *C) {
+	c.Check(new(polld).Poll(), Equals, ErrUnconfigured)
+}
+
+func (s *PdSuite) TestPollFails(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+	pd := New(endp, s.log)
+	c.Check(pd.Poll(), NotNil)
+}
+
+func (s *PdSuite) TestWatchDonesWorks(c *C) {
+	endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{})
+	pd := New(endp, s.log)
+	ch, err := pd.WatchDones()
+	c.Assert(err, IsNil)
+	select {
+	case b := <-ch:
+		c.Check(b, Equals, true)
+	case <-time.After(100 * time.Millisecond):
+		c.Error("timeout waiting for bool")
+	}
+	select {
+	case b := <-ch:
+		c.Check(b, Equals, false)
+	case <-time.After(100 * time.Millisecond):
+		c.Error("timeout waiting for close")
+	}
+}
+
+func (s *PdSuite) TestWatchDonesUnconfigured(c *C) {
+	_, err := new(polld).WatchDones()
+	c.Check(err, Equals, ErrUnconfigured)
+}

=== added directory 'bus/powerd'
=== added file 'bus/powerd/powerd.go'
--- bus/powerd/powerd.go	1970-01-01 00:00:00 +0000
+++ bus/powerd/powerd.go	2014-08-25 16:38:20 +0000
@@ -0,0 +1,101 @@
+/*
+ Copyright 2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// Package powerd is an interface to powerd via dbus.
+package powerd
+
+import (
+	"errors"
+	"time"
+
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+// powerd lives on a well-known bus.Address
+var BusAddress bus.Address = bus.Address{
+	Interface: "com.canonical.powerd",
+	Path:      "/com/canonical/powerd",
+	Name:      "com.canonical.powerd",
+}
+
+// Powerd exposes a subset of powerd
+type Powerd interface {
+	RequestWakeup(name string, wakeupTime time.Time) (string, error)
+	ClearWakeup(cookie string) error
+	WatchWakeups() (<-chan bool, error)
+	RequestWakelock(name string) (string, error)
+	ClearWakelock(cookie string) error
+}
+
+type powerd struct {
+	endp bus.Endpoint
+	log  logger.Logger
+}
+
+var (
+	ErrUnconfigured = errors.New("unconfigured.")
+)
+
+// New builds a new Powerd that uses the provided bus.Endpoint
+func New(endp bus.Endpoint, log logger.Logger) Powerd {
+	return &powerd{endp, log}
+}
+
+func (p *powerd) RequestWakeup(name string, wakeupTime time.Time) (string, error) {
+	if p.endp == nil {
+		return "", ErrUnconfigured
+	}
+	var res string
+	err := p.endp.Call("requestWakeup", bus.Args(name, uint64(wakeupTime.Unix())), &res)
+	return res, err
+}
+
+func (p *powerd) ClearWakeup(cookie string) error {
+	if p.endp == nil {
+		return ErrUnconfigured
+	}
+	return p.endp.Call("clearWakeup", bus.Args(cookie))
+}
+
+func (p *powerd) WatchWakeups() (<-chan bool, error) {
+	if p.endp == nil {
+		return nil, ErrUnconfigured
+	}
+	ch := make(chan bool)
+	p.endp.WatchSignal("Wakeup", func(...interface{}) {
+		ch <- true
+	}, func() { close(ch) })
+	return ch, nil
+}
+
+func (p *powerd) RequestWakelock(name string) (string, error) {
+	// wakelocks are documented on https://wiki.ubuntu.com/powerd#API
+	// (requestSysState with state=1)
+	if p.endp == nil {
+		return "", ErrUnconfigured
+	}
+	var res string
+	err := p.endp.Call("requestSysState", bus.Args(name, int32(1)), &res)
+	return res, err
+}
+
+func (p *powerd) ClearWakelock(cookie string) error {
+	if p.endp == nil {
+		return ErrUnconfigured
+	}
+	return p.endp.Call("clearSysState", bus.Args(cookie))
+}

=== added file 'bus/powerd/powerd_test.go'
--- bus/powerd/powerd_test.go	1970-01-01 00:00:00 +0000
+++ bus/powerd/powerd_test.go	2014-08-25 16:38:20 +0000
@@ -0,0 +1,161 @@
+/*
+ Copyright 2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package powerd
+
+import (
+	"testing"
+	"time"
+
+	. "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 TestPowerd(t *testing.T) { TestingT(t) }
+
+type PdSuite struct {
+	log *helpers.TestLogger
+}
+
+var _ = Suite(&PdSuite{})
+
+func (s *PdSuite) SetUpTest(c *C) {
+	s.log = helpers.NewTestLogger(c, "debug")
+}
+
+func (s *PdSuite) TestRequestWakeupWorks(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), "cookie")
+	pd := New(endp, s.log)
+	t := time.Now().Add(5 * time.Minute)
+	ck, err := pd.RequestWakeup("name", t)
+	c.Assert(err, IsNil)
+	c.Check(ck, Equals, "cookie")
+	args := testibus.GetCallArgs(endp)
+	c.Assert(args, HasLen, 1)
+	c.Check(args[0].Member, Equals, "requestWakeup")
+	c.Check(args[0].Args, DeepEquals, []interface{}{"name", uint64(t.Unix())})
+}
+
+func (s *PdSuite) TestRequestWakeupUnconfigured(c *C) {
+	_, err := new(powerd).RequestWakeup("name", time.Now())
+	c.Assert(err, Equals, ErrUnconfigured)
+}
+
+func (s *PdSuite) TestRequestWakeupFails(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+	pd := New(endp, s.log)
+	t := time.Now().Add(5 * time.Minute)
+	_, err := pd.RequestWakeup("name", t)
+	c.Assert(err, NotNil)
+}
+
+func (s *PdSuite) TestClearWakeupWorks(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+	pd := New(endp, s.log)
+	err := pd.ClearWakeup("cookie")
+	c.Assert(err, IsNil)
+	args := testibus.GetCallArgs(endp)
+	c.Assert(args, HasLen, 1)
+	c.Check(args[0].Member, Equals, "clearWakeup")
+	c.Check(args[0].Args, DeepEquals, []interface{}{"cookie"})
+}
+
+func (s *PdSuite) TestClearWakeupUnconfigured(c *C) {
+	err := new(powerd).ClearWakeup("cookie")
+	c.Assert(err, Equals, ErrUnconfigured)
+}
+
+func (s *PdSuite) TestClearWakeupFails(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+	pd := New(endp, s.log)
+	err := pd.ClearWakeup("cookie")
+	c.Assert(err, NotNil)
+}
+
+func (s *PdSuite) TestRequestWakelockWorks(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), "cookie")
+	pd := New(endp, s.log)
+	ck, err := pd.RequestWakelock("name")
+	c.Assert(err, IsNil)
+	c.Check(ck, Equals, "cookie")
+	args := testibus.GetCallArgs(endp)
+	c.Assert(args, HasLen, 1)
+	// wakelocks are documented on https://wiki.ubuntu.com/powerd#API
+	c.Check(args[0].Member, Equals, "requestSysState")
+	c.Check(args[0].Args, DeepEquals, []interface{}{"name", int32(1)})
+}
+
+func (s *PdSuite) TestRequestWakelockUnconfigured(c *C) {
+	_, err := new(powerd).RequestWakelock("name")
+	c.Assert(err, Equals, ErrUnconfigured)
+}
+
+func (s *PdSuite) TestRequestWakelockFails(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+	pd := New(endp, s.log)
+	_, err := pd.RequestWakelock("name")
+	c.Assert(err, NotNil)
+}
+
+func (s *PdSuite) TestClearWakelockWorks(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
+	pd := New(endp, s.log)
+	err := pd.ClearWakelock("cookie")
+	c.Assert(err, IsNil)
+	args := testibus.GetCallArgs(endp)
+	c.Assert(args, HasLen, 1)
+	c.Check(args[0].Member, Equals, "clearSysState")
+	c.Check(args[0].Args, DeepEquals, []interface{}{"cookie"})
+}
+
+func (s *PdSuite) TestClearWakelockUnconfigured(c *C) {
+	c.Check(new(powerd).ClearWakelock("cookie"), NotNil)
+}
+
+func (s *PdSuite) TestClearWakelockFails(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+	pd := New(endp, s.log)
+	err := pd.ClearWakelock("cookie")
+	c.Assert(err, NotNil)
+}
+
+func (s *PdSuite) TestWatchWakeupsWorks(c *C) {
+	endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{})
+	pd := New(endp, s.log)
+	ch, err := pd.WatchWakeups()
+	c.Assert(err, IsNil)
+	select {
+	case b := <-ch:
+		c.Check(b, Equals, true)
+	case <-time.After(100 * time.Millisecond):
+		c.Error("timeout waiting for bool")
+	}
+	select {
+	case b := <-ch:
+		c.Check(b, Equals, false)
+	case <-time.After(100 * time.Millisecond):
+		c.Error("timeout waiting for close")
+	}
+}
+
+func (s *PdSuite) TestWatchWakeupsUnconfigured(c *C) {
+	_, err := new(powerd).WatchWakeups()
+	c.Check(err, Equals, ErrUnconfigured)
+}

=== modified file 'click/click.go'
--- click/click.go	2014-08-06 02:44:06 +0000
+++ click/click.go	2014-08-25 16:38:20 +0000
@@ -136,6 +136,19 @@
 	return cappinfo.AppIconFromDesktopId(app.DesktopId())
 }
 
+func _symbolic(icon string) string {
+	if strings.ContainsRune(icon, '/') {
+		return icon
+	}
+	return icon + "-symbolic"
+}
+
+var symbolic = _symbolic
+
+func (app *AppId) SymbolicIcon() string {
+	return symbolic(app.Icon())
+}
+
 func (app *AppId) MarshalJSON() ([]byte, error) {
 	return json.Marshal(app.Original())
 }

=== modified file 'click/click_test.go'
--- click/click_test.go	2014-08-06 03:50:14 +0000
+++ click/click_test.go	2014-08-25 16:38:20 +0000
@@ -182,3 +182,21 @@
 	c.Check(app, NotNil)
 	c.Check(app.Original(), Equals, "_non-existent-app")
 }
+
+func (s *clickSuite) TestSymbolicAppendsSymbolicIfIconIsName(c *C) {
+	symb := symbolic("foo")
+	c.Check(symb, Equals, "foo-symbolic")
+}
+
+func (s *clickSuite) TestSymbolicLeavesAloneIfIconIsPath(c *C) {
+	symb := symbolic("foo/bar")
+	c.Check(symb, Equals, "foo/bar")
+}
+
+func (s *clickSuite) TestSymbolicIconCallsSymbolic(c *C) {
+	symbolic = func(string) string { return "xyzzy" }
+	defer func() { symbolic = _symbolic }()
+	app, err := ParseAppId("_python3.4")
+	c.Assert(err, IsNil)
+	c.Check(app.SymbolicIcon(), Equals, "xyzzy")
+}

=== modified file 'client/client.go'
--- client/client.go	2014-08-12 00:32:32 +0000
+++ client/client.go	2014-08-25 16:38:20 +0000
@@ -44,6 +44,7 @@
 	"launchpad.net/ubuntu-push/identifier"
 	"launchpad.net/ubuntu-push/launch_helper"
 	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/poller"
 	"launchpad.net/ubuntu-push/protocol"
 	"launchpad.net/ubuntu-push/util"
 )
@@ -71,6 +72,12 @@
 	// fallback values for simplified notification usage
 	FallbackVibration *launch_helper.Vibration `json:"fallback_vibration"`
 	FallbackSound     string                   `json:"fallback_sound"`
+	// times for the poller
+	PollInterval    config.ConfigTimeDuration `json:"poll_interval"`
+	PollSettle      config.ConfigTimeDuration `json:"poll_settle"`
+	PollNetworkWait config.ConfigTimeDuration `json:"poll_net_wait"`
+	PollPolldWait   config.ConfigTimeDuration `json:"poll_polld_wait"`
+	PollDoneWait    config.ConfigTimeDuration `json:"poll_done_wait"`
 }
 
 // PushService is the interface we use of service.PushService.
@@ -115,6 +122,7 @@
 	unregisterCh       chan *click.AppId
 	trackAddressees    map[string]*click.AppId
 	installedChecker   click.InstalledChecker
+	poller             poller.Poller
 }
 
 // Creates a new Ubuntu Push Notifications client-side daemon that will use
@@ -221,6 +229,21 @@
 	}
 }
 
+// derivePollerSetup derives the Poller setup from the client configuration bits.
+func (client *PushClient) derivePollerSetup() *poller.PollerSetup {
+	return &poller.PollerSetup{
+		Times: poller.Times{
+			AlarmInterval:      client.config.PollInterval.TimeDuration(),
+			SessionStateSettle: client.config.PollSettle.TimeDuration(),
+			NetworkWait:        client.config.PollNetworkWait.TimeDuration(),
+			PolldWait:          client.config.PollPolldWait.TimeDuration(),
+			DoneWait:           client.config.PollDoneWait.TimeDuration(),
+		},
+		Log:                client.log,
+		SessionStateGetter: client.session,
+	}
+}
+
 // getAuthorization gets the authorization blob to send to the server
 func (client *PushClient) getAuthorization(url string) string {
 	client.log.Debugf("getting authorization for %s", url)
@@ -266,8 +289,8 @@
 	return err
 }
 
-// initSession creates the session object
-func (client *PushClient) initSession() error {
+// initSessionAndPoller creates the session and the poller objects
+func (client *PushClient) initSessionAndPoller() error {
 	info := map[string]interface{}{
 		"device":       client.systemImageInfo.Device,
 		"channel":      client.systemImageInfo.Channel,
@@ -280,6 +303,18 @@
 		return err
 	}
 	client.session = sess
+	client.poller = poller.New(client.derivePollerSetup())
+	return nil
+}
+
+// runPoller starts and runs the poller
+func (client *PushClient) runPoller() error {
+	if err := client.poller.Start(); err != nil {
+		return err
+	}
+	if err := client.poller.Run(); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -509,6 +544,7 @@
 		client.startPushService,
 		client.startPostalService,
 		client.takeTheBus,
-		client.initSession,
+		client.initSessionAndPoller,
+		client.runPoller,
 	)
 }

=== modified file 'client/client_test.go'
--- client/client_test.go	2014-08-12 00:32:32 +0000
+++ client/client_test.go	2014-08-25 16:38:20 +0000
@@ -45,6 +45,7 @@
 	"launchpad.net/ubuntu-push/identifier"
 	idtesting "launchpad.net/ubuntu-push/identifier/testing"
 	"launchpad.net/ubuntu-push/launch_helper"
+	"launchpad.net/ubuntu-push/poller"
 	"launchpad.net/ubuntu-push/protocol"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
@@ -143,7 +144,11 @@
 
 func (cs *clientSuite) SetUpSuite(c *C) {
 	config.IgnoreParsedFlags = true // because configure() uses <flags>
-	newIdentifier = func() (identifier.Id, error) { return idtesting.Settable(), nil }
+	newIdentifier = func() (identifier.Id, error) {
+		id := idtesting.Settable()
+		id.Set("42") // must be hex of len 32
+		return id, nil
+	}
 	cs.timeouts = util.SwapTimeouts([]time.Duration{0})
 	cs.leveldbPath = ""
 }
@@ -173,6 +178,11 @@
 		"session_url":      "xyzzy://",
 		"registration_url": "reg://",
 		"log_level":        "debug",
+		"poll_interval":    "5m",
+		"poll_settle":      "20ms",
+		"poll_net_wait":    "1m",
+		"poll_polld_wait":  "3m",
+		"poll_done_wait":   "5s",
 	}
 	for k, v := range overrides {
 		cfgMap[k] = v
@@ -502,6 +512,39 @@
 }
 
 /*****************************************************************
+    derivePollerSetup tests
+******************************************************************/
+func (cs *clientSuite) TestDerivePollerSetup(c *C) {
+	cs.writeTestConfig(map[string]interface{}{})
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.session = new(session.ClientSession)
+	err := cli.configure()
+	c.Assert(err, IsNil)
+	expected := &poller.PollerSetup{
+		Times: poller.Times{
+			AlarmInterval:      5 * time.Minute,
+			SessionStateSettle: 20 * time.Millisecond,
+			NetworkWait:        time.Minute,
+			PolldWait:          3 * time.Minute,
+			DoneWait:           5 * time.Second,
+		},
+		Log:                cli.log,
+		SessionStateGetter: cli.session,
+	}
+	// sanity check that we are looking at all fields
+	vExpected := reflect.ValueOf(expected).Elem()
+	nf := vExpected.NumField()
+	for i := 0; i < nf; i++ {
+		fv := vExpected.Field(i)
+		// field isn't empty/zero
+		c.Assert(fv.Interface(), Not(DeepEquals), reflect.Zero(fv.Type()).Interface(), Commentf("forgot about: %s", vExpected.Type().Field(i).Name))
+	}
+	// finally compare
+	setup := cli.derivePollerSetup()
+	c.Check(setup, DeepEquals, expected)
+}
+
+/*****************************************************************
     startService tests
 ******************************************************************/
 
@@ -653,7 +696,7 @@
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
-	c.Assert(cli.initSession(), IsNil)
+	c.Assert(cli.initSessionAndPoller(), IsNil)
 	cs.log.ResetCapture()
 	cli.hasConnectivity = true
 	cli.handleErr(errors.New("bananas"))
@@ -686,7 +729,7 @@
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
-	c.Assert(cli.initSession(), IsNil)
+	c.Assert(cli.initSessionAndPoller(), IsNil)
 
 	c.Assert(cli.hasConnectivity, Equals, false)
 	cli.handleConnState(true)
@@ -958,7 +1001,7 @@
 	cli.systemImageInfo = siInfoRes
 	cli.connCh = make(chan bool, 1)
 	cli.connCh <- true
-	c.Assert(cli.initSession(), IsNil)
+	c.Assert(cli.initSessionAndPoller(), IsNil)
 
 	ch := make(chan bool, 1)
 	go cli.doLoop(func(bool) { ch <- true }, nopBcast, nopUcast, nopError, nopUnregister)
@@ -969,7 +1012,7 @@
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
-	c.Assert(cli.initSession(), IsNil)
+	c.Assert(cli.initSessionAndPoller(), IsNil)
 	cli.session.BroadcastCh = make(chan *session.BroadcastNotification, 1)
 	cli.session.BroadcastCh <- &session.BroadcastNotification{}
 
@@ -982,7 +1025,7 @@
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
-	c.Assert(cli.initSession(), IsNil)
+	c.Assert(cli.initSessionAndPoller(), IsNil)
 	cli.session.NotificationsCh = make(chan session.AddressedNotification, 1)
 	cli.session.NotificationsCh <- session.AddressedNotification{}
 
@@ -995,7 +1038,7 @@
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
-	c.Assert(cli.initSession(), IsNil)
+	c.Assert(cli.initSessionAndPoller(), IsNil)
 	cli.session.ErrCh = make(chan error, 1)
 	cli.session.ErrCh <- nil
 
@@ -1008,7 +1051,7 @@
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
-	c.Assert(cli.initSession(), IsNil)
+	c.Assert(cli.initSessionAndPoller(), IsNil)
 	cli.unregisterCh = make(chan *click.AppId, 1)
 	cli.unregisterCh <- app1
 
@@ -1060,7 +1103,7 @@
 	cli.postalService = d
 	c.Assert(cli.startPostalService(), IsNil)
 
-	c.Assert(cli.initSession(), IsNil)
+	c.Assert(cli.initSessionAndPoller(), IsNil)
 
 	cli.session.BroadcastCh = make(chan *session.BroadcastNotification)
 	cli.session.ErrCh = make(chan error)
@@ -1141,7 +1184,7 @@
 	// and now everthing is better! We have a config,
 	c.Check(string(cli.config.Addr), Equals, ":0")
 	// and a device id,
-	c.Check(cli.deviceId, HasLen, 32)
+	c.Check(cli.deviceId, HasLen, 40)
 	// and a session,
 	c.Check(cli.session, NotNil)
 	// and a bus,
@@ -1161,13 +1204,13 @@
 	c.Check(err, NotNil)
 }
 
-func (cs *clientSuite) TestInitSessionErr(c *C) {
+func (cs *clientSuite) TestinitSessionAndPollerErr(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
 	cli.systemImageInfo = siInfoRes
-	// change the cli.pem value so initSession fails
+	// change the cli.pem value so initSessionAndPoller fails
 	cli.pem = []byte("foo")
-	c.Assert(cli.initSession(), NotNil)
+	c.Assert(cli.initSessionAndPoller(), NotNil)
 }
 
 /*****************************************************************

=== modified file 'debian/changelog'
--- debian/changelog	2014-08-12 02:33:16 +0000
+++ debian/changelog	2014-08-25 16:38:20 +0000
@@ -1,3 +1,18 @@
+ubuntu-push (0.62) UNRELEASED; urgency=medium
+
+  [ Samuele Pedroni ]
+  * Avoid rare race in kindpool_test.go
+
+  [ John R. Lenton]
+  * Interface with account-polld's dbus api.
+  * Powerd integration.
+  * Use symbolic icon for secondary icon in notification.
+
+  [Roberto Alsina]
+  * Log legacy helper failures.
+
+ -- Roberto Alsina <ralsina@yoga>  Fri, 22 Aug 2014 16:00:31 -0300
+
 ubuntu-push (0.61+14.10.20140812.4-0ubuntu1) utopic; urgency=medium
 
   [ Guillermo Gonzalez ]
@@ -13,7 +28,7 @@
   * Make messaging menu entries show current time instead of epoch for timestamp of 0.
   * Tweak the upstart script, start after unity.
   * Correctly report invalid app ids, missing apps, and package/app id mismatches as separate errors over dbus.
-  
+
   [Roberto Alsina]
   * Check that sound paths don't go up into the tree.
   * Initial draft of QML-based doc

=== modified file 'debian/config.json'
--- debian/config.json	2014-08-08 09:03:42 +0000
+++ debian/config.json	2014-08-25 16:38:20 +0000
@@ -14,5 +14,10 @@
     "connectivity_check_md5": "4589f42e1546aa47ca181e5d949d310b",
     "log_level": "debug",
     "fallback_vibration": {"pattern": [100, 100], "repeat": 2},
-    "fallback_sound": "sounds/ubuntu/notifications/Slick.ogg"
+    "fallback_sound": "sounds/ubuntu/notifications/Slick.ogg",
+    "poll_interval": "5m",
+    "poll_settle":      "20ms",
+    "poll_net_wait":    "1m",
+    "poll_polld_wait":  "3m",
+    "poll_done_wait":   "5s"
 }

=== modified file 'dependencies.tsv'
--- dependencies.tsv	2014-07-26 07:28:59 +0000
+++ dependencies.tsv	2014-08-25 16:38:20 +0000
@@ -1,5 +1,5 @@
 code.google.com/p/go-uuid	hg	7dda39b2e7d5e265014674c5af696ba4186679e9	11
 code.google.com/p/gosqlite	hg	74691fb6f83716190870cde1b658538dd4b18eb0	15
-launchpad.net/go-dbus/v1	bzr	[e-mail]-20140530132806-hpqbkxczif6o1dpz	127
+launchpad.net/go-dbus/v1	bzr	[e-mail]-20140801110939-lzfql7fk76dt6ckd	128
 launchpad.net/go-xdg/v0	bzr	[e-mail]-20140208094800-gubd5md7cro3mtxa	10
 launchpad.net/gocheck	bzr	[e-mail]-20140225173054-xu9zlkf9kxhvow02	87

=== modified file 'launch_helper/kindpool.go'
--- launch_helper/kindpool.go	2014-07-29 15:24:01 +0000
+++ launch_helper/kindpool.go	2014-08-25 16:38:20 +0000
@@ -72,7 +72,7 @@
 func DefaultLaunchers(log logger.Logger) map[string]HelperLauncher {
 	return map[string]HelperLauncher{
 		"click":  cual.New(log),
-		"legacy": legacy.New(),
+		"legacy": legacy.New(log),
 	}
 }
 

=== modified file 'launch_helper/kindpool_test.go'
--- launch_helper/kindpool_test.go	2014-08-08 09:03:42 +0000
+++ launch_helper/kindpool_test.go	2014-08-25 16:38:20 +0000
@@ -102,16 +102,22 @@
 	return args
 }
 
+func (s *poolSuite) SetUpSuite(c *C) {
+	xdgCacheHome = c.MkDir
+}
+
+func (s *poolSuite) TearDownSuite(c *C) {
+	xdgCacheHome = xdg.Cache.Home
+}
+
 func (s *poolSuite) SetUpTest(c *C) {
 	s.log = helpers.NewTestLogger(c, "debug")
 	s.fakeLauncher = &fakeHelperLauncher{argCh: make(chan [5]string, 10)}
 	s.pool = NewHelperPool(map[string]HelperLauncher{"fake": s.fakeLauncher}, s.log)
-	xdgCacheHome = c.MkDir
 }
 
 func (s *poolSuite) TearDownTest(c *C) {
 	s.pool = nil
-	xdgCacheHome = xdg.Cache.Home
 }
 
 func (s *poolSuite) TestDefaultLaunchers(c *C) {
@@ -379,8 +385,9 @@
 }
 
 func (s *poolSuite) TestGetTempFilename(c *C) {
+	tmpDir := c.MkDir()
 	GetTempDir = func(pkgName string) (string, error) {
-		return c.MkDir(), nil
+		return tmpDir, nil
 	}
 	// restore it when we are done
 	defer func() {

=== modified file 'launch_helper/legacy/legacy.go'
--- launch_helper/legacy/legacy.go	2014-07-18 20:45:21 +0000
+++ launch_helper/legacy/legacy.go	2014-08-25 16:38:20 +0000
@@ -18,20 +18,23 @@
 package legacy
 
 import (
+	"bytes"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strconv"
 
 	"launchpad.net/ubuntu-push/click"
+	"launchpad.net/ubuntu-push/logger"
 )
 
 type legacyHelperLauncher struct {
+	log  logger.Logger
 	done func(string)
 }
 
-func New() *legacyHelperLauncher {
-	return new(legacyHelperLauncher)
+func New(log logger.Logger) *legacyHelperLauncher {
+	return &legacyHelperLauncher{log: log}
 }
 
 func (lhl *legacyHelperLauncher) InstallObserver(done func(string)) error {
@@ -47,27 +50,42 @@
 
 func (*legacyHelperLauncher) RemoveObserver() error { return nil }
 
+type msg struct {
+	id  string
+	err error
+}
+
 func (lhl *legacyHelperLauncher) Launch(_, progname, f1, f2 string) (string, error) {
-	cmd := exec.Command(progname, f1, f2)
-	cmd.Stdin = nil
-	cmd.Stdout = nil
-	cmd.Stderr = nil
+	comm := make(chan msg)
 
-	err := cmd.Start()
-	if err != nil {
-		return "", err
-	}
-	proc := cmd.Process
-	if proc == nil {
-		panic("cmd.Process is nil after successful cmd.Start()??")
-	}
-	id := strconv.FormatInt((int64)(proc.Pid), 36)
 	go func() {
-		proc.Wait()
+		cmd := exec.Command(progname, f1, f2)
+		var stdout bytes.Buffer
+		cmd.Stdout = &stdout
+		var stderr bytes.Buffer
+		cmd.Stderr = &stderr
+		err := cmd.Start()
+		if err != nil {
+			comm <- msg{"", err}
+			return
+		}
+		proc := cmd.Process
+		if proc == nil {
+			panic("cmd.Process is nil after successful cmd.Start()??")
+		}
+		id := strconv.FormatInt((int64)(proc.Pid), 36)
+		comm <- msg{id, nil}
+		p_err := cmd.Wait()
+		if p_err != nil {
+			// Helper failed or got killed, log output/errors
+			lhl.log.Errorf("Legacy helper failed: %v", p_err)
+			lhl.log.Errorf("Legacy helper failed. Stdout: %s", stdout)
+			lhl.log.Errorf("Legacy helper failed. Stderr: %s", stderr)
+		}
 		lhl.done(id)
 	}()
-
-	return id, nil
+	msg := <-comm
+	return msg.id, msg.err
 }
 
 func (lhl *legacyHelperLauncher) Stop(_, id string) error {

=== modified file 'launch_helper/legacy/legacy_test.go'
--- launch_helper/legacy/legacy_test.go	2014-07-18 20:45:21 +0000
+++ launch_helper/legacy/legacy_test.go	2014-08-25 16:38:20 +0000
@@ -32,7 +32,7 @@
 	select {
 	case s := <-ch:
 		return s
-	case <-time.After(time.Second):
+	case <-time.After(5 * time.Second):
 		c.Fatal("timed out waiting for value")
 		return ""
 	}
@@ -42,12 +42,14 @@
 
 type legacySuite struct {
 	lhl *legacyHelperLauncher
+	log *helpers.TestLogger
 }
 
 var _ = Suite(&legacySuite{})
 
 func (ls *legacySuite) SetUpTest(c *C) {
-	ls.lhl = New()
+	ls.log = helpers.NewTestLogger(c, "info")
+	ls.lhl = New(ls.log)
 }
 
 func (ls *legacySuite) TestInstallObserver(c *C) {
@@ -94,12 +96,39 @@
 	c.Assert(err, NotNil)
 }
 
+func (ls *legacySuite) TestHelperFails(c *C) {
+	ch := make(chan string, 1)
+	c.Assert(ls.lhl.InstallObserver(func(id string) { ch <- id }), IsNil)
+
+	_, err := ls.lhl.Launch("", "/bin/false", "", "")
+	c.Assert(err, IsNil)
+
+	takeNext(ch, c)
+	c.Check(ls.log.Captured(), Matches, "(?s).*Legacy helper failed.*")
+}
+
+func (ls *legacySuite) TestHelperFailsLog(c *C) {
+	ch := make(chan string, 1)
+	c.Assert(ls.lhl.InstallObserver(func(id string) { ch <- id }), IsNil)
+
+	exe := helpers.ScriptAbsPath("noisy-helper.sh")
+	_, err := ls.lhl.Launch("", exe, "", "")
+	c.Assert(err, IsNil)
+
+	takeNext(ch, c)
+	c.Check(ls.log.Captured(), Matches, "(?s).*BOOM-1.*")
+	c.Check(ls.log.Captured(), Matches, "(?s).*BANG-1.*")
+	c.Check(ls.log.Captured(), Matches, "(?s).*BOOM-20.*")
+	c.Check(ls.log.Captured(), Matches, "(?s).*BANG-20.*")
+}
+
 func (ls *legacySuite) TestStop(c *C) {
 	ch := make(chan string, 1)
 	c.Assert(ls.lhl.InstallObserver(func(id string) { ch <- id }), IsNil)
 
-	exe := helpers.ScriptAbsPath("slow-helper.sh")
-	id, err := ls.lhl.Launch("", exe, "", "")
+	// 	exe := helpers.ScriptAbsPath("slow-helper.sh")
+	id, err := ls.lhl.Launch("", "/bin/sleep", "9", "1")
+	c.Assert(err, IsNil)
 
 	err = ls.lhl.Stop("", "===")
 	c.Check(err, NotNil) // not a valid id

=== added directory 'poller'
=== added file 'poller/poller.go'
--- poller/poller.go	1970-01-01 00:00:00 +0000
+++ poller/poller.go	2014-08-25 16:38:20 +0000
@@ -0,0 +1,220 @@
+/*
+ Copyright 2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// Package poller implements Poller, a thing that uses (hw) alarms to
+// wake the device up from deep sleep periodically, check for
+// notifications, and poke polld.
+package poller
+
+import (
+	"errors"
+	"sync"
+	"time"
+
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/bus/polld"
+	"launchpad.net/ubuntu-push/bus/powerd"
+	"launchpad.net/ubuntu-push/client/session"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/util"
+)
+
+var (
+	ErrUnconfigured   = errors.New("not configured")
+	ErrAlreadyStarted = errors.New("already started")
+	ErrNotStarted     = errors.New("not started")
+)
+
+type stater interface {
+	State() session.ClientSessionState
+}
+
+type Times struct {
+	AlarmInterval      time.Duration
+	SessionStateSettle time.Duration
+	NetworkWait        time.Duration
+	PolldWait          time.Duration
+	DoneWait           time.Duration
+}
+
+type Poller interface {
+	IsConnected() bool
+	Start() error
+	Run() error
+}
+
+type PollerSetup struct {
+	Times              Times
+	Log                logger.Logger
+	SessionStateGetter stater
+}
+
+type poller struct {
+	times        Times
+	log          logger.Logger
+	powerd       powerd.Powerd
+	polld        polld.Polld
+	cookie       string
+	sessionState stater
+}
+
+func New(setup *PollerSetup) Poller {
+	return &poller{
+		times:        setup.Times,
+		log:          setup.Log,
+		powerd:       nil,
+		polld:        nil,
+		sessionState: setup.SessionStateGetter,
+	}
+}
+
+func (p *poller) IsConnected() bool {
+	return p.sessionState.State() == session.Running
+}
+
+func (p *poller) Start() error {
+	if p.log == nil {
+		return ErrUnconfigured
+	}
+	if p.powerd != nil || p.polld != nil {
+		return ErrAlreadyStarted
+	}
+	powerdEndp := bus.SystemBus.Endpoint(powerd.BusAddress, p.log)
+	polldEndp := bus.SessionBus.Endpoint(polld.BusAddress, p.log)
+	var wg sync.WaitGroup
+	wg.Add(2)
+	go func() {
+		n := util.NewAutoRedialer(powerdEndp).Redial()
+		p.log.Debugf("powerd dialed on try %d", n)
+		wg.Done()
+	}()
+	go func() {
+		n := util.NewAutoRedialer(polldEndp).Redial()
+		p.log.Debugf("polld dialed in on try %d", n)
+		wg.Done()
+	}()
+	wg.Wait()
+
+	p.powerd = powerd.New(powerdEndp, p.log)
+	p.polld = polld.New(polldEndp, p.log)
+
+	return nil
+}
+
+func (p *poller) Run() error {
+	if p.log == nil {
+		return ErrUnconfigured
+	}
+	if p.powerd == nil || p.polld == nil {
+		return ErrNotStarted
+	}
+	wakeupCh, err := p.powerd.WatchWakeups()
+	if err != nil {
+		return err
+	}
+	doneCh, err := p.polld.WatchDones()
+	if err != nil {
+		return err
+	}
+	go p.run(wakeupCh, doneCh)
+	return nil
+}
+
+func (p *poller) run(wakeupCh <-chan bool, doneCh <-chan bool) {
+	var lockCookie string
+
+	for {
+		lockCookie = p.step(wakeupCh, doneCh, lockCookie)
+	}
+}
+
+func (p *poller) step(wakeupCh <-chan bool, doneCh <-chan bool, lockCookie string) string {
+
+	t := time.Now().Add(p.times.AlarmInterval).Truncate(time.Second)
+	_, err := p.powerd.RequestWakeup("ubuntu push client", t)
+	if err != nil {
+		p.log.Errorf("RequestWakeup got %v", err)
+		return lockCookie
+	}
+	p.log.Debugf("requested wakeup at %s", t)
+	if lockCookie != "" {
+		if err := p.powerd.ClearWakelock(lockCookie); err != nil {
+			p.log.Errorf("ClearWakelock(%#v) got %v", lockCookie, err)
+		} else {
+			p.log.Debugf("cleared wakelock cookie %s.", lockCookie)
+		}
+		lockCookie = ""
+	}
+	for b := range wakeupCh {
+		if !b {
+			panic("WatchWakeups channel produced a false value (??)")
+		}
+		// the channel will produce a true for every
+		// wakeup, not only the one we asked for
+		now := time.Now()
+		p.log.Debugf("got woken up; time is %s", now)
+		if !now.Before(t) {
+			break
+		}
+	}
+	lockCookie, err = p.powerd.RequestWakelock("ubuntu push client")
+	if err != nil {
+		p.log.Errorf("RequestWakelock got %v", err)
+		return lockCookie
+	}
+	p.log.Debugf("got wakelock cookie of %s", lockCookie)
+	time.Sleep(p.times.SessionStateSettle)
+	for i := 0; i < 20; i++ {
+		if p.IsConnected() {
+			break
+		}
+		time.Sleep(p.times.NetworkWait / 20)
+	}
+	if !p.IsConnected() {
+		p.log.Errorf("not connected after %s; giving up", p.times.NetworkWait)
+	} else {
+		p.log.Debugf("poking polld.")
+		// drain the doneCH
+	drain:
+		for {
+			select {
+			case <-doneCh:
+			default:
+				break drain
+			}
+		}
+
+		if err := p.polld.Poll(); err != nil {
+			p.log.Errorf("Poll got %v", err)
+		} else {
+			p.log.Debugf("waiting for polld to signal Done.")
+			select {
+			case b := <-doneCh:
+				if !b {
+					panic("WatchDones channel produced a false value (??)")
+				}
+				p.log.Debugf("polld Done.")
+			case <-time.After(p.times.PolldWait):
+				p.log.Errorf("polld still not done after %s; giving up", p.times.PolldWait)
+			}
+		}
+
+		// XXX check whether something was actually done before waiting
+		time.Sleep(p.times.DoneWait)
+	}
+
+	return lockCookie
+}

=== added file 'poller/poller_test.go'
--- poller/poller_test.go	1970-01-01 00:00:00 +0000
+++ poller/poller_test.go	2014-08-25 16:38:20 +0000
@@ -0,0 +1,114 @@
+/*
+ Copyright 2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package poller
+
+import (
+	"testing"
+	"time"
+
+	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/client/session"
+	helpers "launchpad.net/ubuntu-push/testing"
+)
+
+// hook up gocheck
+func TestPoller(t *testing.T) { TestingT(t) }
+
+type PrSuite struct {
+	log *helpers.TestLogger
+	myd *myD
+}
+
+var _ = Suite(&PrSuite{})
+
+type myD struct {
+	// in/out for RequestWakeup
+	reqWakeName   string
+	reqWakeTime   time.Time
+	reqWakeCookie string
+	reqWakeErr    error
+	// WatchWakeups
+	watchWakeCh  <-chan bool
+	watchWakeErr error
+	// RequestWakelock
+	reqLockName   string
+	reqLockCookie string
+	reqLockErr    error
+	// ClearWakelock
+	clearLockCookie string
+	clearLockErr    error
+	// Poll
+	pollErr error
+	// WatchDones
+	watchDonesCh  <-chan bool
+	watchDonesErr error
+	// State
+	stateState session.ClientSessionState
+}
+
+func (m *myD) RequestWakeup(name string, wakeupTime time.Time) (string, error) {
+	m.reqWakeName = name
+	m.reqWakeTime = wakeupTime
+	return m.reqWakeCookie, m.reqWakeErr
+}
+func (m *myD) RequestWakelock(name string) (string, error) {
+	m.reqLockName = name
+	return m.reqLockCookie, m.reqLockErr
+}
+func (m *myD) ClearWakelock(cookie string) error {
+	m.clearLockCookie = cookie
+	return m.clearLockErr
+}
+func (m *myD) ClearWakeup(cookie string) error    { panic("clearwakeup called??") }
+func (m *myD) WatchWakeups() (<-chan bool, error) { return m.watchWakeCh, m.watchWakeErr }
+func (m *myD) Poll() error                        { return m.pollErr }
+func (m *myD) WatchDones() (<-chan bool, error)   { return m.watchDonesCh, m.watchDonesErr }
+func (m *myD) State() session.ClientSessionState  { return m.stateState }
+
+func (s *PrSuite) SetUpTest(c *C) {
+	s.log = helpers.NewTestLogger(c, "debug")
+	s.myd = &myD{}
+}
+
+func (s *PrSuite) TestStep(c *C) {
+	p := &poller{
+		times:        Times{},
+		log:          s.log,
+		powerd:       s.myd,
+		polld:        s.myd,
+		sessionState: s.myd,
+	}
+	s.myd.reqLockCookie = "wakelock cookie"
+	s.myd.stateState = session.Running
+	// we'll get the wakeup right away
+	wakeupCh := make(chan bool, 1)
+	wakeupCh <- true
+	// we won't get the "done" signal in time ;)
+	doneCh := make(chan bool)
+	// and a channel to get the return value from a goroutine
+	ch := make(chan string)
+	// now, run
+	go func() { ch <- p.step(wakeupCh, doneCh, "old cookie") }()
+	select {
+	case s := <-ch:
+		c.Check(s, Equals, "wakelock cookie")
+	case <-time.After(time.Second):
+		c.Fatal("timeout waiting for step")
+	}
+	// check we cleared the old cookie
+	c.Check(s.myd.clearLockCookie, Equals, "old cookie")
+}

=== added file 'scripts/noisy-helper.sh'
--- scripts/noisy-helper.sh	1970-01-01 00:00:00 +0000
+++ scripts/noisy-helper.sh	2014-08-25 16:38:20 +0000
@@ -0,0 +1,7 @@
+#!/bin/sh
+for a in `seq 1 100`
+do
+echo BOOM-$a
+>&2 echo BANG-$a
+done
+exit 1

=== modified file 'server/acceptance/acceptanceclient.go'
--- server/acceptance/acceptanceclient.go	2014-06-05 09:32:43 +0000
+++ server/acceptance/acceptanceclient.go	2014-08-25 16:38:20 +0000
@@ -19,9 +19,7 @@
 
 import (
 	"crypto/tls"
-	"crypto/x509"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"net"
 	"strings"
@@ -40,35 +38,36 @@
 	ImageChannel    string
 	ServerAddr      string
 	ExchangeTimeout time.Duration
-	CertPEMBlock    []byte
 	ReportPings     bool
 	Levels          map[string]int64
-	Insecure        bool   // don't verify certs
+	TLSConfig       *tls.Config
 	Prefix          string // prefix for events
 	Auth            string
 	// connection
 	Connection net.Conn
 }
 
-// Dial connects to a server using the configuration in the ClientSession
-// and sets up the connection.
+// Dial connects to a server using the configuration in the
+// ClientSession and sets up the connection.
 func (sess *ClientSession) Dial() error {
 	conn, err := net.DialTimeout("tcp", sess.ServerAddr, sess.ExchangeTimeout)
 	if err != nil {
 		return err
 	}
-	tlsConfig := &tls.Config{}
-	if sess.CertPEMBlock != nil {
-		cp := x509.NewCertPool()
-		ok := cp.AppendCertsFromPEM(sess.CertPEMBlock)
-		if !ok {
-			return errors.New("dial: could not parse certificate")
-		}
-		tlsConfig.RootCAs = cp
+	sess.TLSWrapAndSet(conn)
+	return nil
+}
+
+// TLSWrapAndSet wraps a socket connection in tls and sets it as
+// session.Connection. For use instead of Dial().
+func (sess *ClientSession) TLSWrapAndSet(conn net.Conn) {
+	var tlsConfig *tls.Config
+	if sess.TLSConfig != nil {
+		tlsConfig = sess.TLSConfig
+	} else {
+		tlsConfig = &tls.Config{}
 	}
-	tlsConfig.InsecureSkipVerify = sess.Insecure
 	sess.Connection = tls.Client(conn, tlsConfig)
-	return nil
 }
 
 type serverMsg struct {

=== added file 'server/acceptance/cmd/acceptanceclient.go'
--- server/acceptance/cmd/acceptanceclient.go	1970-01-01 00:00:00 +0000
+++ server/acceptance/cmd/acceptanceclient.go	2014-08-25 16:38:20 +0000
@@ -0,0 +1,54 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// acceptanceclient command for playing.
+package main
+
+import (
+	"log"
+	"os/exec"
+	"strings"
+
+	"launchpad.net/ubuntu-push/server/acceptance"
+	"launchpad.net/ubuntu-push/server/acceptance/kit"
+)
+
+type configuration struct {
+	kit.Configuration
+	AuthHelper string `json:"auth_helper"`
+	WaitFor    string `json:"wait_for"`
+}
+
+func main() {
+	kit.Defaults["auth_helper"] = ""
+	kit.Defaults["wait_for"] = ""
+	cfg := &configuration{}
+	kit.CliLoop(cfg, &cfg.Configuration, func(session *acceptance.ClientSession, cfgDir string) {
+		log.Printf("with: %#v", session)
+	}, func(url string) string {
+		if cfg.AuthHelper == "" {
+			return ""
+		}
+		auth, err := exec.Command(cfg.AuthHelper, url).Output()
+		if err != nil {
+			log.Fatalf("auth helper: %v", err)
+		}
+		return strings.TrimSpace(string(auth))
+	}, func() string {
+		return cfg.WaitFor
+	}, func() {
+	})
+}

=== added directory 'server/acceptance/kit'
=== added file 'server/acceptance/kit/api.go'
--- server/acceptance/kit/api.go	1970-01-01 00:00:00 +0000
+++ server/acceptance/kit/api.go	2014-08-25 16:38:20 +0000
@@ -0,0 +1,82 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// Package kit contains reusable building blocks for acceptance.
+package kit
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"net/http"
+)
+
+// APIClient helps making api requests.
+type APIClient struct {
+	ServerAPIURL string
+	// hook to adjust requests
+	MassageRequest func(req *http.Request, message interface{}) *http.Request
+	// other state
+	httpClient *http.Client
+}
+
+// SetupClient sets up the http client to make requests.
+func (api *APIClient) SetupClient(tlsConfig *tls.Config) {
+	api.httpClient = &http.Client{
+		Transport: &http.Transport{TLSClientConfig: tlsConfig},
+	}
+}
+
+var ErrNOk = errors.New("not ok")
+
+// Post a API request.
+func (api *APIClient) PostRequest(path string, message interface{}) (map[string]interface{}, error) {
+	packedMessage, err := json.Marshal(message)
+	if err != nil {
+		panic(err)
+	}
+	reader := bytes.NewReader(packedMessage)
+
+	url := api.ServerAPIURL + path
+	request, _ := http.NewRequest("POST", url, reader)
+	request.ContentLength = int64(reader.Len())
+	request.Header.Set("Content-Type", "application/json")
+
+	if api.MassageRequest != nil {
+		request = api.MassageRequest(request, message)
+	}
+
+	resp, err := api.httpClient.Do(request)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	var res map[string]interface{}
+	err = json.Unmarshal(body, &res)
+	if err != nil {
+		return nil, err
+	}
+	if ok, _ := res["ok"].(bool); !ok {
+		return res, ErrNOk
+	}
+	return res, nil
+}

=== renamed file 'server/acceptance/cmd/acceptanceclient.go' => 'server/acceptance/kit/cliloop.go'
--- server/acceptance/cmd/acceptanceclient.go	2014-07-11 21:24:21 +0000
+++ server/acceptance/kit/cliloop.go	2014-08-25 16:38:20 +0000
@@ -14,15 +14,13 @@
  with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-// acceptanceclient command for playing.
-package main
+package kit
 
 import (
 	"flag"
 	"fmt"
 	"log"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -32,27 +30,58 @@
 	"launchpad.net/ubuntu-push/server/acceptance"
 )
 
-var (
-	insecureFlag    = flag.Bool("insecure", false, "disable checking of server certificate and hostname")
-	reportPingsFlag = flag.Bool("reportPings", true, "report each Ping from the server")
-	deviceModel     = flag.String("model", "?", "device image model")
-	imageChannel    = flag.String("imageChannel", "?", "image channel")
-)
-
-type configuration struct {
+type Configuration struct {
 	// session configuration
 	ExchangeTimeout config.ConfigTimeDuration `json:"exchange_timeout"`
 	// server connection config
-	Addr        config.ConfigHostPort
-	CertPEMFile string                    `json:"cert_pem_file"`
-	AuthHelper  string                    `json:"auth_helper"`
-	RunTimeout  config.ConfigTimeDuration `json:"run_timeout"`
-	WaitFor     string                    `json:"wait_for"`
-}
-
-func main() {
+	Target      string                `json:"target"`
+	Addr        config.ConfigHostPort `json:"addr"`
+	CertPEMFile string                `json:"cert_pem_file"`
+	Insecure    bool                  `json:"insecure" help:"disable checking of server certificate and hostname"`
+	Domain      string                `json:"domain" help:"domain for tls connect"`
+	// run timeout
+	RunTimeout config.ConfigTimeDuration `json:"run_timeout"`
+	// flags
+	ReportPings  bool   `json:"reportPings" help:"report each Ping from the server"`
+	DeviceModel  string `json:"model" help:"device image model"`
+	ImageChannel string `json:"imageChannel" help:"image channel"`
+}
+
+func (cfg *Configuration) PickByTarget(what, productionValue, stagingValue string) (value string) {
+	switch cfg.Target {
+	case "production":
+		value = productionValue
+	case "staging":
+		value = stagingValue
+	case "":
+		log.Fatalf("either %s or target must be given", what)
+	default:
+		log.Fatalf("if specified target should be production|staging")
+	}
+	return
+}
+
+// Control.
+var (
+	Name     = "acceptanceclient"
+	Defaults = map[string]interface{}{
+		"target":           "",
+		"addr":             ":0",
+		"exchange_timeout": "5s",
+		"cert_pem_file":    "",
+		"insecure":         false,
+		"domain":           "",
+		"run_timeout":      "0s",
+		"reportPings":      true,
+		"model":            "?",
+		"imageChannel":     "?",
+	}
+)
+
+// CliLoop parses command line arguments and runs a client loop.
+func CliLoop(totalCfg interface{}, cfg *Configuration, onSetup func(sess *acceptance.ClientSession, cfgDir string), auth func(string) string, waitFor func() string, onConnect func()) {
 	flag.Usage = func() {
-		fmt.Fprintf(os.Stderr, "Usage: acceptancclient [options] <device id>\n")
+		fmt.Fprintf(os.Stderr, "Usage: %s [options] <device id>\n", Name)
 		flag.PrintDefaults()
 	}
 	missingArg := func(what string) {
@@ -60,14 +89,7 @@
 		flag.Usage()
 		os.Exit(2)
 	}
-	cfg := &configuration{}
-	err := config.ReadFilesDefaults(cfg, map[string]interface{}{
-		"exchange_timeout": "5s",
-		"cert_pem_file":    "",
-		"auth_helper":      "",
-		"run_timeout":      "0s",
-		"wait_for":         "",
-	}, "<flags>")
+	err := config.ReadFilesDefaults(totalCfg, Defaults, "<flags>")
 	if err != nil {
 		log.Fatalf("reading config: %v", err)
 	}
@@ -76,36 +98,34 @@
 	case narg < 1:
 		missingArg("device-id")
 	}
+	addr := ""
+	if cfg.Addr == ":0" {
+		addr = cfg.PickByTarget("addr", "push-delivery.ubuntu.com:443",
+			"push-delivery.staging.ubuntu.com:443")
+	} else {
+		addr = cfg.Addr.HostPort()
+	}
 	session := &acceptance.ClientSession{
 		ExchangeTimeout: cfg.ExchangeTimeout.TimeDuration(),
-		ServerAddr:      cfg.Addr.HostPort(),
+		ServerAddr:      addr,
 		DeviceId:        flag.Arg(0),
 		// flags
-		Model:        *deviceModel,
-		ImageChannel: *imageChannel,
-		ReportPings:  *reportPingsFlag,
-		Insecure:     *insecureFlag,
-	}
-	log.Printf("with: %#v", session)
-	if !*insecureFlag && cfg.CertPEMFile != "" {
-		cfgDir := filepath.Dir(flag.Lookup("cfg@").Value.String())
-		log.Printf("cert: %v relToDir: %v", cfg.CertPEMFile, cfgDir)
-		session.CertPEMBlock, err = config.LoadFile(cfg.CertPEMFile, cfgDir)
-		if err != nil {
-			log.Fatalf("reading CertPEMFile: %v", err)
-		}
-	}
-	if len(cfg.AuthHelper) != 0 {
-		auth, err := exec.Command(cfg.AuthHelper, "https://push.ubuntu.com/").Output()
-		if err != nil {
-			log.Fatalf("auth helper: %v", err)
-		}
-		session.Auth = strings.TrimSpace(string(auth))
-	}
+		Model:        cfg.DeviceModel,
+		ImageChannel: cfg.ImageChannel,
+		ReportPings:  cfg.ReportPings,
+	}
+	cfgDir := filepath.Dir(flag.Lookup("cfg@").Value.String())
+	onSetup(session, cfgDir)
+	session.TLSConfig, err = MakeTLSConfig(cfg.Domain, cfg.Insecure, cfg.CertPEMFile, cfgDir)
+	if err != nil {
+		log.Fatalf("tls config: %v", err)
+	}
+	session.Auth = auth("https://push.ubuntu.com/")
 	var waitForRegexp *regexp.Regexp
-	if cfg.WaitFor != "" {
+	waitForStr := waitFor()
+	if waitForStr != "" {
 		var err error
-		waitForRegexp, err = regexp.Compile(cfg.WaitFor)
+		waitForRegexp, err = regexp.Compile(waitForStr)
 		if err != nil {
 			log.Fatalf("wait_for regexp: %v", err)
 		}
@@ -118,6 +138,9 @@
 	go func() {
 		for {
 			ev := <-events
+			if strings.HasPrefix(ev, "connected") {
+				onConnect()
+			}
 			if waitForRegexp != nil && waitForRegexp.MatchString(ev) {
 				log.Println("<matching-event>:", ev)
 				os.Exit(0)

=== added file 'server/acceptance/kit/helpers.go'
--- server/acceptance/kit/helpers.go	1970-01-01 00:00:00 +0000
+++ server/acceptance/kit/helpers.go	2014-08-25 16:38:20 +0000
@@ -0,0 +1,46 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package kit
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"fmt"
+
+	"launchpad.net/ubuntu-push/config"
+)
+
+// MakeTLSConfig makes a tls.Config, optionally reading a cert from
+// disk, possibly relative to relDir.
+func MakeTLSConfig(domain string, insecure bool, certPEMFile string, relDir string) (*tls.Config, error) {
+	tlsConfig := &tls.Config{}
+	tlsConfig.ServerName = domain
+	tlsConfig.InsecureSkipVerify = insecure
+	if !insecure && certPEMFile != "" {
+		certPEMBlock, err := config.LoadFile(certPEMFile, relDir)
+		if err != nil {
+			return nil, fmt.Errorf("reading cert: %v", err)
+		}
+		cp := x509.NewCertPool()
+		ok := cp.AppendCertsFromPEM(certPEMBlock)
+		if !ok {
+			return nil, fmt.Errorf("could not parse certificate")
+		}
+		tlsConfig.RootCAs = cp
+	}
+	return tlsConfig, nil
+}

=== modified file 'server/acceptance/suites/broadcast.go'
--- server/acceptance/suites/broadcast.go	2014-06-25 11:00:15 +0000
+++ server/acceptance/suites/broadcast.go	2014-08-25 16:38:20 +0000
@@ -41,8 +41,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 42}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"img1/m1":42}]`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
@@ -56,14 +55,13 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m2": 10}`),
 	})
-	c.Assert(err, IsNil)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 20}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"img1/m1":20}]`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
@@ -77,8 +75,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	events, errCh, stop := s.StartClient(c, "DEVB", nil)
 	// gettting pending on connect
@@ -97,8 +94,7 @@
 			ExpireOn: future,
 			Data:     json.RawMessage(fmt.Sprintf(payloadFmt, i)),
 		})
-		c.Assert(err, IsNil)
-		c.Assert(got, Matches, OK)
+		c.Assert(err, IsNil, Commentf("%v", got))
 	}
 
 	events, errCh, stop := s.StartClient(c, "DEVC", nil)
@@ -130,8 +126,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 42}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events1, errCh1), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"img1/m1":42}]`)
 	c.Check(NextEvent(events2, errCh2), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"img1/m1":42}]`)
 	stop1()
@@ -149,8 +144,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"img1/m1":1}]`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
@@ -161,8 +155,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	// reconnect, provide levels, get only later notification
 	events, errCh, stop = s.StartClient(c, "DEVD", map[string]int64{
 		protocol.SystemChannelId: 1,
@@ -180,15 +173,13 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	events, errCh, stop := s.StartClient(c, "DEVB", map[string]int64{
 		protocol.SystemChannelId: 10,
@@ -219,15 +210,13 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	events, errCh, stop := s.StartClient(c, "DEVB", map[string]int64{
 		protocol.SystemChannelId: -10,
@@ -246,15 +235,13 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: time.Now().Add(1 * time.Second).Format(time.RFC3339),
 		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	time.Sleep(2 * time.Second)
 	// second broadcast is expired

=== modified file 'server/acceptance/suites/suite.go'
--- server/acceptance/suites/suite.go	2014-06-25 11:00:15 +0000
+++ server/acceptance/suites/suite.go	2014-08-25 16:38:20 +0000
@@ -18,13 +18,9 @@
 package suites
 
 import (
-	"bytes"
-	"encoding/json"
 	"flag"
 	"fmt"
-	"io/ioutil"
 	"net"
-	"net/http"
 	"os"
 	"runtime"
 	"time"
@@ -32,6 +28,7 @@
 	. "launchpad.net/gocheck"
 
 	"launchpad.net/ubuntu-push/server/acceptance"
+	"launchpad.net/ubuntu-push/server/acceptance/kit"
 	helpers "launchpad.net/ubuntu-push/testing"
 )
 
@@ -84,14 +81,10 @@
 	StartServer func(c *C, s *AcceptanceSuite, handle *ServerHandle)
 	// populated by StartServer
 	ServerHandle
-	ServerAPIURL string
+	kit.APIClient // has ServerAPIURL
 	// KillGroup should be populated by StartServer with functions
 	// to kill the server process
 	KillGroup map[string]func(os.Signal)
-	// hook to adjust requests
-	MassageRequest func(req *http.Request, message interface{}) *http.Request
-	// other state
-	httpClient *http.Client
 }
 
 // Start a new server for each test.
@@ -101,7 +94,7 @@
 	c.Assert(s.ServerHandle.ServerEvents, NotNil)
 	c.Assert(s.ServerHandle.ServerAddr, Not(Equals), "")
 	c.Assert(s.ServerAPIURL, Not(Equals), "")
-	s.httpClient = &http.Client{}
+	s.SetupClient(nil)
 }
 
 func (s *AcceptanceSuite) TearDownTest(c *C) {
@@ -110,45 +103,19 @@
 	}
 }
 
-// Post a API request.
-func (s *AcceptanceSuite) PostRequest(path string, message interface{}) (string, error) {
-	packedMessage, err := json.Marshal(message)
-	if err != nil {
-		panic(err)
-	}
-	reader := bytes.NewReader(packedMessage)
-
-	url := s.ServerAPIURL + path
-	request, _ := http.NewRequest("POST", url, reader)
-	request.ContentLength = int64(reader.Len())
-	request.Header.Set("Content-Type", "application/json")
-
-	if s.MassageRequest != nil {
-		request = s.MassageRequest(request, message)
-	}
-
-	resp, err := s.httpClient.Do(request)
-	if err != nil {
-		panic(err)
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	return string(body), err
-}
-
 func testClientSession(addr string, deviceId, model, imageChannel string, reportPings bool) *acceptance.ClientSession {
-	certPEMBlock, err := ioutil.ReadFile(helpers.SourceRelative("../ssl/testing.cert"))
+	tlsConfig, err := kit.MakeTLSConfig("", false, helpers.SourceRelative("../ssl/testing.cert"), "")
 	if err != nil {
 		panic(fmt.Sprintf("could not read ssl/testing.cert: %v", err))
 	}
 	return &acceptance.ClientSession{
 		ExchangeTimeout: 100 * time.Millisecond,
 		ServerAddr:      addr,
-		CertPEMBlock:    certPEMBlock,
 		DeviceId:        deviceId,
 		Model:           model,
 		ImageChannel:    imageChannel,
 		ReportPings:     reportPings,
+		TLSConfig:       tlsConfig,
 	}
 }
 
@@ -198,5 +165,3 @@
 
 // Long after the end of the tests.
 var future = time.Now().Add(9 * time.Hour).Format(time.RFC3339)
-
-const OK = `.*"ok":true.*`

=== modified file 'server/acceptance/suites/unicast.go'
--- server/acceptance/suites/unicast.go	2014-07-14 15:23:17 +0000
+++ server/acceptance/suites/unicast.go	2014-08-25 16:38:20 +0000
@@ -23,6 +23,7 @@
 
 	. "launchpad.net/gocheck"
 
+	"launchpad.net/ubuntu-push/server/acceptance/kit"
 	"launchpad.net/ubuntu-push/server/api"
 )
 
@@ -45,20 +46,15 @@
 		DeviceId: "DEV1",
 		AppId:    "app1",
 	})
-	c.Assert(err, IsNil)
-	c.Assert(res, Matches, OK)
-	var reg map[string]interface{}
-	err = json.Unmarshal([]byte(res), &reg)
-	c.Assert(err, IsNil)
+	c.Assert(err, IsNil, Commentf("%v", res))
 	events, errCh, stop := s.StartClientAuth(c, "DEV1", nil, auth)
 	got, err := s.PostRequest("/notify", &api.Unicast{
-		Token:    reg["token"].(string),
+		Token:    res["token"].(string),
 		AppId:    "app1",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"a": 42}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events, errCh), Equals, `unicast app:app1 payload:{"a":42};`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
@@ -80,8 +76,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"to": 1}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	got, err = s.PostRequest("/notify", &api.Unicast{
 		UserId:   userId2,
 		DeviceId: "DEV2",
@@ -89,8 +84,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"to": 2}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 	c.Check(NextEvent(events1, errCh1), Equals, `unicast app:app1 payload:{"to":1};`)
 	c.Check(NextEvent(events2, errCh2), Equals, `unicast app:app1 payload:{"to":2};`)
 	stop1()
@@ -111,8 +105,7 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"a": 42}`),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	// get pending on connect
 	events, errCh, stop := s.StartClientAuth(c, "DEV1", nil, auth)
@@ -134,8 +127,7 @@
 			ExpireOn: future,
 			Data:     json.RawMessage(fmt.Sprintf(payloadFmt, i)),
 		})
-		c.Assert(err, IsNil)
-		c.Assert(got, Matches, OK)
+		c.Assert(err, IsNil, Commentf("%v", got))
 	}
 
 	events, errCh, stop := s.StartClientAuth(c, "DEV2", nil, auth)
@@ -168,8 +160,7 @@
 			ExpireOn: future,
 			Data:     json.RawMessage(fmt.Sprintf(payloadFmt, i)),
 		})
-		c.Assert(err, IsNil)
-		c.Assert(got, Matches, OK)
+		c.Assert(err, IsNil, Commentf("%v", got))
 	}
 
 	got, err := s.PostRequest("/notify", &api.Unicast{
@@ -179,8 +170,9 @@
 		ExpireOn: future,
 		Data:     json.RawMessage(fmt.Sprintf(payloadFmt, MaxNotificationsPerApplication)),
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, `.*"error":"too-many-pending".*`)
+	c.Assert(err, Equals, kit.ErrNOk, Commentf("%v", got))
+	errorStr, _ := got["error"].(string)
+	c.Assert(errorStr, Equals, "too-many-pending")
 
 	// clear all pending
 	got, err = s.PostRequest("/notify", &api.Unicast{
@@ -191,8 +183,7 @@
 		Data:         json.RawMessage(fmt.Sprintf(payloadFmt, 1000)),
 		ClearPending: true,
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	events, errCh, stop := s.StartClientAuth(c, "DEV2", nil, auth)
 	// getting the 1 pending on connect
@@ -214,8 +205,7 @@
 		Data:       json.RawMessage(`{"m": 1}`),
 		ReplaceTag: "tagFoo",
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	// replace
 	got, err = s.PostRequest("/notify", &api.Unicast{
@@ -226,8 +216,7 @@
 		Data:       json.RawMessage(`{"m": 2}`),
 		ReplaceTag: "tagFoo",
 	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, OK)
+	c.Assert(err, IsNil, Commentf("%v", got))
 
 	events, errCh, stop := s.StartClientAuth(c, "DEV2", nil, auth)
 	// getting the 1 pending on connect