Merge lp:ubuntu-push/automatic into lp:ubuntu-push

[John Lenton]

Merge automatic into trunk.

Merge automatic into trunk.

=== modified file '.bzrignore'
--- .bzrignore	2014-02-07 19:36:38 +0000
+++ .bzrignore	2014-04-04 14:39:41 +0000
@@ -11,3 +11,5 @@
 debian/*.ex
 debian/*.EX
 debian/*.substvars
+ubuntu-push-client
+push-server-dev

=== modified file 'Makefile'
--- Makefile	2014-03-12 13:23:26 +0000
+++ Makefile	2014-04-04 14:39:41 +0000
@@ -12,6 +12,8 @@
 GODEPS += launchpad.net/go-xdg/v0
 GODEPS += code.google.com/p/gosqlite/sqlite3
 
+TOTEST = $(shell env GOPATH=$(GOPATH) go list $(PROJECT)/...|grep -v acceptance|grep -v http13client )
+
 bootstrap:
 	mkdir -p $(GOPATH)/bin
 	mkdir -p $(GOPATH)/pkg
@@ -21,17 +23,29 @@
 	go install $(GODEPS)
 
 check:
-	go test $(TESTFLAGS) $(PROJECT)/...
+	go test $(TESTFLAGS) $(TOTEST)
 
 check-race:
-	go test $(TESTFLAGS) -race $(PROJECT)/...
+	go test $(TESTFLAGS) -race $(TOTEST)
+
+acceptance:
+	cd server/acceptance; ./acceptance.sh
+
+build-client:
+	go build ubuntu-push-client.go
+
+build-server-dev:
+	go build -o push-server-dev launchpad.net/ubuntu-push/server/dev
+
+run-server-dev:
+	go run server/dev/*.go sampleconfigs/dev.json
 
 coverage-summary:
-	go test $(TESTFLAGS) -a -cover $(PROJECT)/...
+	go test $(TESTFLAGS) -a -cover $(TOTEST)
 
 coverage-html:
 	mkdir -p coverhtml
-	for pkg in $$(go list $(PROJECT)/...|grep -v acceptance ); do \
+	for pkg in $(TOTEST); do \
 		relname="$${pkg#$(PROJECT)/}" ; \
 		mkdir -p coverhtml/$$(dirname $${relname}) ; \
 		go test $(TESTFLAGS) -a -coverprofile=coverhtml/$${relname}.out $$pkg ; \
@@ -52,5 +66,6 @@
 	# requires graphviz installed
 	dot -Tsvg $< > $@
 
-.PHONY: bootstrap check check-race format check-format coverage-summary \
-	coverage-html protocol-diagrams
+.PHONY: bootstrap check check-race format check-format \
+	acceptance build-client build server-dev run-server-dev \
+	coverage-summary coverage-html protocol-diagrams

=== modified file 'README'
--- README	2014-02-21 16:17:28 +0000
+++ README	2014-04-04 14:39:41 +0000
@@ -15,8 +15,7 @@
    make check
 
 To produce coverage reports you need Go 1.2 (default on Trusty) and
-the cover tool (the latter can be obtained atm with something like:
-sudo GOPATH=<go-workspace> go get code.google.com/p/go.tools/cmd/cover ),
+the cover tool (in the golang-go.tools package),
 then run:
 
    make coverage-summary
@@ -31,4 +30,13 @@
 
 To run the acceptance tests, change to the acceptance subdir and run:
 
-   ./acceptance.sh
+  make acceptance
+
+There are build targets to build the client:
+
+  make build-client
+
+building ubuntu-push-client, and to run the development server:
+
+  make run-server-dev
+

=== modified file 'bus/bus.go'
--- bus/bus.go	2014-02-06 09:57:49 +0000
+++ bus/bus.go	2014-04-04 14:39:41 +0000
@@ -57,11 +57,16 @@
 	}
 }
 
-// Connect() connects to the bus, and returns the bus endpoint (and/or error).
+// Endpoint returns a bus endpoint.
 func (bus concreteBus) Endpoint(addr Address, log logger.Logger) Endpoint {
 	return newEndpoint(bus, addr, log)
 }
 
+// Args helps build arguments for endpoint Call().
+func Args(args ...interface{}) []interface{} {
+	return args
+}
+
 /*
    private methods
 */

=== modified file 'bus/connectivity/connectivity.go'
--- bus/connectivity/connectivity.go	2014-03-20 14:21:24 +0000
+++ bus/connectivity/connectivity.go	2014-04-04 14:39:41 +0000
@@ -47,6 +47,7 @@
 
 type connectedState struct {
 	networkStateCh <-chan networkmanager.State
+	networkConCh   <-chan string
 	config         ConnectivityConfig
 	log            logger.Logger
 	endp           bus.Endpoint
@@ -62,7 +63,9 @@
 // up the watch.
 func (cs *connectedState) start() networkmanager.State {
 	var initial networkmanager.State
-	var ch <-chan networkmanager.State
+	var stateCh <-chan networkmanager.State
+	var primary string
+	var conCh <-chan string
 	var err error
 	for {
 		ar := util.NewAutoRedialer(cs.endp)
@@ -77,13 +80,24 @@
 		}
 
 		// set up the watch
-		ch, err = nm.WatchState()
-		if err != nil {
-			cs.log.Debugf("Failed to set up the watch: %s", err)
-			goto Continue
-		}
-
-		cs.networkStateCh = ch
+		stateCh, err = nm.WatchState()
+		if err != nil {
+			cs.log.Debugf("failed to set up the state 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
+
 		return initial
 
 	Continue:
@@ -102,6 +116,15 @@
 Loop:
 	for {
 		select {
+		case <-cs.networkConCh:
+			cs.webgetCh = nil
+			cs.timer.Reset(stabilizingTimeout)
+			log.Debugf("PrimaryConnection changed. Assuming disconnect.")
+			if cs.lastSent == true {
+				cs.lastSent = false
+				break Loop
+			}
+
 		case v, ok := <-cs.networkStateCh:
 			if !ok {
 				// tear it all down and start over

=== modified file 'bus/connectivity/connectivity_test.go'
--- bus/connectivity/connectivity_test.go	2014-03-20 12:15:47 +0000
+++ bus/connectivity/connectivity_test.go	2014-04-04 14:39:41 +0000
@@ -17,6 +17,7 @@
 package connectivity
 
 import (
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
 	"launchpad.net/ubuntu-push/bus/networkmanager"
 	testingbus "launchpad.net/ubuntu-push/bus/testing"
@@ -84,6 +85,17 @@
 	c.Check(cs.connAttempts, Equals, uint32(6))
 }
 
+// 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),
+		1, condition.Work(true))
+
+	endp := testingbus.NewTestingEndpoint(condition.Work(true), cond, uint32(networkmanager.Connecting))
+	cs := connectedState{config: ConnectivityConfig{}, log: s.log, endp: endp}
+
+	c.Check(cs.start(), Equals, networkmanager.Connecting)
+}
+
 // when... and bear with me... the bus works, and the first call to
 // get network manager's state works, but then you can't establish the
 // watch, we recover and try again.
@@ -213,24 +225,72 @@
 	}{
 		{false, "first state is always false", 0},
 		{true, "then it should be true as per ConnectedGlobal above", 0},
-		{false, "then, false (upon receiving the next ConnectedGlobal)", 1},
-		{true, "then it should be true (webcheck passed)", 0},
-		{false, "then it should be false (Disconnected)", 1},
-		{false, "then it should be false again because it's restarted", 1},
-	}
-
-	for i, expected := range expecteds {
-		for j := 0; j < expected.n; j++ {
-			watchTicker <- true
-		}
-		timer.Reset(dt)
-		select {
-		case v = <-out:
-			break
-		case <-timer.C:
-			c.Fatalf("Timed out before getting value (#%d: %s)", i+1, expected.s)
-		}
-
-		c.Check(v, Equals, expected.p, Commentf(expected.s))
+		{false, "then, false (upon receiving the next ConnectedGlobal)", 2},
+		{true, "then it should be true (webcheck passed)", 0},
+		{false, "then it should be false (Disconnected)", 2},
+		{false, "then it should be false again because it's restarted", 2},
+	}
+
+	for i, expected := range expecteds {
+		for j := 0; j < expected.n; j++ {
+			watchTicker <- true
+		}
+		timer.Reset(dt)
+		select {
+		case v = <-out:
+			break
+		case <-timer.C:
+			c.Fatalf("Timed out before getting value (#%d: %s)", i+1, expected.s)
+		}
+		c.Assert(v, Equals, expected.p, Commentf(expected.s))
+	}
+}
+
+func (s *ConnSuite) TestRun4Active(c *C) {
+	ts := httptest.NewServer(mkHandler(staticText))
+	defer ts.Close()
+
+	cfg := ConnectivityConfig{
+		ConnectivityCheckURL: ts.URL,
+		ConnectivityCheckMD5: staticHash,
+		RecheckTimeout:       config.ConfigTimeDuration{time.Second},
+	}
+
+	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Work(true),
+		uint32(networkmanager.ConnectedGlobal),
+		map[string]dbus.Variant{"PrimaryConnection": dbus.Variant{dbus.ObjectPath("hello")}},
+	)
+
+	watchTicker := make(chan bool)
+	testingbus.SetWatchTicker(endp, watchTicker)
+
+	out := make(chan bool)
+	dt := time.Second / 10
+	timer := time.NewTimer(dt)
+	go ConnectedState(endp, cfg, s.log, out)
+	var v bool
+	expecteds := []struct {
+		p bool
+		s string
+		n int
+	}{
+		{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},
+	}
+
+	for i, expected := range expecteds {
+		for j := 0; j < expected.n; j++ {
+			watchTicker <- true
+		}
+		timer.Reset(dt)
+		select {
+		case v = <-out:
+			break
+		case <-timer.C:
+			c.Fatalf("Timed out before getting value (#%d: %s)", i+1, expected.s)
+		}
+		c.Assert(v, Equals, expected.p, Commentf(expected.s))
 	}
 }

=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2014-02-21 16:17:28 +0000
+++ bus/endpoint.go	2014-04-04 14:39:41 +0000
@@ -32,7 +32,7 @@
 // bus.Endpoint represents the DBus connection itself.
 type Endpoint interface {
 	WatchSignal(member string, f func(...interface{}), d func()) error
-	Call(member string, args ...interface{}) ([]interface{}, error)
+	Call(member string, args []interface{}, rvs ...interface{}) error
 	GetProperty(property string) (interface{}, error)
 	Dial() error
 	Close()
@@ -118,16 +118,20 @@
 	return nil
 }
 
-// Call() invokes the provided member method (on the name, path and interface
-// provided when creating the endpoint). The return value is unpacked before
-// being returned.
-func (endp *endpoint) Call(member string, args ...interface{}) ([]interface{}, error) {
+// Call() invokes the provided member method (on the name, path and
+// interface provided when creating the endpoint). args can be built
+// using bus.Args(...). The return value is unpacked into rvs before being
+// returned.
+func (endp *endpoint) Call(member string, args []interface{}, rvs ...interface{}) error {
 	msg, err := endp.proxy.Call(endp.addr.Interface, member, args...)
 	if err != nil {
-		return nil, err
-	}
-	rvs := endp.unpackOneMsg(msg, member)
-	return rvs, nil
+		return err
+	}
+	err = msg.Args(rvs...)
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
 // GetProperty uses the org.freedesktop.DBus.Properties interface's Get method
@@ -175,7 +179,11 @@
 
 // unpackOneMsg unpacks the value from the response msg
 func (endp *endpoint) unpackOneMsg(msg *dbus.Message, member string) []interface{} {
-	return msg.AllArgs()
+	var varmap map[string]dbus.Variant
+	if err := msg.Args(&varmap); err != nil {
+		return msg.AllArgs()
+	}
+	return []interface{}{varmap}
 }
 
 // unpackMessages unpacks the value from the watch

=== modified file 'bus/networkmanager/networkmanager.go'
--- bus/networkmanager/networkmanager.go	2014-01-21 13:21:19 +0000
+++ bus/networkmanager/networkmanager.go	2014-04-04 14:39:41 +0000
@@ -20,6 +20,8 @@
 package networkmanager
 
 import (
+	"launchpad.net/go-dbus/v1"
+
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/logger"
 )
@@ -41,6 +43,12 @@
 	// WatchState listens for changes to NetworkManager's state, and sends
 	// them out over the channel returned.
 	WatchState() (<-chan State, 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)
 }
 
 type networkManager struct {
@@ -68,13 +76,28 @@
 		return Unknown
 	}
 
-	return State(s.(uint32))
+	v, ok := s.(uint32)
+	if !ok {
+		nm.log.Errorf("Got weird state: %#v", s)
+		return Unknown
+	}
+
+	return State(v)
 }
 
 func (nm *networkManager) WatchState() (<-chan State, error) {
 	ch := make(chan State)
 	err := nm.bus.WatchSignal("StateChanged",
-		func(ns ...interface{}) { ch <- State(ns[0].(uint32)) },
+		func(ns ...interface{}) {
+			stint, ok := ns[0].(uint32)
+			if !ok {
+				nm.log.Errorf("got weird state: %#v", ns[0])
+				return
+			}
+			st := State(stint)
+			nm.log.Debugf("got state: %s", st)
+			ch <- State(stint)
+		},
 		func() { close(ch) })
 	if err != nil {
 		nm.log.Debugf("Failed to set up the watch: %s", err)
@@ -83,3 +106,49 @@
 
 	return ch, nil
 }
+
+func (nm *networkManager) GetPrimaryConnection() string {
+	s, err := nm.bus.GetProperty("PrimaryConnection")
+	if err != nil {
+		nm.log.Errorf("Failed gettting current primary connection: %s", err)
+		nm.log.Debugf("Defaulting primary connection to empty")
+		return ""
+	}
+
+	v, ok := s.(dbus.ObjectPath)
+	if !ok {
+		nm.log.Errorf("got weird PrimaryConnection: %#v", s)
+		return ""
+	}
+
+	return string(v)
+}
+
+func (nm *networkManager) WatchPrimaryConnection() (<-chan string, error) {
+	ch := make(chan string)
+	err := nm.bus.WatchSignal("PropertiesChanged",
+		func(ppsi ...interface{}) {
+			pps, ok := ppsi[0].(map[string]dbus.Variant)
+			if !ok {
+				nm.log.Errorf("got weird PropertiesChanged: %#v", ppsi[0])
+				return
+			}
+			v, ok := pps["PrimaryConnection"]
+			if !ok {
+				return
+			}
+			con, ok := v.Value.(dbus.ObjectPath)
+			if !ok {
+				nm.log.Errorf("got weird PrimaryConnection via PropertiesChanged: %#v", v)
+				return
+			}
+			nm.log.Debugf("got primary connection: %s", con)
+			ch <- string(con)
+		}, func() { close(ch) })
+	if err != nil {
+		nm.log.Debugf("Failed to set up the watch: %s", err)
+		return nil, err
+	}
+
+	return ch, nil
+}

=== modified file 'bus/networkmanager/networkmanager_test.go'
--- bus/networkmanager/networkmanager_test.go	2014-02-05 18:17:26 +0000
+++ bus/networkmanager/networkmanager_test.go	2014-04-04 14:39:41 +0000
@@ -17,12 +17,15 @@
 package networkmanager
 
 import (
+	"testing"
+
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
+
 	testingbus "launchpad.net/ubuntu-push/bus/testing"
 	"launchpad.net/ubuntu-push/logger"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
-	"testing"
 )
 
 // hook up gocheck
@@ -71,7 +74,7 @@
 
 // GetState returns the right state when dbus works but delivers rubbish values
 func (s *NMSuite) TestGetStateRubbishValues(c *C) {
-	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false), 42), s.log)
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), "Unknown"), s.log)
 	state := nm.GetState()
 	c.Check(state, Equals, Unknown)
 }
@@ -101,11 +104,123 @@
 }
 
 // WatchState calls close on its channel when the watch bails
-func (s *NMSuite) TestWatchClosesOnWatchBail(c *C) {
-	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true))
-	nm := New(tc, s.log)
-	ch, err := nm.WatchState()
-	c.Check(err, IsNil)
-	_, ok := <-ch
-	c.Check(ok, Equals, false)
+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)
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}
+
+// WatchState survives rubbish values
+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)
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}
+
+// GetPrimaryConnection returns the right state when everything works
+func (s *NMSuite) TestGetPrimaryConnection(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), dbus.ObjectPath("/a/1")), s.log)
+	con := nm.GetPrimaryConnection()
+	c.Check(con, Equals, "/a/1")
+}
+
+// GetPrimaryConnection returns the right state when dbus fails
+func (s *NMSuite) TestGetPrimaryConnectionFail(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	con := nm.GetPrimaryConnection()
+	c.Check(con, Equals, "")
+}
+
+// GetPrimaryConnection returns the right state when dbus works but delivers rubbish values
+func (s *NMSuite) TestGetPrimaryConnectionRubbishValues(c *C) {
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), "broken"), s.log)
+	con := nm.GetPrimaryConnection()
+	c.Check(con, Equals, "")
+}
+
+// GetPrimaryConnection returns the right state when dbus works but delivers a rubbish structure
+func (s *NMSuite) TestGetPrimaryConnectionRubbishStructure(c *C) {
+	nm := New(testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{}), s.log)
+	con := nm.GetPrimaryConnection()
+	c.Check(con, Equals, "")
+}
+
+func mkPriConMap(priCon string) map[string]dbus.Variant {
+	m := make(map[string]dbus.Variant)
+	m["PrimaryConnection"] = dbus.Variant{dbus.ObjectPath(priCon)}
+	return m
+}
+
+// WatchPrimaryConnection sends a stream of Connections over the channel
+func (s *NMSuite) TestWatchPrimaryConnection(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true),
+		mkPriConMap("/a/1"),
+		mkPriConMap("/b/2"),
+		mkPriConMap("/c/3"))
+	nm := New(tc, s.log)
+	ch, err := nm.WatchPrimaryConnection()
+	c.Check(err, IsNil)
+	l := []string{<-ch, <-ch, <-ch}
+	c.Check(l, DeepEquals, []string{"/a/1", "/b/2", "/c/3"})
+}
+
+// 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()
+	c.Check(err, NotNil)
+}
+
+// WatchPrimaryConnection calls close on its channel when the watch bails
+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)
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}
+
+// WatchPrimaryConnection survives rubbish values
+func (s *NMSuite) TestWatchPrimaryConnectionSurvivesRubbishValues(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), "a")
+	nm := New(tc, s.log)
+	ch, err := nm.WatchPrimaryConnection()
+	c.Assert(err, IsNil)
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}
+
+// WatchPrimaryConnection ignores non-PrimaryConnection PropertyChanged
+func (s *NMSuite) TestWatchPrimaryConnectionIgnoresIrrelephant(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true),
+		map[string]dbus.Variant{"foo": dbus.Variant{}},
+		map[string]dbus.Variant{"PrimaryConnection": dbus.Variant{dbus.ObjectPath("42")}},
+	)
+	nm := New(tc, s.log)
+	ch, err := nm.WatchPrimaryConnection()
+	c.Assert(err, IsNil)
+	v, ok := <-ch
+	c.Check(ok, Equals, true)
+	c.Check(v, Equals, "42")
+}
+
+// WatchPrimaryConnection ignores rubbish PrimaryConnections
+func (s *NMSuite) TestWatchPrimaryConnectionIgnoresRubbishValues(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true),
+		map[string]dbus.Variant{"PrimaryConnection": dbus.Variant{-12}},
+		map[string]dbus.Variant{"PrimaryConnection": dbus.Variant{dbus.ObjectPath("42")}},
+	)
+	nm := New(tc, s.log)
+	ch, err := nm.WatchPrimaryConnection()
+	c.Assert(err, IsNil)
+	v, ok := <-ch
+	c.Check(ok, Equals, true)
+	c.Check(v, Equals, "42")
 }

=== modified file 'bus/notifications/raw.go'
--- bus/notifications/raw.go	2014-01-27 14:22:00 +0000
+++ bus/notifications/raw.go	2014-04-04 14:39:41 +0000
@@ -22,7 +22,6 @@
 // this is the lower-level api
 
 import (
-	"fmt"
 	"launchpad.net/go-dbus/v1"
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/logger"
@@ -69,16 +68,13 @@
 	timeout int32) (uint32, error) {
 	// that's a long argument list! Take a breather.
 	//
-	rvs, err := raw.bus.Call("Notify", app_name, reuse_id, icon,
-		summary, body, actions, hints, timeout)
+	var res uint32
+	err := raw.bus.Call("Notify", bus.Args(app_name, reuse_id, icon,
+		summary, body, actions, hints, timeout), &res)
 	if err != nil {
 		return 0, err
 	}
-	if len(rvs) != 1 {
-		return 0, fmt.Errorf("Wrong number of values in Notify response: %d",
-			len(rvs))
-	}
-	return rvs[0].(uint32), nil
+	return res, nil
 }
 
 // WatchActions listens for ActionInvoked signals from the notification daemon

=== added directory 'bus/systemimage'
=== added file 'bus/systemimage/systemimage.go'
--- bus/systemimage/systemimage.go	1970-01-01 00:00:00 +0000
+++ bus/systemimage/systemimage.go	2014-04-04 14:39:41 +0000
@@ -0,0 +1,68 @@
+/*
+ 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 systemimage is a mimimal wrapper for the system-image dbus API.
+package systemimage
+
+import (
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/logger"
+)
+
+// system-image service lives on a well-known bus.Address
+var BusAddress bus.Address = bus.Address{
+	Interface: "com.canonical.SystemImage",
+	Path:      "/Service",
+	Name:      "com.canonical.SystemImage",
+}
+
+// InfoResult holds the result of the system-image service Info method.
+type InfoResult struct {
+	BuildNumber int32
+	Device      string
+	Channel     string
+	// xxx channel_target missing
+	LastUpdate    string
+	VersionDetail map[string]string
+}
+
+// A SystemImage exposes the a subset of system-image service.
+type SystemImage interface {
+	Info() (*InfoResult, error)
+}
+
+type systemImage struct {
+	endp bus.Endpoint
+	log  logger.Logger
+}
+
+// New builds a new system-image service wrapper that uses the provided bus.Endpoint
+func New(endp bus.Endpoint, log logger.Logger) SystemImage {
+	return &systemImage{endp, log}
+}
+
+var _ SystemImage = &systemImage{} // ensures it conforms
+
+func (si *systemImage) Info() (*InfoResult, error) {
+	si.log.Debugf("Invoking Info")
+	res := &InfoResult{}
+	err := si.endp.Call("Info", bus.Args(), &res.BuildNumber, &res.Device, &res.Channel, &res.LastUpdate, &res.VersionDetail)
+	if err != nil {
+		si.log.Errorf("Info failed: %v", err)
+		return nil, err
+	}
+	return res, err
+}

=== added file 'bus/systemimage/systemimage_test.go'
--- bus/systemimage/systemimage_test.go	1970-01-01 00:00:00 +0000
+++ bus/systemimage/systemimage_test.go	2014-04-04 14:39:41 +0000
@@ -0,0 +1,62 @@
+/*
+ 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 systemimage
+
+import (
+	"testing"
+
+	. "launchpad.net/gocheck"
+
+	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/logger"
+	helpers "launchpad.net/ubuntu-push/testing"
+	"launchpad.net/ubuntu-push/testing/condition"
+)
+
+// hook up gocheck
+func TestSystemImage(t *testing.T) { TestingT(t) }
+
+type SISuite struct {
+	log logger.Logger
+}
+
+var _ = Suite(&SISuite{})
+
+func (s *SISuite) SetUpTest(c *C) {
+	s.log = helpers.NewTestLogger(c, "debug")
+}
+
+func (s *SISuite) TestWorks(c *C) {
+	endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{int32(101), "mako", "daily", "Unknown", map[string]string{}})
+	si := New(endp, s.log)
+	res, err := si.Info()
+	c.Assert(err, IsNil)
+	c.Check(res, DeepEquals, &InfoResult{
+		BuildNumber:   101,
+		Device:        "mako",
+		Channel:       "daily",
+		LastUpdate:    "Unknown",
+		VersionDetail: map[string]string{},
+	})
+}
+
+func (s *SISuite) TestFailsIfCallFails(c *C) {
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
+	si := New(endp, s.log)
+	_, err := si.Info()
+	c.Check(err, NotNil)
+}

=== modified file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	2014-02-06 13:26:13 +0000
+++ bus/testing/testing_endpoint.go	2014-04-04 14:39:41 +0000
@@ -21,6 +21,9 @@
 import (
 	"errors"
 	"fmt"
+
+	"launchpad.net/go-dbus/v1"
+
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/testing/condition"
 	"sync"
@@ -37,6 +40,7 @@
 	callCond    condition.Interface
 	retvals     [][]interface{}
 	watchTicker chan bool
+	watchLck    sync.RWMutex
 	callArgs    []callArgs
 	callArgsLck sync.RWMutex
 }
@@ -62,7 +66,9 @@
 // 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) {
+	tc.(*testingEndpoint).watchLck.Lock()
 	tc.(*testingEndpoint).watchTicker = watchTicker
+	tc.(*testingEndpoint).watchLck.Unlock()
 }
 
 // GetCallArgs returns a list of the arguments for each Call() invocation.
@@ -79,8 +85,11 @@
 		go func() {
 			for _, v := range tc.retvals {
 				f(v...)
-				if tc.watchTicker != nil {
-					<-tc.watchTicker
+				tc.watchLck.RLock()
+				ticker := tc.watchTicker
+				tc.watchLck.RUnlock()
+				if ticker != nil {
+					<-ticker
 				} else {
 					time.Sleep(10 * time.Millisecond)
 				}
@@ -95,32 +104,50 @@
 
 // See Endpoint's Call. This Call will check its condition to decide whether
 // to return an error, or the first of its return values
-func (tc *testingEndpoint) Call(member string, args ...interface{}) ([]interface{}, error) {
+func (tc *testingEndpoint) Call(member string, args []interface{}, rvs ...interface{}) error {
 	tc.callArgsLck.Lock()
 	defer tc.callArgsLck.Unlock()
 
 	tc.callArgs = append(tc.callArgs, callArgs{member, args})
 	if tc.callCond.OK() {
+		expected := len(rvs)
+		var provided int
 		if len(tc.retvals) == 0 {
-			panic("No return values provided!")
-		}
-		return tc.retvals[0], nil
+			if expected != 0 {
+				panic("No return values provided!")
+			}
+			provided = 0
+		} else {
+			provided = len(tc.retvals[0])
+		}
+		if provided != expected {
+			return errors.New("provided/expected return vals mismatch")
+		}
+		if provided != 0 {
+			x := dbus.NewMethodCallMessage("", "", "", "")
+			err := x.AppendArgs(tc.retvals[0]...)
+			if err != nil {
+				return err
+			}
+			err = x.Args(rvs...)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
 	} else {
-		return nil, errors.New("no way")
+		return errors.New("no way")
 	}
 }
 
 // See Endpoint's GetProperty. This one is just another name for Call.
 func (tc *testingEndpoint) GetProperty(property string) (interface{}, error) {
-	rvs, err := tc.Call(property)
+	var res interface{}
+	err := tc.Call(property, bus.Args(), &res)
 	if err != nil {
 		return nil, err
 	}
-	if len(rvs) != 1 {
-		return nil, errors.New("Wrong number of values given to testingEndpoint" +
-			" -- GetProperty only returns a single value for now!")
-	}
-	return rvs[0], err
+	return res, err
 }
 
 // See Endpoint's Dial. This one will check its dialCondition to

=== modified file 'bus/testing/testing_endpoint_test.go'
--- bus/testing/testing_endpoint_test.go	2014-02-05 02:13:35 +0000
+++ bus/testing/testing_endpoint_test.go	2014-04-04 14:39:41 +0000
@@ -18,6 +18,7 @@
 
 import (
 	. "launchpad.net/gocheck"
+	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/testing/condition"
 	"testing"
 	"time"
@@ -35,26 +36,26 @@
 func (s *TestingEndpointSuite) TestCallReturnsFirstRetval(c *C) {
 	var m, n uint32 = 42, 17
 	endp := NewTestingEndpoint(nil, condition.Work(true), m, n)
-	vs, e := endp.Call("what")
+	var r uint32
+	e := endp.Call("what", bus.Args(), &r)
 	c.Check(e, IsNil)
-	c.Check(vs, HasLen, 1)
-	c.Check(vs[0], Equals, m)
+	c.Check(r, Equals, m)
 }
 
 // Test the same Call() but with multi-valued endpoint
 func (s *TestingEndpointSuite) TestMultiValuedCall(c *C) {
 	var m, n uint32 = 42, 17
 	endp := NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{m}, []interface{}{n})
-	vs, e := endp.Call("what")
+	var r uint32
+	e := endp.Call("what", bus.Args(), &r)
 	c.Check(e, IsNil)
-	c.Check(vs, HasLen, 1)
-	c.Check(vs[0], Equals, m)
+	c.Check(r, Equals, m)
 }
 
 // Test that Call() with a negative condition returns an error.
 func (s *TestingEndpointSuite) TestCallFails(c *C) {
 	endp := NewTestingEndpoint(nil, condition.Work(false))
-	_, e := endp.Call("what")
+	e := endp.Call("what", bus.Args())
 	c.Check(e, NotNil)
 }
 
@@ -62,13 +63,14 @@
 // a helpful message.
 func (s *TestingEndpointSuite) TestCallPanicsWithNiceMessage(c *C) {
 	endp := NewTestingEndpoint(nil, condition.Work(true))
-	c.Check(func() { endp.Call("") }, PanicMatches, "No return values provided.*")
+	var x int32
+	c.Check(func() { endp.Call("", bus.Args(), &x) }, PanicMatches, "No return values provided.*")
 }
 
 // Test that Call() updates callArgs
 func (s *TestingEndpointSuite) TestCallArgs(c *C) {
-	endp := NewTestingEndpoint(nil, condition.Work(true), 0)
-	_, err := endp.Call("what", "is", "this", "thing")
+	endp := NewTestingEndpoint(nil, condition.Work(true))
+	err := endp.Call("what", bus.Args("is", "this", "thing"))
 	c.Assert(err, IsNil)
 	c.Check(GetCallArgs(endp), DeepEquals,
 		[]callArgs{{"what", []interface{}{"is", "this", "thing"}}})

=== modified file 'bus/urldispatcher/urldispatcher.go'
--- bus/urldispatcher/urldispatcher.go	2014-01-23 00:54:51 +0000
+++ bus/urldispatcher/urldispatcher.go	2014-04-04 14:39:41 +0000
@@ -49,7 +49,7 @@
 
 func (ud *urlDispatcher) DispatchURL(url string) error {
 	ud.log.Debugf("Dispatching %s", url)
-	_, err := ud.endp.Call("DispatchURL", url)
+	err := ud.endp.Call("DispatchURL", bus.Args(url))
 	if err != nil {
 		ud.log.Errorf("Dispatch to %s failed with %s", url, err)
 	}

=== modified file 'client/client.go'
--- client/client.go	2014-03-26 16:26:36 +0000
+++ client/client.go	2014-04-04 14:39:41 +0000
@@ -20,13 +20,19 @@
 
 import (
 	"encoding/pem"
+	"errors"
 	"fmt"
 	"io/ioutil"
+	"os"
+	"strings"
+
 	"launchpad.net/go-dbus/v1"
+
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/bus/connectivity"
 	"launchpad.net/ubuntu-push/bus/networkmanager"
 	"launchpad.net/ubuntu-push/bus/notifications"
+	"launchpad.net/ubuntu-push/bus/systemimage"
 	"launchpad.net/ubuntu-push/bus/urldispatcher"
 	"launchpad.net/ubuntu-push/client/session"
 	"launchpad.net/ubuntu-push/client/session/levelmap"
@@ -34,7 +40,6 @@
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/util"
 	"launchpad.net/ubuntu-push/whoopsie/identifier"
-	"os"
 )
 
 // ClientConfig holds the client configuration
@@ -42,8 +47,13 @@
 	connectivity.ConnectivityConfig // q.v.
 	// A reasonably large timeout for receive/answer pairs
 	ExchangeTimeout config.ConfigTimeDuration `json:"exchange_timeout"`
-	// The server to connect to
-	Addr config.ConfigHostPort
+	// A timeout to use when trying to connect to the server
+	ConnectTimeout config.ConfigTimeDuration `json:"connect_timeout"`
+	// The server to connect to or url to query for hosts to connect to
+	Addr string
+	// Host list management
+	HostsCachingExpiryTime config.ConfigTimeDuration `json:"hosts_cache_expiry"`  // potentially refresh host list after
+	ExpectAllRepairedTime  config.ConfigTimeDuration `json:"expect_all_repaired"` // worth retrying all servers after
 	// The PEM-encoded server certificate
 	CertPEMFile string `json:"cert_pem_file"`
 	// The logging level (one of "debug", "info", "error")
@@ -62,6 +72,8 @@
 	notificationsEndp  bus.Endpoint
 	urlDispatcherEndp  bus.Endpoint
 	connectivityEndp   bus.Endpoint
+	systemImageEndp    bus.Endpoint
+	systemImageInfo    *systemimage.InfoResult
 	connCh             chan bool
 	hasConnectivity    bool
 	actionsCh          <-chan notifications.RawActionReply
@@ -89,6 +101,12 @@
 	if err != nil {
 		return fmt.Errorf("reading config: %v", err)
 	}
+	// ignore spaces
+	client.config.Addr = strings.Replace(client.config.Addr, " ", "", -1)
+	if client.config.Addr == "" {
+		return errors.New("no hosts specified")
+	}
+
 	// later, we'll be specifying more logging options in the config file
 	client.log = logger.NewSimpleLogger(os.Stderr, client.config.LogLevel)
 
@@ -97,6 +115,7 @@
 	client.notificationsEndp = bus.SessionBus.Endpoint(notifications.BusAddress, client.log)
 	client.urlDispatcherEndp = bus.SessionBus.Endpoint(urldispatcher.BusAddress, client.log)
 	client.connectivityEndp = bus.SystemBus.Endpoint(networkmanager.BusAddress, client.log)
+	client.systemImageEndp = bus.SystemBus.Endpoint(systemimage.BusAddress, client.log)
 
 	client.connCh = make(chan bool, 1)
 	client.sessionConnectedCh = make(chan uint32, 1)
@@ -116,6 +135,18 @@
 	return nil
 }
 
+// deriveSessionConfig dervies the session configuration from the client configuration bits.
+func (client *PushClient) deriveSessionConfig(info map[string]interface{}) session.ClientSessionConfig {
+	return session.ClientSessionConfig{
+		ConnectTimeout:         client.config.ConnectTimeout.TimeDuration(),
+		ExchangeTimeout:        client.config.ExchangeTimeout.TimeDuration(),
+		HostsCachingExpiryTime: client.config.HostsCachingExpiryTime.TimeDuration(),
+		ExpectAllRepairedTime:  client.config.ExpectAllRepairedTime.TimeDuration(),
+		PEM:  client.pem,
+		Info: info,
+	}
+}
+
 // getDeviceId gets the whoopsie identifier for the device
 func (client *PushClient) getDeviceId() error {
 	err := client.idder.Generate()
@@ -133,8 +164,17 @@
 	iniCh := make(chan uint32)
 	go func() { iniCh <- util.NewAutoRedialer(client.notificationsEndp).Redial() }()
 	go func() { iniCh <- util.NewAutoRedialer(client.urlDispatcherEndp).Redial() }()
-	<-iniCh
-	<-iniCh
+	go func() { iniCh <- util.NewAutoRedialer(client.systemImageEndp).Redial() }()
+	<-iniCh
+	<-iniCh
+	<-iniCh
+
+	sysimg := systemimage.New(client.systemImageEndp, client.log)
+	info, err := sysimg.Info()
+	if err != nil {
+		return err
+	}
+	client.systemImageInfo = info
 
 	actionsCh, err := notifications.Raw(client.notificationsEndp, client.log).WatchActions()
 	client.actionsCh = actionsCh
@@ -143,8 +183,13 @@
 
 // initSession creates the session object
 func (client *PushClient) initSession() error {
-	sess, err := session.NewSession(string(client.config.Addr), client.pem,
-		client.config.ExchangeTimeout.Duration, client.deviceId,
+	info := map[string]interface{}{
+		"device":       client.systemImageInfo.Device,
+		"channel":      client.systemImageInfo.Channel,
+		"build_number": client.systemImageInfo.BuildNumber,
+	}
+	sess, err := session.NewSession(client.config.Addr,
+		client.deriveSessionConfig(info), client.deviceId,
 		client.levelMapFactory, client.log)
 	if err != nil {
 		return err
@@ -185,8 +230,54 @@
 	}
 }
 
+// filterNotification finds out if the notification is about an actual
+// upgrade for the device. It expects msg.Decoded entries to look
+// like:
+//
+// {
+// "IMAGE-CHANNEL/DEVICE-MODEL": [BUILD-NUMBER, CHANNEL-ALIAS]
+// ...
+// }
+func (client *PushClient) filterNotification(msg *session.Notification) bool {
+	n := len(msg.Decoded)
+	if n == 0 {
+		return false
+	}
+	// they are all for us, consider last
+	last := msg.Decoded[n-1]
+	tag := fmt.Sprintf("%s/%s", client.systemImageInfo.Channel, client.systemImageInfo.Device)
+	entry, ok := last[tag]
+	if !ok {
+		return false
+	}
+	pair, ok := entry.([]interface{})
+	if !ok {
+		return false
+	}
+	if len(pair) < 1 {
+		return false
+	}
+	buildNumber, ok := pair[0].(float64)
+	if !ok {
+		return false
+	}
+	curBuildNumber := float64(client.systemImageInfo.BuildNumber)
+	if buildNumber > curBuildNumber {
+		return true
+	}
+	// xxx we should really compare channel_target and alias here
+	// going backward by a margin, assume switch of target
+	if buildNumber < curBuildNumber && (curBuildNumber-buildNumber) > 10 {
+		return true
+	}
+	return false
+}
+
 // handleNotification deals with receiving a notification
 func (client *PushClient) handleNotification(msg *session.Notification) error {
+	if !client.filterNotification(msg) {
+		return nil
+	}
 	action_id := "dummy_id"
 	a := []string{action_id, "Go get it!"} // action value not visible on the phone
 	h := map[string]*dbus.Variant{"x-canonical-switch-to-application": &dbus.Variant{true}}
@@ -260,7 +351,7 @@
 	return client.doStart(
 		client.configure,
 		client.getDeviceId,
+		client.takeTheBus,
 		client.initSession,
-		client.takeTheBus,
 	)
 }

=== modified file 'client/client_test.go'
--- client/client_test.go	2014-03-26 16:26:36 +0000
+++ client/client_test.go	2014-04-04 14:39:41 +0000
@@ -17,13 +17,23 @@
 package client
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"reflect"
+	"testing"
+	"time"
+
 	. "launchpad.net/gocheck"
+
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/bus/networkmanager"
 	"launchpad.net/ubuntu-push/bus/notifications"
+	"launchpad.net/ubuntu-push/bus/systemimage"
 	testibus "launchpad.net/ubuntu-push/bus/testing"
 	"launchpad.net/ubuntu-push/client/session"
 	"launchpad.net/ubuntu-push/client/session/levelmap"
@@ -32,11 +42,6 @@
 	"launchpad.net/ubuntu-push/util"
 	"launchpad.net/ubuntu-push/whoopsie/identifier"
 	idtesting "launchpad.net/ubuntu-push/whoopsie/identifier/testing"
-	"net/http"
-	"net/http/httptest"
-	"path/filepath"
-	"testing"
-	"time"
 )
 
 func TestClient(t *testing.T) { TestingT(t) }
@@ -83,22 +88,37 @@
 	cs.timeouts = nil
 }
 
+func (cs *clientSuite) writeTestConfig(overrides map[string]interface{}) {
+	pem_file := helpers.SourceRelative("../server/acceptance/ssl/testing.cert")
+	cfgMap := map[string]interface{}{
+		"connect_timeout":        "7ms",
+		"exchange_timeout":       "10ms",
+		"hosts_cache_expiry":     "1h",
+		"expect_all_repaired":    "30m",
+		"stabilizing_timeout":    "0ms",
+		"connectivity_check_url": "",
+		"connectivity_check_md5": "",
+		"addr":            ":0",
+		"cert_pem_file":   pem_file,
+		"recheck_timeout": "3h",
+		"log_level":       "debug",
+	}
+	for k, v := range overrides {
+		cfgMap[k] = v
+	}
+	cfgBlob, err := json.Marshal(cfgMap)
+	if err != nil {
+		panic(err)
+	}
+	ioutil.WriteFile(cs.configPath, cfgBlob, 0600)
+}
+
 func (cs *clientSuite) SetUpTest(c *C) {
 	cs.log = helpers.NewTestLogger(c, "debug")
 	dir := c.MkDir()
 	cs.configPath = filepath.Join(dir, "config")
-	cfg := fmt.Sprintf(`
-{
-    "exchange_timeout": "10ms",
-    "stabilizing_timeout": "0ms",
-    "connectivity_check_url": "",
-    "connectivity_check_md5": "",
-    "addr": ":0",
-    "cert_pem_file": %#v,
-    "recheck_timeout": "3h",
-    "log_level": "debug"
-}`, helpers.SourceRelative("../server/acceptance/config/testing.cert"))
-	ioutil.WriteFile(cs.configPath, []byte(cfg), 0600)
+
+	cs.writeTestConfig(nil)
 }
 
 type sqlientSuite struct{ clientSuite }
@@ -119,7 +139,7 @@
 	err := cli.configure()
 	c.Assert(err, IsNil)
 	c.Assert(cli.config, NotNil)
-	c.Check(cli.config.ExchangeTimeout.Duration, Equals, time.Duration(10*time.Millisecond))
+	c.Check(cli.config.ExchangeTimeout.TimeDuration(), Equals, time.Duration(10*time.Millisecond))
 }
 
 func (cs *clientSuite) TestConfigureSetsUpLog(c *C) {
@@ -179,41 +199,74 @@
 }
 
 func (cs *clientSuite) TestConfigureBailsOnBadPEMFilename(c *C) {
-	ioutil.WriteFile(cs.configPath, []byte(`
-{
-    "exchange_timeout": "10ms",
-    "stabilizing_timeout": "0ms",
-    "connectivity_check_url": "",
-    "connectivity_check_md5": "",
-    "addr": ":0",
-    "cert_pem_file": "/a/b/c",
-    "log_level": "debug",
-    "recheck_timeout": "3h"
-}`), 0600)
-
+	cs.writeTestConfig(map[string]interface{}{
+		"cert_pem_file": "/a/b/c",
+	})
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	err := cli.configure()
 	c.Assert(err, ErrorMatches, "reading PEM file: .*")
 }
 
 func (cs *clientSuite) TestConfigureBailsOnBadPEM(c *C) {
-	ioutil.WriteFile(cs.configPath, []byte(`
-{
-    "exchange_timeout": "10ms",
-    "stabilizing_timeout": "0ms",
-    "connectivity_check_url": "",
-    "connectivity_check_md5": "",
-    "addr": ":0",
-    "cert_pem_file": "/etc/passwd",
-    "log_level": "debug",
-    "recheck_timeout": "3h"
-}`), 0600)
-
+	cs.writeTestConfig(map[string]interface{}{
+		"cert_pem_file": "/etc/passwd",
+	})
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	err := cli.configure()
 	c.Assert(err, ErrorMatches, "no PEM found.*")
 }
 
+func (cs *clientSuite) TestConfigureBailsOnNoHosts(c *C) {
+	cs.writeTestConfig(map[string]interface{}{
+		"addr": "  ",
+	})
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	err := cli.configure()
+	c.Assert(err, ErrorMatches, "no hosts specified")
+}
+
+func (cs *clientSuite) TestConfigureRemovesBlanksInAddr(c *C) {
+	cs.writeTestConfig(map[string]interface{}{
+		"addr": " foo: 443",
+	})
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	err := cli.configure()
+	c.Assert(err, IsNil)
+	c.Check(cli.config.Addr, Equals, "foo:443")
+}
+
+/*****************************************************************
+    deriveSessionConfig tests
+******************************************************************/
+
+func (cs *clientSuite) TestDeriveSessionConfig(c *C) {
+	info := map[string]interface{}{
+		"foo": 1,
+	}
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	err := cli.configure()
+	c.Assert(err, IsNil)
+	expected := session.ClientSessionConfig{
+		ConnectTimeout:         7 * time.Millisecond,
+		ExchangeTimeout:        10 * time.Millisecond,
+		HostsCachingExpiryTime: 1 * time.Hour,
+		ExpectAllRepairedTime:  30 * time.Minute,
+		PEM:  cli.pem,
+		Info: info,
+	}
+	// sanity check that we are looking at all fields
+	vExpected := reflect.ValueOf(expected)
+	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
+	conf := cli.deriveSessionConfig(info)
+	c.Check(conf, DeepEquals, expected)
+}
+
 /*****************************************************************
     getDeviceId tests
 ******************************************************************/
@@ -254,6 +307,8 @@
 	cEndp := testibus.NewTestingEndpoint(cCond, condition.Work(true),
 		uint32(networkmanager.ConnectedGlobal),
 	)
+	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))
 	// ok, create the thing
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
@@ -269,6 +324,7 @@
 	cli.notificationsEndp = nEndp
 	cli.urlDispatcherEndp = uEndp
 	cli.connectivityEndp = cEndp
+	cli.systemImageEndp = siEndp
 
 	c.Assert(cli.takeTheBus(), IsNil)
 	// the notifications and urldispatcher endpoints retried until connected
@@ -280,6 +336,8 @@
 	c.Check(takeNextBool(cli.connCh), Equals, true)
 	// the connectivity endpoint retried until connected
 	c.Check(cCond.OK(), Equals, true)
+	// the systemimage endpoint retried until connected
+	c.Check(siCond.OK(), Equals, true)
 }
 
 // takeTheBus can, in fact, fail
@@ -295,6 +353,7 @@
 	cli.notificationsEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
 	cli.urlDispatcherEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
 	cli.connectivityEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
+	cli.systemImageEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
 
 	c.Check(cli.takeTheBus(), NotNil)
 	c.Check(cli.actionsCh, IsNil)
@@ -307,7 +366,9 @@
 func (cs *clientSuite) TestHandleErr(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
+	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSession(), IsNil)
+	cs.log.ResetCapture()
 	cli.hasConnectivity = true
 	cli.handleErr(errors.New("bananas"))
 	c.Check(cs.log.Captured(), Matches, ".*session exited.*bananas\n")
@@ -338,6 +399,7 @@
 func (cs *clientSuite) TestHandleConnStateD2C(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
+	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSession(), IsNil)
 
 	c.Assert(cli.hasConnectivity, Equals, false)
@@ -363,7 +425,7 @@
 func (cs *clientSuite) TestHandleConnStateC2D(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
-	cli.session, _ = session.NewSession(string(cli.config.Addr), cli.pem, cli.config.ExchangeTimeout.Duration, cli.deviceId, levelmap.NewLevelMap, cs.log)
+	cli.session, _ = session.NewSession(cli.config.Addr, cli.deriveSessionConfig(nil), cli.deviceId, levelmap.NewLevelMap, cs.log)
 	cli.session.Dial()
 	cli.hasConnectivity = true
 
@@ -376,7 +438,7 @@
 func (cs *clientSuite) TestHandleConnStateC2DPending(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
-	cli.session, _ = session.NewSession(string(cli.config.Addr), cli.pem, cli.config.ExchangeTimeout.Duration, cli.deviceId, levelmap.NewLevelMap, cs.log)
+	cli.session, _ = session.NewSession(cli.config.Addr, cli.deriveSessionConfig(nil), cli.deviceId, levelmap.NewLevelMap, cs.log)
 	cli.hasConnectivity = true
 
 	cli.handleConnState(false)
@@ -384,15 +446,110 @@
 }
 
 /*****************************************************************
+   filterNotification tests
+******************************************************************/
+
+var siInfoRes = &systemimage.InfoResult{
+	Device:      "mako",
+	Channel:     "daily",
+	BuildNumber: 102,
+	LastUpdate:  "Unknown",
+}
+
+func (cs *clientSuite) TestFilterNotification(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.systemImageInfo = siInfoRes
+	// empty
+	msg := &session.Notification{}
+	c.Check(cli.filterNotification(msg), Equals, false)
+	// same build number
+	msg = &session.Notification{
+		Decoded: []map[string]interface{}{
+			map[string]interface{}{
+				"daily/mako": []interface{}{float64(102), "tubular"},
+			},
+		},
+	}
+	c.Check(cli.filterNotification(msg), Equals, false)
+	// higher build number and pick last
+	msg = &session.Notification{
+		Decoded: []map[string]interface{}{
+			map[string]interface{}{
+				"daily/mako": []interface{}{float64(102), "tubular"},
+			},
+			map[string]interface{}{
+				"daily/mako": []interface{}{float64(103), "tubular"},
+			},
+		},
+	}
+	c.Check(cli.filterNotification(msg), Equals, true)
+	// going backward by a margin, assume switch of alias
+	msg = &session.Notification{
+		Decoded: []map[string]interface{}{
+			map[string]interface{}{
+				"daily/mako": []interface{}{float64(102), "tubular"},
+			},
+			map[string]interface{}{
+				"daily/mako": []interface{}{float64(2), "urban"},
+			},
+		},
+	}
+	c.Check(cli.filterNotification(msg), Equals, true)
+}
+
+func (cs *clientSuite) TestFilterNotificationRobust(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.systemImageInfo = siInfoRes
+	msg := &session.Notification{
+		Decoded: []map[string]interface{}{
+			map[string]interface{}{},
+		},
+	}
+	c.Check(cli.filterNotification(msg), Equals, false)
+	for _, broken := range []interface{}{
+		5,
+		[]interface{}{},
+		[]interface{}{55},
+	} {
+		msg := &session.Notification{
+			Decoded: []map[string]interface{}{
+				map[string]interface{}{
+					"daily/mako": broken,
+				},
+			},
+		}
+		c.Check(cli.filterNotification(msg), Equals, false)
+	}
+}
+
+/*****************************************************************
     handleNotification tests
 ******************************************************************/
 
+var (
+	positiveNotification = &session.Notification{
+		Decoded: []map[string]interface{}{
+			map[string]interface{}{
+				"daily/mako": []interface{}{float64(103), "tubular"},
+			},
+		},
+	}
+	negativeNotification = &session.Notification{
+		Decoded: []map[string]interface{}{
+			map[string]interface{}{
+				"daily/mako": []interface{}{float64(102), "tubular"},
+			},
+		},
+	}
+)
+
 func (cs *clientSuite) TestHandleNotification(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.systemImageInfo = siInfoRes
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	cli.notificationsEndp = endp
 	cli.log = cs.log
-	c.Check(cli.handleNotification(nil), IsNil)
+	c.Check(cli.handleNotification(positiveNotification), IsNil)
 	// check we sent the notification
 	args := testibus.GetCallArgs(endp)
 	c.Assert(args, HasLen, 1)
@@ -400,12 +557,26 @@
 	c.Check(cs.log.Captured(), Matches, `.* got notification id \d+\s*`)
 }
 
+func (cs *clientSuite) TestHandleNotificationNothingToDo(c *C) {
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.systemImageInfo = siInfoRes
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
+	cli.notificationsEndp = endp
+	cli.log = cs.log
+	c.Check(cli.handleNotification(negativeNotification), IsNil)
+	// check we sent the notification
+	args := testibus.GetCallArgs(endp)
+	c.Assert(args, HasLen, 0)
+	c.Check(cs.log.Captured(), Matches, "")
+}
+
 func (cs *clientSuite) TestHandleNotificationFail(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	cli.systemImageInfo = siInfoRes
 	cli.log = cs.log
 	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
 	cli.notificationsEndp = endp
-	c.Check(cli.handleNotification(nil), NotNil)
+	c.Check(cli.handleNotification(positiveNotification), NotNil)
 }
 
 /*****************************************************************
@@ -415,7 +586,7 @@
 func (cs *clientSuite) TestHandleClick(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
-	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), nil)
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true))
 	cli.urlDispatcherEndp = endp
 	c.Check(cli.handleClick(), IsNil)
 	// check we sent the notification
@@ -432,6 +603,7 @@
 func (cs *clientSuite) TestDoLoopConn(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
+	cli.systemImageInfo = siInfoRes
 	cli.connCh = make(chan bool, 1)
 	cli.connCh <- true
 	c.Assert(cli.initSession(), IsNil)
@@ -444,6 +616,7 @@
 func (cs *clientSuite) TestDoLoopClick(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
+	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSession(), IsNil)
 	aCh := make(chan notifications.RawActionReply, 1)
 	aCh <- notifications.RawActionReply{}
@@ -457,6 +630,7 @@
 func (cs *clientSuite) TestDoLoopNotif(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
+	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSession(), IsNil)
 	cli.session.MsgCh = make(chan *session.Notification, 1)
 	cli.session.MsgCh <- &session.Notification{}
@@ -469,6 +643,7 @@
 func (cs *clientSuite) TestDoLoopErr(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	cli.log = cs.log
+	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSession(), IsNil)
 	cli.session.ErrCh = make(chan error, 1)
 	cli.session.ErrCh <- nil
@@ -521,7 +696,7 @@
 	cli.urlDispatcherEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(false))
 	cli.connectivityEndp = testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true),
 		uint32(networkmanager.ConnectedGlobal))
-
+	cli.systemImageInfo = siInfoRes
 	c.Assert(cli.initSession(), IsNil)
 
 	cli.session.MsgCh = make(chan *session.Notification)
@@ -558,7 +733,7 @@
 	c.Check(cli.hasConnectivity, Equals, false)
 
 	//  * session.MsgCh to the notifications handler
-	cli.session.MsgCh <- &session.Notification{}
+	cli.session.MsgCh <- positiveNotification
 	tick()
 	nargs := testibus.GetCallArgs(cli.notificationsEndp)
 	c.Check(nargs, HasLen, 1)

=== modified file 'client/gethosts/gethost_test.go'
--- client/gethosts/gethost_test.go	2014-03-24 15:32:29 +0000
+++ client/gethosts/gethost_test.go	2014-04-04 14:39:41 +0000
@@ -61,18 +61,16 @@
 }
 
 func (s *getHostsSuite) TestGetTimeout(c *C) {
-	finish := make(chan bool, 1)
+	started := make(chan bool, 1)
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		<-finish
+		started <- true
+		time.Sleep(700 * time.Millisecond)
 	}))
 	defer func() {
-		time.Sleep(100 * time.Millisecond) // work around -race issue
+		<-started
 		ts.Close()
 	}()
-	defer func() {
-		finish <- true
-	}()
-	gh := New("foobar", ts.URL, 1*time.Second)
+	gh := New("foobar", ts.URL, 500*time.Millisecond)
 	_, err := gh.Get()
 	c.Check(err, ErrorMatches, ".*closed.*")
 }

=== modified file 'client/session/session.go'
--- client/session/session.go	2014-03-26 16:26:36 +0000
+++ client/session/session.go	2014-04-04 14:39:41 +0000
@@ -21,22 +21,28 @@
 import (
 	"crypto/tls"
 	"crypto/x509"
+	"encoding/json"
 	"errors"
 	"fmt"
+	"math/rand"
+	"net"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"launchpad.net/ubuntu-push/client/gethosts"
 	"launchpad.net/ubuntu-push/client/session/levelmap"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/protocol"
 	"launchpad.net/ubuntu-push/util"
-	"math/rand"
-	"net"
-	"sync/atomic"
-	"time"
 )
 
 var wireVersionBytes = []byte{protocol.ProtocolWireVersion}
 
 type Notification struct {
 	TopLevel int64
+	Decoded  []map[string]interface{}
 }
 
 type serverMsg struct {
@@ -45,6 +51,15 @@
 	protocol.NotificationsMsg
 }
 
+// parseServerAddrSpec recognizes whether spec is a HTTP URL to get
+// hosts from or a |-separated list of host:port pairs.
+func parseServerAddrSpec(spec string) (hostsEndpoint string, fallbackHosts []string) {
+	if strings.HasPrefix(spec, "http") {
+		return spec, nil
+	}
+	return "", strings.Split(spec, "|")
+}
+
 // ClientSessionState is a way to broadly track the progress of the session
 type ClientSessionState uint32
 
@@ -56,15 +71,39 @@
 	Running
 )
 
-// ClienSession holds a client<->server session and its configuration.
+type hostGetter interface {
+	Get() ([]string, error)
+}
+
+// ClientSessionConfig groups the client session configuration.
+type ClientSessionConfig struct {
+	ConnectTimeout         time.Duration
+	ExchangeTimeout        time.Duration
+	HostsCachingExpiryTime time.Duration
+	ExpectAllRepairedTime  time.Duration
+	PEM                    []byte
+	Info                   map[string]interface{}
+}
+
+// ClientSession holds a client<->server session and its configuration.
 type ClientSession struct {
 	// configuration
-	DeviceId        string
-	ServerAddr      string
-	ExchangeTimeout time.Duration
-	Levels          levelmap.LevelMap
-	Protocolator    func(net.Conn) protocol.Protocol
+	DeviceId string
+	ClientSessionConfig
+	Levels       levelmap.LevelMap
+	Protocolator func(net.Conn) protocol.Protocol
+	// hosts
+	getHost                hostGetter
+	fallbackHosts          []string
+	deliveryHostsTimestamp time.Time
+	deliveryHosts          []string
+	lastAttemptTimestamp   time.Time
+	leftToTry              int
+	tryHost                int
+	// hook for testing
+	timeSince func(time.Time) time.Duration
 	// connection
+	connLock     sync.RWMutex
 	Connection   net.Conn
 	Log          logger.Logger
 	TLS          *tls.Config
@@ -77,7 +116,7 @@
 	MsgCh  chan *Notification
 }
 
-func NewSession(serverAddr string, pem []byte, exchangeTimeout time.Duration,
+func NewSession(serverAddrSpec string, conf ClientSessionConfig,
 	deviceId string, levelmapFactory func() (levelmap.LevelMap, error),
 	log logger.Logger) (*ClientSession, error) {
 	state := uint32(Disconnected)
@@ -85,19 +124,27 @@
 	if err != nil {
 		return nil, err
 	}
+	var getHost hostGetter
+	log.Infof("using addr: %v", serverAddrSpec)
+	hostsEndpoint, fallbackHosts := parseServerAddrSpec(serverAddrSpec)
+	if hostsEndpoint != "" {
+		getHost = gethosts.New(deviceId, hostsEndpoint, conf.ExchangeTimeout)
+	}
 	sess := &ClientSession{
-		ExchangeTimeout: exchangeTimeout,
-		ServerAddr:      serverAddr,
-		DeviceId:        deviceId,
-		Log:             log,
-		Protocolator:    protocol.NewProtocol0,
-		Levels:          levels,
-		TLS:             &tls.Config{InsecureSkipVerify: true}, // XXX
-		stateP:          &state,
+		ClientSessionConfig: conf,
+		getHost:             getHost,
+		fallbackHosts:       fallbackHosts,
+		DeviceId:            deviceId,
+		Log:                 log,
+		Protocolator:        protocol.NewProtocol0,
+		Levels:              levels,
+		TLS:                 &tls.Config{InsecureSkipVerify: true}, // XXX
+		stateP:              &state,
+		timeSince:           time.Since,
 	}
-	if pem != nil {
+	if sess.PEM != nil {
 		cp := x509.NewCertPool()
-		ok := cp.AppendCertsFromPEM(pem)
+		ok := cp.AppendCertsFromPEM(sess.PEM)
 		if !ok {
 			return nil, errors.New("could not parse certificate")
 		}
@@ -114,15 +161,90 @@
 	atomic.StoreUint32(sess.stateP, uint32(state))
 }
 
+func (sess *ClientSession) setConnection(conn net.Conn) {
+	sess.connLock.Lock()
+	defer sess.connLock.Unlock()
+	sess.Connection = conn
+}
+
+func (sess *ClientSession) getConnection() net.Conn {
+	sess.connLock.RLock()
+	defer sess.connLock.RUnlock()
+	return sess.Connection
+}
+
+// getHosts sets deliveryHosts possibly querying a remote endpoint
+func (sess *ClientSession) getHosts() error {
+	if sess.getHost != nil {
+		if sess.timeSince(sess.deliveryHostsTimestamp) < sess.HostsCachingExpiryTime {
+			return nil
+		}
+		hosts, err := sess.getHost.Get()
+		if err != nil {
+			sess.Log.Errorf("getHosts: %v", err)
+			sess.setState(Error)
+			return err
+		}
+		sess.deliveryHostsTimestamp = time.Now()
+		sess.deliveryHosts = hosts
+	} else {
+		sess.deliveryHosts = sess.fallbackHosts
+	}
+	return nil
+}
+
+// startConnectionAttempt/nextHostToTry help connect iterating over candidate hosts
+
+func (sess *ClientSession) startConnectionAttempt() {
+	if sess.timeSince(sess.lastAttemptTimestamp) > sess.ExpectAllRepairedTime {
+		sess.tryHost = 0
+	}
+	sess.leftToTry = len(sess.deliveryHosts)
+	if sess.leftToTry == 0 {
+		panic("should have got hosts from config or remote at this point")
+	}
+	sess.lastAttemptTimestamp = time.Now()
+}
+
+func (sess *ClientSession) nextHostToTry() string {
+	if sess.leftToTry == 0 {
+		return ""
+	}
+	res := sess.deliveryHosts[sess.tryHost]
+	sess.tryHost = (sess.tryHost + 1) % len(sess.deliveryHosts)
+	sess.leftToTry--
+	return res
+}
+
+// we reached the Started state, we can retry with the same host if we
+// have to retry again
+func (sess *ClientSession) started() {
+	sess.tryHost--
+	if sess.tryHost == -1 {
+		sess.tryHost = len(sess.deliveryHosts) - 1
+	}
+	sess.setState(Started)
+}
+
 // connect to a server using the configuration in the ClientSession
 // and set up the connection.
 func (sess *ClientSession) connect() error {
-	conn, err := net.DialTimeout("tcp", sess.ServerAddr, sess.ExchangeTimeout)
-	if err != nil {
-		sess.setState(Error)
-		return fmt.Errorf("connect: %s", err)
+	sess.startConnectionAttempt()
+	var err error
+	var conn net.Conn
+	for {
+		host := sess.nextHostToTry()
+		if host == "" {
+			sess.setState(Error)
+			return fmt.Errorf("connect: %s", err)
+		}
+		sess.Log.Debugf("trying to connect to: %v", host)
+		conn, err = net.DialTimeout("tcp", host, sess.ConnectTimeout)
+		if err == nil {
+			break
+		}
 	}
-	sess.Connection = tls.Client(conn, sess.TLS)
+	sess.setConnection(tls.Client(conn, sess.TLS))
 	sess.setState(Connected)
 	return nil
 }
@@ -145,6 +267,8 @@
 	sess.doClose()
 }
 func (sess *ClientSession) doClose() {
+	sess.connLock.Lock()
+	defer sess.connLock.Unlock()
 	if sess.Connection != nil {
 		sess.Connection.Close()
 		// we ignore Close errors, on purpose (the thinking being that
@@ -167,6 +291,23 @@
 	return err
 }
 
+func (sess *ClientSession) decodeBroadcast(bcast *serverMsg) *Notification {
+	decoded := make([]map[string]interface{}, 0)
+	for _, p := range bcast.Payloads {
+		var v map[string]interface{}
+		err := json.Unmarshal(p, &v)
+		if err != nil {
+			sess.Log.Debugf("expected map in broadcast: %v", err)
+			continue
+		}
+		decoded = append(decoded, v)
+	}
+	return &Notification{
+		TopLevel: bcast.TopLevel,
+		Decoded:  decoded,
+	}
+}
+
 // handle "broadcast" messages
 func (sess *ClientSession) handleBroadcast(bcast *serverMsg) error {
 	err := sess.Levels.Set(bcast.ChanId, bcast.TopLevel)
@@ -189,7 +330,7 @@
 	if bcast.ChanId == protocol.SystemChannelId {
 		// the system channel id, the only one we care about for now
 		sess.Log.Debugf("sending it over")
-		sess.MsgCh <- &Notification{bcast.TopLevel}
+		sess.MsgCh <- sess.decodeBroadcast(bcast)
 		sess.Log.Debugf("sent it over")
 	} else {
 		sess.Log.Debugf("what is this weird channel, %#v?", bcast.ChanId)
@@ -224,7 +365,7 @@
 
 // Call this when you've connected and want to start looping.
 func (sess *ClientSession) start() error {
-	conn := sess.Connection
+	conn := sess.getConnection()
 	err := conn.SetDeadline(time.Now().Add(sess.ExchangeTimeout))
 	if err != nil {
 		sess.setState(Error)
@@ -253,6 +394,7 @@
 		// xxx get the SSO Authorization string from the phone
 		Authorization: "",
 		Levels:        levels,
+		Info:          sess.Info,
 	})
 	if err != nil {
 		sess.setState(Error)
@@ -278,16 +420,20 @@
 	}
 	sess.proto = proto
 	sess.pingInterval = pingInterval
-	sess.Log.Debugf("Connected %v.", conn.LocalAddr())
-	sess.setState(Started)
+	sess.Log.Debugf("Connected %v.", conn.RemoteAddr())
+	sess.started() // deals with choosing which host to retry with as well
 	return nil
 }
 
 // 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(), connecter, starter, looper func() error) error {
+func (sess *ClientSession) run(closer func(), hostGetter, connecter, starter, looper func() error) error {
 	closer()
-	err := connecter()
+	err := hostGetter()
+	if err != nil {
+		return err
+	}
+	err = connecter()
 	if err == nil {
 		err = starter()
 		if err == nil {
@@ -317,7 +463,7 @@
 		// keep on trying.
 		panic("can't Dial() without a protocol constructor.")
 	}
-	return sess.run(sess.doClose, sess.connect, sess.start, sess.loop)
+	return sess.run(sess.doClose, sess.getHosts, sess.connect, sess.start, sess.loop)
 }
 
 func init() {

=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-03-27 13:26:10 +0000
+++ client/session/session_test.go	2014-04-04 14:39:41 +0000
@@ -23,16 +23,21 @@
 	"fmt"
 	"io"
 	"io/ioutil"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+	"time"
+
 	. "launchpad.net/gocheck"
+
 	"launchpad.net/ubuntu-push/client/session/levelmap"
+	//"launchpad.net/ubuntu-push/client/gethosts"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/protocol"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
-	"net"
-	"reflect"
-	"testing"
-	"time"
 )
 
 func TestSession(t *testing.T) { TestingT(t) }
@@ -181,23 +186,51 @@
 }
 
 /****************************************************************
+  parseServerAddrSpec() tests
+****************************************************************/
+
+func (cs *clientSessionSuite) TestParseServerAddrSpec(c *C) {
+	hEp, fallbackHosts := parseServerAddrSpec("http://foo/hosts")
+	c.Check(hEp, Equals, "http://foo/hosts")
+	c.Check(fallbackHosts, IsNil)
+
+	hEp, fallbackHosts = parseServerAddrSpec("foo:443")
+	c.Check(hEp, Equals, "")
+	c.Check(fallbackHosts, DeepEquals, []string{"foo:443"})
+
+	hEp, fallbackHosts = parseServerAddrSpec("foo:443|bar:443")
+	c.Check(hEp, Equals, "")
+	c.Check(fallbackHosts, DeepEquals, []string{"foo:443", "bar:443"})
+}
+
+/****************************************************************
   NewSession() tests
 ****************************************************************/
 
+var dummyConf = ClientSessionConfig{}
+
 func (cs *clientSessionSuite) TestNewSessionPlainWorks(c *C) {
-	sess, err := NewSession("", nil, 0, "", 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"})
 	// but no root CAs set
 	c.Check(sess.TLS.RootCAs, IsNil)
 	c.Check(sess.State(), Equals, Disconnected)
 }
 
-var certfile string = helpers.SourceRelative("../../server/acceptance/config/testing.cert")
+func (cs *clientSessionSuite) TestNewSessionHostEndpointWorks(c *C) {
+	sess, err := NewSession("http://foo/hosts", dummyConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	c.Check(sess.getHost, NotNil)
+}
+
+var certfile string = helpers.SourceRelative("../../server/acceptance/ssl/testing.cert")
 var pem, _ = ioutil.ReadFile(certfile)
 
 func (cs *clientSessionSuite) TestNewSessionPEMWorks(c *C) {
-	sess, err := NewSession("", pem, 0, "wah", cs.lvls, cs.log)
+	conf := ClientSessionConfig{PEM: pem}
+	sess, err := NewSession("", conf, "wah", cs.lvls, cs.log)
 	c.Check(sess, NotNil)
 	c.Assert(err, IsNil)
 	c.Check(sess.TLS.RootCAs, NotNil)
@@ -205,25 +238,172 @@
 
 func (cs *clientSessionSuite) TestNewSessionBadPEMFileContentFails(c *C) {
 	badpem := []byte("This is not the PEM you're looking for.")
-	sess, err := NewSession("", badpem, 0, "wah", cs.lvls, cs.log)
+	conf := ClientSessionConfig{PEM: badpem}
+	sess, err := NewSession("", conf, "wah", cs.lvls, cs.log)
 	c.Check(sess, IsNil)
 	c.Check(err, NotNil)
 }
 
 func (cs *clientSessionSuite) TestNewSessionBadLevelMapFails(c *C) {
 	ferr := func() (levelmap.LevelMap, error) { return nil, errors.New("Busted.") }
-	sess, err := NewSession("", nil, 0, "wah", ferr, cs.log)
+	sess, err := NewSession("", dummyConf, "wah", ferr, cs.log)
 	c.Check(sess, IsNil)
 	c.Assert(err, NotNil)
 }
 
 /****************************************************************
+  getHosts() tests
+****************************************************************/
+
+func (cs *clientSessionSuite) TestGetHostsFallback(c *C) {
+	fallback := []string{"foo:443", "bar:443"}
+	sess := &ClientSession{fallbackHosts: fallback}
+	err := sess.getHosts()
+	c.Assert(err, IsNil)
+	c.Check(sess.deliveryHosts, DeepEquals, fallback)
+}
+
+type testHostGetter struct {
+	hosts []string
+	err   error
+}
+
+func (thg *testHostGetter) Get() ([]string, error) {
+	return thg.hosts, thg.err
+}
+
+func (cs *clientSessionSuite) TestGetHostsRemote(c *C) {
+	hostGetter := &testHostGetter{[]string{"foo:443", "bar:443"}, nil}
+	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)
+	c.Assert(err, IsNil)
+	hostsErr := errors.New("failed")
+	hostGetter := &testHostGetter{nil, hostsErr}
+	sess.getHost = hostGetter
+	err = sess.getHosts()
+	c.Assert(err, Equals, hostsErr)
+	c.Check(sess.deliveryHosts, IsNil)
+	c.Check(sess.State(), Equals, Error)
+}
+
+func (cs *clientSessionSuite) TestGetHostsRemoteCaching(c *C) {
+	hostGetter := &testHostGetter{[]string{"foo:443", "bar:443"}, nil}
+	sess := &ClientSession{
+		getHost: hostGetter,
+		ClientSessionConfig: ClientSessionConfig{
+			HostsCachingExpiryTime: 2 * time.Hour,
+		},
+		timeSince: time.Since,
+	}
+	err := sess.getHosts()
+	c.Assert(err, IsNil)
+	hostGetter.hosts = []string{"baz:443"}
+	// cached
+	err = sess.getHosts()
+	c.Assert(err, IsNil)
+	c.Check(sess.deliveryHosts, DeepEquals, []string{"foo:443", "bar:443"})
+	// expired
+	sess.timeSince = func(ts time.Time) time.Duration {
+		return 3 * time.Hour
+	}
+	err = sess.getHosts()
+	c.Assert(err, IsNil)
+	c.Check(sess.deliveryHosts, DeepEquals, []string{"baz:443"})
+}
+
+/****************************************************************
+  startConnectionAttempt()/nextHostToTry()/started tests
+****************************************************************/
+
+func (cs *clientSessionSuite) TestStartConnectionAttempt(c *C) {
+	since := time.Since(time.Time{})
+	sess := &ClientSession{
+		ClientSessionConfig: ClientSessionConfig{
+			ExpectAllRepairedTime: 10 * time.Second,
+		},
+		timeSince: func(ts time.Time) time.Duration {
+			return since
+		},
+		deliveryHosts: []string{"foo:443", "bar:443"},
+	}
+	// start from first host
+	sess.startConnectionAttempt()
+	c.Check(sess.lastAttemptTimestamp, Not(Equals), 0)
+	c.Check(sess.tryHost, Equals, 0)
+	c.Check(sess.leftToTry, Equals, 2)
+	since = 1 * time.Second
+	sess.tryHost = 1
+	// just continue
+	sess.startConnectionAttempt()
+	c.Check(sess.tryHost, Equals, 1)
+	sess.tryHost = 2
+}
+
+func (cs *clientSessionSuite) TestStartConnectionAttemptNoHostsPanic(c *C) {
+	since := time.Since(time.Time{})
+	sess := &ClientSession{
+		ClientSessionConfig: ClientSessionConfig{
+			ExpectAllRepairedTime: 10 * time.Second,
+		},
+		timeSince: func(ts time.Time) time.Duration {
+			return since
+		},
+	}
+	c.Check(sess.startConnectionAttempt, PanicMatches, "should have got hosts from config or remote at this point")
+}
+
+func (cs *clientSessionSuite) TestNextHostToTry(c *C) {
+	sess := &ClientSession{
+		deliveryHosts: []string{"foo:443", "bar:443", "baz:443"},
+		tryHost:       0,
+		leftToTry:     3,
+	}
+	c.Check(sess.nextHostToTry(), Equals, "foo:443")
+	c.Check(sess.nextHostToTry(), Equals, "bar:443")
+	c.Check(sess.nextHostToTry(), Equals, "baz:443")
+	c.Check(sess.nextHostToTry(), Equals, "")
+	c.Check(sess.nextHostToTry(), Equals, "")
+	c.Check(sess.tryHost, Equals, 0)
+
+	sess.leftToTry = 3
+	sess.tryHost = 1
+	c.Check(sess.nextHostToTry(), Equals, "bar:443")
+	c.Check(sess.nextHostToTry(), Equals, "baz:443")
+	c.Check(sess.nextHostToTry(), Equals, "foo:443")
+	c.Check(sess.nextHostToTry(), Equals, "")
+	c.Check(sess.nextHostToTry(), Equals, "")
+	c.Check(sess.tryHost, Equals, 1)
+}
+
+func (cs *clientSessionSuite) TestStarted(c *C) {
+	sess, err := NewSession("", dummyConf, "", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+
+	sess.deliveryHosts = []string{"foo:443", "bar:443", "baz:443"}
+	sess.tryHost = 1
+
+	sess.started()
+	c.Check(sess.tryHost, Equals, 0)
+	c.Check(sess.State(), Equals, Started)
+
+	sess.started()
+	c.Check(sess.tryHost, Equals, 2)
+}
+
+/****************************************************************
   connect() tests
 ****************************************************************/
 
 func (cs *clientSessionSuite) TestConnectFailsWithNoAddress(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
+	sess.deliveryHosts = []string{"nowhere"}
 	err = sess.connect()
 	c.Check(err, ErrorMatches, ".*connect.*address.*")
 	c.Check(sess.State(), Equals, Error)
@@ -233,20 +413,36 @@
 	srv, err := net.Listen("tcp", "localhost:0")
 	c.Assert(err, IsNil)
 	defer srv.Close()
-	sess, err := NewSession(srv.Addr().String(), nil, 0, "wah", cs.lvls, cs.log)
-	c.Assert(err, IsNil)
-	err = sess.connect()
-	c.Check(err, IsNil)
-	c.Check(sess.Connection, NotNil)
-	c.Check(sess.State(), Equals, Connected)
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	sess.deliveryHosts = []string{srv.Addr().String()}
+	err = sess.connect()
+	c.Check(err, IsNil)
+	c.Check(sess.Connection, NotNil)
+	c.Check(sess.State(), Equals, Connected)
+}
+
+func (cs *clientSessionSuite) TestConnectSecondConnects(c *C) {
+	srv, err := net.Listen("tcp", "localhost:0")
+	c.Assert(err, IsNil)
+	defer srv.Close()
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	sess.deliveryHosts = []string{"nowhere", srv.Addr().String()}
+	err = sess.connect()
+	c.Check(err, IsNil)
+	c.Check(sess.Connection, NotNil)
+	c.Check(sess.State(), Equals, Connected)
+	c.Check(sess.tryHost, Equals, 0)
 }
 
 func (cs *clientSessionSuite) TestConnectConnectFail(c *C) {
 	srv, err := net.Listen("tcp", "localhost:0")
 	c.Assert(err, IsNil)
-	sess, err := NewSession(srv.Addr().String(), nil, 0, "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()}
 	err = sess.connect()
 	c.Check(err, ErrorMatches, ".*connection refused")
 	c.Check(sess.State(), Equals, Error)
@@ -257,7 +453,7 @@
 ****************************************************************/
 
 func (cs *clientSessionSuite) TestClose(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestClose"}
 	sess.Close()
@@ -266,7 +462,7 @@
 }
 
 func (cs *clientSessionSuite) TestCloseTwice(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestCloseTwice"}
 	sess.Close()
@@ -277,7 +473,7 @@
 }
 
 func (cs *clientSessionSuite) TestCloseFails(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestCloseFails", CloseCondition: condition.Work(false)}
 	sess.Close()
@@ -291,7 +487,7 @@
 func (d *derp) Stop()        { d.stopped = true }
 
 func (cs *clientSessionSuite) TestCloseStopsRetrier(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	ar := new(derp)
 	sess.retrier = ar
@@ -308,7 +504,7 @@
 
 func (cs *clientSessionSuite) TestAutoRedialWorks(c *C) {
 	// checks that AutoRedial sets up a retrier and tries redialing it
-	sess, err := NewSession("", nil, 0, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	ar := new(derp)
 	sess.retrier = ar
@@ -319,7 +515,7 @@
 
 func (cs *clientSessionSuite) TestAutoRedialStopsRetrier(c *C) {
 	// checks that AutoRedial stops the previous retrier
-	sess, err := NewSession("", nil, 0, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	ch := make(chan uint32)
 	c.Check(sess.retrier, IsNil)
@@ -344,7 +540,10 @@
 
 func (s *msgSuite) SetUpTest(c *C) {
 	var err error
-	s.sess, err = NewSession("", nil, time.Millisecond, "wah", levelmap.NewLevelMap, helpers.NewTestLogger(c, "debug"))
+	conf := ClientSessionConfig{
+		ExchangeTimeout: time.Millisecond,
+	}
+	s.sess, err = NewSession("", conf, "wah", levelmap.NewLevelMap, helpers.NewTestLogger(c, "debug"))
 	c.Assert(err, IsNil)
 	s.sess.Connection = &testConn{Name: "TestHandle*"}
 	s.errCh = make(chan error, 1)
@@ -383,14 +582,28 @@
 			AppId:    "--ignored--",
 			ChanId:   "0",
 			TopLevel: 2,
-			Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
+			Payloads: []json.RawMessage{
+				json.RawMessage(`{"img1/m1":[101,"tubular"]}`),
+				json.RawMessage("false"), // shouldn't happen but robust
+				json.RawMessage(`{"img1/m1":[102,"tubular"]}`),
+			},
 		}, protocol.NotificationsMsg{}}
 	go func() { s.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.Assert(len(s.sess.MsgCh), Equals, 1)
-	c.Check(<-s.sess.MsgCh, DeepEquals, &Notification{TopLevel: 2})
+	c.Check(<-s.sess.MsgCh, DeepEquals, &Notification{
+		TopLevel: 2,
+		Decoded: []map[string]interface{}{
+			map[string]interface{}{
+				"img1/m1": []interface{}{float64(101), "tubular"},
+			},
+			map[string]interface{}{
+				"img1/m1": []interface{}{float64(102), "tubular"},
+			},
+		},
+	})
 	// and finally, the session keeps track of the levels
 	levels, err := s.sess.Levels.GetAll()
 	c.Check(err, IsNil)
@@ -519,7 +732,7 @@
   start() tests
 ****************************************************************/
 func (cs *clientSessionSuite) TestStartFailsIfSetDeadlineFails(c *C) {
-	sess, err := NewSession("", nil, 0, "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
@@ -529,7 +742,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartFailsIfWriteFails(c *C) {
-	sess, err := NewSession("", nil, 0, "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
@@ -539,7 +752,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartFailsIfGetLevelsFails(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", cs.lvls, cs.log)
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Levels = &brokenLevelMap{}
 	sess.Connection = &testConn{Name: "TestStartConnectMessageFails"}
@@ -559,7 +772,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartConnectMessageFails(c *C) {
-	sess, err := NewSession("", nil, 0, "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)
@@ -585,7 +798,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartConnackReadError(c *C) {
-	sess, err := NewSession("", nil, 0, "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)
@@ -609,7 +822,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartBadConnack(c *C) {
-	sess, err := NewSession("", nil, 0, "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)
@@ -633,7 +846,7 @@
 }
 
 func (cs *clientSessionSuite) TestStartNotConnack(c *C) {
-	sess, err := NewSession("", nil, 0, "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)
@@ -657,7 +870,14 @@
 }
 
 func (cs *clientSessionSuite) TestStartWorks(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", cs.lvls, cs.log)
+	info := map[string]interface{}{
+		"foo": 1,
+		"bar": "baz",
+	}
+	conf := ClientSessionConfig{
+		Info: info,
+	}
+	sess, err := NewSession("", conf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartWorks"}
 	errCh := make(chan error, 1)
@@ -671,8 +891,10 @@
 	}()
 
 	c.Check(takeNext(downCh), Equals, "deadline 0")
-	_, ok := takeNext(downCh).(protocol.ConnectMsg)
+	msg, ok := takeNext(downCh).(protocol.ConnectMsg)
 	c.Check(ok, Equals, true)
+	c.Check(msg.DeviceId, Equals, "wah")
+	c.Check(msg.Info, DeepEquals, info)
 	upCh <- nil // no error
 	upCh <- protocol.ConnAckMsg{
 		Type:   "connack",
@@ -688,34 +910,49 @@
   run() tests
 ****************************************************************/
 
-func (cs *clientSessionSuite) TestRunBailsIfConnectFails(c *C) {
-	sess, err := NewSession("", nil, 0, "wah", cs.lvls, cs.log)
+func (cs *clientSessionSuite) TestRunBailsIfHostGetterFails(c *C) {
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
-	failure := errors.New("TestRunBailsIfConnectFails")
+	failure := errors.New("TestRunBailsIfHostGetterFails")
 	has_closed := false
 	err = sess.run(
 		func() { has_closed = true },
 		func() error { return failure },
 		nil,
+		nil,
 		nil)
 	c.Check(err, Equals, failure)
 	c.Check(has_closed, Equals, true)
 }
 
+func (cs *clientSessionSuite) TestRunBailsIfConnectFails(c *C) {
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	failure := errors.New("TestRunBailsIfConnectFails")
+	err = sess.run(
+		func() {},
+		func() error { return nil },
+		func() error { return failure },
+		nil,
+		nil)
+	c.Check(err, Equals, failure)
+}
+
 func (cs *clientSessionSuite) TestRunBailsIfStartFails(c *C) {
-	sess, err := NewSession("", nil, 0, "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() error { return nil },
+		func() error { return nil },
 		func() error { return failure },
 		nil)
 	c.Check(err, Equals, failure)
 }
 
 func (cs *clientSessionSuite) TestRunRunsEvenIfLoopFails(c *C) {
-	sess, err := NewSession("", nil, 0, "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 & MsgCh (no
 	// biggie if this stops being true)
@@ -727,6 +964,7 @@
 		func() {},
 		func() error { return nil },
 		func() error { return nil },
+		func() error { return nil },
 		func() error { sess.MsgCh <- notf; return <-failureCh })
 	c.Check(err, Equals, nil)
 	// if run doesn't error it sets up the channels
@@ -744,7 +982,7 @@
 ****************************************************************/
 
 func (cs *clientSessionSuite) TestJitter(c *C) {
-	sess, err := NewSession("", nil, 0, "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 //
@@ -776,12 +1014,17 @@
 
 func (cs *clientSessionSuite) TestDialPanics(c *C) {
 	// one last unhappy test
-	sess, err := NewSession("", nil, 0, "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}
+)
+
 func (cs *clientSessionSuite) TestDialWorks(c *C) {
 	// happy path thoughts
 	cert, err := tls.X509KeyPair(helpers.TestCertPEMBlock, helpers.TestKeyPEMBlock)
@@ -791,10 +1034,22 @@
 		SessionTicketsDisabled: true,
 	}
 
-	timeout := 100 * time.Millisecond
 	lst, err := tls.Listen("tcp", "localhost:0", tlsCfg)
 	c.Assert(err, IsNil)
-	sess, err := NewSession(lst.Addr().String(), nil, timeout, "wah", cs.lvls, cs.log)
+	// advertise
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		b, err := json.Marshal(map[string]interface{}{
+			"hosts": []string{"nowhere", lst.Addr().String()},
+		})
+		if err != nil {
+			panic(err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(b)
+	}))
+	defer ts.Close()
+
+	sess, err := NewSession(ts.URL, dialTestConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	tconn := &testConn{CloseCondition: condition.Fail2Work(10)}
 	sess.Connection = tconn
@@ -819,10 +1074,13 @@
 	c.Check(tconn.CloseCondition.String(), Matches, ".* 9 to go.")
 
 	// now, start: 1. protocol version
-	v, err := protocol.ReadWireFormatVersion(srv, timeout)
+	v, err := protocol.ReadWireFormatVersion(srv, dialTestTimeout)
 	c.Assert(err, IsNil)
 	c.Assert(v, Equals, protocol.ProtocolWireVersion)
 
+	// if something goes wrong session would try the first/other host
+	c.Check(sess.tryHost, Equals, 0)
+
 	// 2. "connect" (but on the fake protcol above! woo)
 
 	c.Check(takeNext(downCh), Equals, "deadline 100ms")
@@ -843,6 +1101,9 @@
 	c.Check(takeNext(downCh), Equals, protocol.PingPongMsg{Type: "pong"})
 	upCh <- nil
 
+	// session would retry the same host
+	c.Check(sess.tryHost, Equals, 1)
+
 	// and broadcasts...
 	b := &protocol.BroadcastMsg{
 		Type:     "broadcast",
@@ -870,3 +1131,30 @@
 	upCh <- failure
 	c.Check(<-sess.ErrCh, Equals, failure)
 }
+
+func (cs *clientSessionSuite) TestDialWorksDirect(c *C) {
+	// happy path thoughts
+	cert, err := tls.X509KeyPair(helpers.TestCertPEMBlock, helpers.TestKeyPEMBlock)
+	c.Assert(err, IsNil)
+	tlsCfg := &tls.Config{
+		Certificates:           []tls.Certificate{cert},
+		SessionTicketsDisabled: true,
+	}
+
+	lst, err := tls.Listen("tcp", "localhost:0", tlsCfg)
+	c.Assert(err, IsNil)
+	sess, err := NewSession(lst.Addr().String(), dialTestConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	defer sess.Close()
+
+	upCh := make(chan interface{}, 5)
+	downCh := make(chan interface{}, 5)
+	proto := &testProtocol{up: upCh, down: downCh}
+	sess.Protocolator = func(net.Conn) protocol.Protocol { return proto }
+
+	go sess.Dial()
+
+	_, err = lst.Accept()
+	c.Assert(err, IsNil)
+	// connect done
+}

=== modified file 'debian/config.json'
--- debian/config.json	2014-03-20 12:17:40 +0000
+++ debian/config.json	2014-04-04 14:39:41 +0000
@@ -1,6 +1,9 @@
 {
+    "connect_timeout": "20s",
     "exchange_timeout": "30s",
-    "addr": "push-delivery.ubuntu.com:443",
+    "hosts_cache_expiry": "12h",
+    "expect_all_repaired": "40m",
+    "addr": "https://push.ubuntu.com/delivery-hosts",
     "cert_pem_file": "",
     "stabilizing_timeout": "2s",
     "recheck_timeout": "10m",

=== modified file 'debian/ubuntu-push-client.conf'
--- debian/ubuntu-push-client.conf	2014-02-07 11:31:54 +0000
+++ debian/ubuntu-push-client.conf	2014-04-04 14:39:41 +0000
@@ -1,6 +1,6 @@
-description		"Starts the ubuntu push notifications client side daemon"
+description "ubuntu push notification client-side daemon"
 
-start on dbus
-stop on runlevel [06]
+start on started dbus
+stop on stopped dbus
 
 exec /usr/lib/ubuntu-push-client/ubuntu-push-client

=== added directory 'sampleconfigs'
=== renamed file 'server/acceptance/config/config.json' => 'sampleconfigs/dev.json'
--- server/acceptance/config/config.json	2014-01-17 17:20:34 +0000
+++ sampleconfigs/dev.json	2014-04-04 14:39:41 +0000
@@ -4,9 +4,9 @@
     "broker_queue_size": 10000,
     "session_queue_size": 10,
     "addr": "127.0.0.1:9090",
-    "key_pem_file": "testing.key",
-    "cert_pem_file": "testing.cert",
-    "http_addr": "127.0.0.1:8888",
+    "key_pem_file": "../server/acceptance/ssl/testing.key",
+    "cert_pem_file": "../server/acceptance/ssl/testing.cert",
+    "http_addr": "127.0.0.1:8080",
     "http_read_timeout": "5s",
     "http_write_timeout": "5s"
 }

=== modified file 'server/acceptance/acceptanceclient.go'
--- server/acceptance/acceptanceclient.go	2014-02-21 16:17:28 +0000
+++ server/acceptance/acceptanceclient.go	2014-04-04 14:39:41 +0000
@@ -35,6 +35,8 @@
 type ClientSession struct {
 	// configuration
 	DeviceId        string
+	Model           string
+	ImageChannel    string
 	ServerAddr      string
 	ExchangeTimeout time.Duration
 	CertPEMBlock    []byte
@@ -86,6 +88,10 @@
 		Type:     "connect",
 		DeviceId: sess.DeviceId,
 		Levels:   sess.Levels,
+		Info: map[string]interface{}{
+			"device":  sess.Model,
+			"channel": sess.ImageChannel,
+		},
 	})
 	if err != nil {
 		return err

=== modified file 'server/acceptance/cmd/acceptanceclient.go'
--- server/acceptance/cmd/acceptanceclient.go	2014-02-21 16:17:28 +0000
+++ server/acceptance/cmd/acceptanceclient.go	2014-04-04 14:39:41 +0000
@@ -30,6 +30,8 @@
 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 {
@@ -64,9 +66,12 @@
 		ServerAddr:      cfg.Addr.HostPort(),
 		DeviceId:        flag.Arg(1),
 		// flags
-		ReportPings: *reportPingsFlag,
-		Insecure:    *insecureFlag,
+		Model:        *deviceModel,
+		ImageChannel: *imageChannel,
+		ReportPings:  *reportPingsFlag,
+		Insecure:     *insecureFlag,
 	}
+	log.Printf("with: %#v", session)
 	session.CertPEMBlock, err = config.LoadFile(cfg.CertPEMFile, filepath.Dir(configFName))
 	if err != nil {
 		log.Fatalf("reading CertPEMFile: %v", err)

=== renamed directory 'server/acceptance/config' => 'server/acceptance/ssl'
=== modified file 'server/acceptance/suites/broadcast.go'
--- server/acceptance/suites/broadcast.go	2014-02-21 21:39:54 +0000
+++ server/acceptance/suites/broadcast.go	2014-04-04 14:39:41 +0000
@@ -41,11 +41,34 @@
 	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
-		Data:     json.RawMessage(`{"n": 42}`),
-	})
-	c.Assert(err, IsNil)
-	c.Assert(got, Matches, ".*ok.*")
-	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`)
+		Data:     json.RawMessage(`{"img1/m1": 42}`),
+	})
+	c.Assert(err, IsNil)
+	c.Assert(got, Matches, ".*ok.*")
+	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`)
+	c.Check(len(errCh), Equals, 0)
+}
+
+func (s *BroadcastAcceptanceSuite) TestBroadcastToConnectedChannelFilter(c *C) {
+	events, errCh, stop := s.StartClient(c, "DEVB", nil)
+	got, err := s.PostRequest("/broadcast", &api.Broadcast{
+		Channel:  "system",
+		ExpireOn: future,
+		Data:     json.RawMessage(`{"img1/m2": 10}`),
+	})
+	c.Assert(err, IsNil)
+	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.*")
+	// xxx don't send this one
+	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[]`)
+	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`)
 	c.Check(len(errCh), Equals, 0)
@@ -56,14 +79,14 @@
 	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
-		Data:     json.RawMessage(`{"b": 1}`),
+		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 
 	events, errCh, stop := s.StartClient(c, "DEVB", nil)
 	// gettting pending on connect
-	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"b":1}]`)
+	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`)
 	c.Check(len(errCh), Equals, 0)
@@ -71,7 +94,7 @@
 
 func (s *BroadcastAcceptanceSuite) TestBroadcasLargeNeedsSplitting(c *C) {
 	// send bunch of broadcasts that will be pending
-	payloadFmt := fmt.Sprintf(`{"b":%%d,"bloat":"%s"}`, strings.Repeat("x", 1024*2))
+	payloadFmt := fmt.Sprintf(`{"img1/m1":%%d,"bloat":"%s"}`, strings.Repeat("x", 1024*2))
 	for i := 0; i < 32; i++ {
 		got, err := s.PostRequest("/broadcast", &api.Broadcast{
 			Channel:  "system",
@@ -84,7 +107,7 @@
 
 	events, errCh, stop := s.StartClient(c, "DEVC", nil)
 	// gettting pending on connect
-	c.Check(NextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:30 payloads:\[{"b":0,.*`)
+	c.Check(NextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:30 payloads:\[{"img1/m1":0,.*`)
 	c.Check(NextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:32 payloads:\[.*`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
@@ -100,12 +123,12 @@
 	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
-		Data:     json.RawMessage(`{"n": 42}`),
+		Data:     json.RawMessage(`{"img1/m1": 42}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
-	c.Check(NextEvent(events1, errCh1), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`)
-	c.Check(NextEvent(events2, errCh2), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`)
+	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()
 	stop2()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
@@ -119,11 +142,11 @@
 	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
-		Data:     json.RawMessage(`{"b": 1}`),
+		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
-	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"b":1}]`)
+	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`)
 	c.Check(len(errCh), Equals, 0)
@@ -131,7 +154,7 @@
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
-		Data:     json.RawMessage(`{"b": 2}`),
+		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
@@ -139,7 +162,7 @@
 	events, errCh, stop = s.StartClient(c, "DEVD", map[string]int64{
 		protocol.SystemChannelId: 1,
 	})
-	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":2}]`)
+	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"img1/m1":2}]`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
@@ -150,14 +173,14 @@
 	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
-		Data:     json.RawMessage(`{"b": 1}`),
+		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
-		Data:     json.RawMessage(`{"b": 2}`),
+		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
@@ -166,7 +189,7 @@
 		protocol.SystemChannelId: 10,
 	})
 	// gettting last one pending on connect
-	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":2}]`)
+	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"img1/m1":2}]`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
@@ -189,14 +212,14 @@
 	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
-		Data:     json.RawMessage(`{"b": 1}`),
+		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
-		Data:     json.RawMessage(`{"b": 2}`),
+		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
@@ -205,7 +228,7 @@
 		protocol.SystemChannelId: -10,
 	})
 	// gettting pending on connect
-	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":1},{"b":2}]`)
+	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"img1/m1":1},{"img1/m1":2}]`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
@@ -216,14 +239,14 @@
 	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
-		Data:     json.RawMessage(`{"b": 1}`),
+		Data:     json.RawMessage(`{"img1/m1": 1}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: time.Now().Add(1 * time.Second).Format(time.RFC3339),
-		Data:     json.RawMessage(`{"b": 2}`),
+		Data:     json.RawMessage(`{"img1/m1": 2}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
@@ -233,7 +256,7 @@
 
 	events, errCh, stop := s.StartClient(c, "DEVB", nil)
 	// gettting pending on connect
-	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":1}]`)
+	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"img1/m1":1}]`)
 	stop()
 	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)

=== modified file 'server/acceptance/suites/helpers.go'
--- server/acceptance/suites/helpers.go	2014-03-25 19:08:00 +0000
+++ server/acceptance/suites/helpers.go	2014-04-04 14:39:41 +0000
@@ -48,8 +48,8 @@
 		"session_queue_size": 10,
 		"broker_queue_size":  100,
 		"addr":               addr,
-		"key_pem_file":       helpers.SourceRelative("../config/testing.key"),
-		"cert_pem_file":      helpers.SourceRelative("../config/testing.cert"),
+		"key_pem_file":       helpers.SourceRelative("../ssl/testing.key"),
+		"cert_pem_file":      helpers.SourceRelative("../ssl/testing.cert"),
 	})
 }
 

=== modified file 'server/acceptance/suites/pingpong.go'
--- server/acceptance/suites/pingpong.go	2014-02-21 20:29:16 +0000
+++ server/acceptance/suites/pingpong.go	2014-04-04 14:39:41 +0000
@@ -34,7 +34,7 @@
 func (s *PingPongAcceptanceSuite) TestConnectPingPing(c *C) {
 	errCh := make(chan error, 1)
 	events := make(chan string, 10)
-	sess := testClientSession(s.ServerAddr, "DEVA", true)
+	sess := testClientSession(s.ServerAddr, "DEVA", "m1", "img1", true)
 	err := sess.Dial()
 	c.Assert(err, IsNil)
 	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
@@ -68,7 +68,7 @@
 func (s *PingPongAcceptanceSuite) TestConnectPingNeverPong(c *C) {
 	errCh := make(chan error, 1)
 	events := make(chan string, 10)
-	sess := testClientSession(s.ServerAddr, "DEVB", true)
+	sess := testClientSession(s.ServerAddr, "DEVB", "m1", "img1", true)
 	err := sess.Dial()
 	c.Assert(err, IsNil)
 	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {

=== modified file 'server/acceptance/suites/suite.go'
--- server/acceptance/suites/suite.go	2014-03-25 19:08:00 +0000
+++ server/acceptance/suites/suite.go	2014-04-04 14:39:41 +0000
@@ -46,7 +46,7 @@
 func (h *ServerHandle) StartClient(c *C, devId string, levels map[string]int64) (events <-chan string, errorCh <-chan error, stop func()) {
 	errCh := make(chan error, 1)
 	cliEvents := make(chan string, 10)
-	sess := testClientSession(h.ServerAddr, devId, false)
+	sess := testClientSession(h.ServerAddr, devId, "m1", "img1", false)
 	sess.Levels = levels
 	err := sess.Dial()
 	c.Assert(err, IsNil)
@@ -127,16 +127,18 @@
 	return string(body), err
 }
 
-func testClientSession(addr string, deviceId string, reportPings bool) *acceptance.ClientSession {
-	certPEMBlock, err := ioutil.ReadFile(helpers.SourceRelative("../config/testing.cert"))
+func testClientSession(addr string, deviceId, model, imageChannel string, reportPings bool) *acceptance.ClientSession {
+	certPEMBlock, err := ioutil.ReadFile(helpers.SourceRelative("../ssl/testing.cert"))
 	if err != nil {
-		panic(fmt.Sprintf("could not read config/testing.cert: %v", err))
+		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,
 	}
 }

=== modified file 'server/broker/broker.go'
--- server/broker/broker.go	2014-02-21 16:04:44 +0000
+++ server/broker/broker.go	2014-04-04 14:39:41 +0000
@@ -49,6 +49,19 @@
 // LevelsMap is the type for holding channel levels for session.
 type LevelsMap map[store.InternalChannelId]int64
 
+// GetInfoString helps retrivieng a string out of a protocol.ConnectMsg.Info
+func GetInfoString(msg *protocol.ConnectMsg, name, defaultVal string) (string, error) {
+	v, ok := msg.Info[name]
+	if !ok {
+		return defaultVal, nil
+	}
+	s, ok := v.(string)
+	if !ok {
+		return "", ErrUnexpectedValue
+	}
+	return s, nil
+}
+
 // BrokerSession holds broker session state.
 type BrokerSession interface {
 	// SessionChannel returns the session control channel
@@ -56,6 +69,10 @@
 	SessionChannel() <-chan Exchange
 	// DeviceIdentifier returns the device id string.
 	DeviceIdentifier() string
+	// DeviceImageModel returns the device model.
+	DeviceImageModel() string
+	// DeviceImageChannel returns the device system image channel.
+	DeviceImageChannel() string
 	// Levels returns the current channel levels for the session
 	Levels() LevelsMap
 	// ExchangeScratchArea returns the scratch area for exchanges.
@@ -71,6 +88,9 @@
 	return fmt.Sprintf("session aborted (%s)", ea.Reason)
 }
 
+// Unexpect value in message
+var ErrUnexpectedValue = &ErrAbort{"unexpected value in message"}
+
 // BrokerConfig gives access to the typical broker configuration.
 type BrokerConfig interface {
 	// SessionQueueSize gives the session queue size.

=== modified file 'server/broker/broker_test.go'
--- server/broker/broker_test.go	2014-02-10 23:19:08 +0000
+++ server/broker/broker_test.go	2014-04-04 14:39:41 +0000
@@ -20,6 +20,8 @@
 	"fmt"
 
 	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/protocol"
 )
 
 type brokerSuite struct{}
@@ -30,3 +32,19 @@
 	err := &ErrAbort{"expected FOO"}
 	c.Check(fmt.Sprintf("%s", err), Equals, "session aborted (expected FOO)")
 }
+
+func (s *brokerSuite) TestGetInfoString(c *C) {
+	connectMsg := &protocol.ConnectMsg{}
+	v, err := GetInfoString(connectMsg, "foo", "?")
+	c.Check(err, IsNil)
+	c.Check(v, Equals, "?")
+
+	connectMsg.Info = map[string]interface{}{"foo": "yay"}
+	v, err = GetInfoString(connectMsg, "foo", "?")
+	c.Check(err, IsNil)
+	c.Check(v, Equals, "yay")
+
+	connectMsg.Info["foo"] = 33
+	v, err = GetInfoString(connectMsg, "foo", "?")
+	c.Check(err, Equals, ErrUnexpectedValue)
+}

=== modified file 'server/broker/exchanges.go'
--- server/broker/exchanges.go	2014-02-26 16:04:57 +0000
+++ server/broker/exchanges.go	2014-04-04 14:39:41 +0000
@@ -18,6 +18,7 @@
 
 import (
 	"encoding/json"
+	"fmt"
 
 	"launchpad.net/ubuntu-push/protocol"
 	"launchpad.net/ubuntu-push/server/store"
@@ -37,11 +38,24 @@
 	ChanId               store.InternalChannelId
 	TopLevel             int64
 	NotificationPayloads []json.RawMessage
+	Decoded              []map[string]interface{}
 }
 
 // check interface already here
 var _ Exchange = &BroadcastExchange{}
 
+// Init ensures the BroadcastExchange is fully initialized for the sessions.
+func (sbe *BroadcastExchange) Init() {
+	decoded := make([]map[string]interface{}, len(sbe.NotificationPayloads))
+	sbe.Decoded = decoded
+	for i, p := range sbe.NotificationPayloads {
+		err := json.Unmarshal(p, &decoded[i])
+		if err != nil {
+			decoded[i] = nil
+		}
+	}
+}
+
 func filterByLevel(clientLevel, topLevel int64, payloads []json.RawMessage) []json.RawMessage {
 	c := int64(len(payloads))
 	if c == 0 {
@@ -58,6 +72,20 @@
 	}
 }
 
+func channelFilter(tag string, chanId store.InternalChannelId, payloads []json.RawMessage, decoded []map[string]interface{}) []json.RawMessage {
+	if len(payloads) != 0 && chanId == store.SystemInternalChannelId {
+		decoded := decoded[len(decoded)-len(payloads):]
+		filtered := make([]json.RawMessage, 0)
+		for i, decoded1 := range decoded {
+			if _, ok := decoded1[tag]; ok {
+				filtered = append(filtered, payloads[i])
+			}
+		}
+		payloads = filtered
+	}
+	return payloads
+}
+
 // Prepare session for a BROADCAST.
 func (sbe *BroadcastExchange) Prepare(sess BrokerSession) (outMessage protocol.SplittableMsg, inMessage interface{}, err error) {
 	scratchArea := sess.ExchangeScratchArea()
@@ -65,6 +93,9 @@
 	scratchArea.broadcastMsg.Type = "broadcast"
 	clientLevel := sess.Levels()[sbe.ChanId]
 	payloads := filterByLevel(clientLevel, sbe.TopLevel, sbe.NotificationPayloads)
+	tag := fmt.Sprintf("%s/%s", sess.DeviceImageChannel(), sess.DeviceImageModel())
+	payloads = channelFilter(tag, sbe.ChanId, payloads, sbe.Decoded)
+
 	// xxx need an AppId as well, later
 	scratchArea.broadcastMsg.ChanId = store.InternalChannelIdToHex(sbe.ChanId)
 	scratchArea.broadcastMsg.TopLevel = sbe.TopLevel

=== modified file 'server/broker/exchanges_test.go'
--- server/broker/exchanges_test.go	2014-02-26 16:04:57 +0000
+++ server/broker/exchanges_test.go	2014-04-04 14:39:41 +0000
@@ -35,24 +35,45 @@
 
 var _ = Suite(&exchangesSuite{})
 
+func (s *exchangesSuite) TestBroadcastExchangeInit(c *C) {
+	exchg := &broker.BroadcastExchange{
+		ChanId:   store.SystemInternalChannelId,
+		TopLevel: 3,
+		NotificationPayloads: []json.RawMessage{
+			json.RawMessage(`{"a":"x"}`),
+			json.RawMessage(`[]`),
+			json.RawMessage(`{"a":"y"}`),
+		},
+	}
+	exchg.Init()
+	c.Check(exchg.Decoded, DeepEquals, []map[string]interface{}{
+		map[string]interface{}{"a": "x"},
+		nil,
+		map[string]interface{}{"a": "y"},
+	})
+}
+
 func (s *exchangesSuite) TestBroadcastExchange(c *C) {
 	sess := &testing.TestBrokerSession{
-		LevelsMap: broker.LevelsMap(map[store.InternalChannelId]int64{}),
+		LevelsMap:    broker.LevelsMap(map[store.InternalChannelId]int64{}),
+		Model:        "m1",
+		ImageChannel: "img1",
 	}
 	exchg := &broker.BroadcastExchange{
 		ChanId:   store.SystemInternalChannelId,
 		TopLevel: 3,
 		NotificationPayloads: []json.RawMessage{
-			json.RawMessage(`{"a":"x"}`),
-			json.RawMessage(`{"a":"y"}`),
+			json.RawMessage(`{"img1/m1":100}`),
+			json.RawMessage(`{"img2/m2":200}`),
 		},
 	}
+	exchg.Init()
 	outMsg, inMsg, err := exchg.Prepare(sess)
 	c.Assert(err, IsNil)
 	// check
 	marshalled, err := json.Marshal(outMsg)
 	c.Assert(err, IsNil)
-	c.Check(string(marshalled), Equals, `{"T":"broadcast","ChanId":"0","TopLevel":3,"Payloads":[{"a":"x"},{"a":"y"}]}`)
+	c.Check(string(marshalled), Equals, `{"T":"broadcast","ChanId":"0","TopLevel":3,"Payloads":[{"img1/m1":100}]}`)
 	err = json.Unmarshal([]byte(`{"T":"ack"}`), inMsg)
 	c.Assert(err, IsNil)
 	err = exchg.Acked(sess, true)
@@ -62,9 +83,11 @@
 
 func (s *exchangesSuite) TestBroadcastExchangeReuseVsSplit(c *C) {
 	sess := &testing.TestBrokerSession{
-		LevelsMap: broker.LevelsMap(map[store.InternalChannelId]int64{}),
+		LevelsMap:    broker.LevelsMap(map[store.InternalChannelId]int64{}),
+		Model:        "m1",
+		ImageChannel: "img1",
 	}
-	payloadFmt := fmt.Sprintf(`{"b":%%d,"bloat":"%s"}`, strings.Repeat("x", 1024*2))
+	payloadFmt := fmt.Sprintf(`{"img1/m1":%%d,"bloat":"%s"}`, strings.Repeat("x", 1024*2))
 	needsSplitting := make([]json.RawMessage, 32)
 	for i := 0; i < 32; i++ {
 		needsSplitting[i] = json.RawMessage(fmt.Sprintf(payloadFmt, i))
@@ -76,6 +99,7 @@
 		TopLevel:             topLevel,
 		NotificationPayloads: needsSplitting,
 	}
+	exchg.Init()
 	outMsg, _, err := exchg.Prepare(sess)
 	c.Assert(err, IsNil)
 	parts := 0
@@ -91,10 +115,11 @@
 		ChanId:   store.SystemInternalChannelId,
 		TopLevel: topLevel + 2,
 		NotificationPayloads: []json.RawMessage{
-			json.RawMessage(`{"a":"x"}`),
-			json.RawMessage(`{"a":"y"}`),
+			json.RawMessage(`{"img1/m1":"x"}`),
+			json.RawMessage(`{"img1/m1":"y"}`),
 		},
 	}
+	exchg.Init()
 	outMsg, _, err = exchg.Prepare(sess)
 	c.Assert(err, IsNil)
 	done := outMsg.Split() // shouldn't panic
@@ -103,21 +128,24 @@
 
 func (s *exchangesSuite) TestBroadcastExchangeAckMismatch(c *C) {
 	sess := &testing.TestBrokerSession{
-		LevelsMap: broker.LevelsMap(map[store.InternalChannelId]int64{}),
+		LevelsMap:    broker.LevelsMap(map[store.InternalChannelId]int64{}),
+		Model:        "m1",
+		ImageChannel: "img2",
 	}
 	exchg := &broker.BroadcastExchange{
 		ChanId:   store.SystemInternalChannelId,
 		TopLevel: 3,
 		NotificationPayloads: []json.RawMessage{
-			json.RawMessage(`{"a":"y"}`),
+			json.RawMessage(`{"img2/m1":1}`),
 		},
 	}
+	exchg.Init()
 	outMsg, inMsg, err := exchg.Prepare(sess)
 	c.Assert(err, IsNil)
 	// check
 	marshalled, err := json.Marshal(outMsg)
 	c.Assert(err, IsNil)
-	c.Check(string(marshalled), Equals, `{"T":"broadcast","ChanId":"0","TopLevel":3,"Payloads":[{"a":"y"}]}`)
+	c.Check(string(marshalled), Equals, `{"T":"broadcast","ChanId":"0","TopLevel":3,"Payloads":[{"img2/m1":1}]}`)
 	err = json.Unmarshal([]byte(`{}`), inMsg)
 	c.Assert(err, IsNil)
 	err = exchg.Acked(sess, true)
@@ -130,23 +158,55 @@
 		LevelsMap: broker.LevelsMap(map[store.InternalChannelId]int64{
 			store.SystemInternalChannelId: 2,
 		}),
+		Model:        "m1",
+		ImageChannel: "img1",
 	}
 	exchg := &broker.BroadcastExchange{
 		ChanId:   store.SystemInternalChannelId,
 		TopLevel: 3,
 		NotificationPayloads: []json.RawMessage{
-			json.RawMessage(`{"a":"x"}`),
-			json.RawMessage(`{"a":"y"}`),
-		},
-	}
-	outMsg, inMsg, err := exchg.Prepare(sess)
-	c.Assert(err, IsNil)
-	// check
-	marshalled, err := json.Marshal(outMsg)
-	c.Assert(err, IsNil)
-	c.Check(string(marshalled), Equals, `{"T":"broadcast","ChanId":"0","TopLevel":3,"Payloads":[{"a":"y"}]}`)
-	err = json.Unmarshal([]byte(`{"T":"ack"}`), inMsg)
-	c.Assert(err, IsNil)
-	err = exchg.Acked(sess, true)
-	c.Assert(err, IsNil)
+			json.RawMessage(`{"img1/m1":100}`),
+			json.RawMessage(`{"img1/m1":101}`),
+		},
+	}
+	exchg.Init()
+	outMsg, inMsg, err := exchg.Prepare(sess)
+	c.Assert(err, IsNil)
+	// check
+	marshalled, err := json.Marshal(outMsg)
+	c.Assert(err, IsNil)
+	c.Check(string(marshalled), Equals, `{"T":"broadcast","ChanId":"0","TopLevel":3,"Payloads":[{"img1/m1":101}]}`)
+	err = json.Unmarshal([]byte(`{"T":"ack"}`), inMsg)
+	c.Assert(err, IsNil)
+	err = exchg.Acked(sess, true)
+	c.Assert(err, IsNil)
+}
+
+func (s *exchangesSuite) TestBroadcastExchangeChannelFilter(c *C) {
+	sess := &testing.TestBrokerSession{
+		LevelsMap:    broker.LevelsMap(map[store.InternalChannelId]int64{}),
+		Model:        "m1",
+		ImageChannel: "img1",
+	}
+	exchg := &broker.BroadcastExchange{
+		ChanId:   store.SystemInternalChannelId,
+		TopLevel: 5,
+		NotificationPayloads: []json.RawMessage{
+			json.RawMessage(`{"img1/m1":100}`),
+			json.RawMessage(`{"img2/m2":200}`),
+			json.RawMessage(`{"img1/m1":101}`),
+		},
+	}
+	exchg.Init()
+	outMsg, inMsg, err := exchg.Prepare(sess)
+	c.Assert(err, IsNil)
+	// check
+	marshalled, err := json.Marshal(outMsg)
+	c.Assert(err, IsNil)
+	c.Check(string(marshalled), Equals, `{"T":"broadcast","ChanId":"0","TopLevel":5,"Payloads":[{"img1/m1":100},{"img1/m1":101}]}`)
+	err = json.Unmarshal([]byte(`{"T":"ack"}`), inMsg)
+	c.Assert(err, IsNil)
+	err = exchg.Acked(sess, true)
+	c.Assert(err, IsNil)
+	c.Check(sess.LevelsMap[store.SystemInternalChannelId], Equals, int64(5))
 }

=== modified file 'server/broker/exchg_impl_test.go'
--- server/broker/exchg_impl_test.go	2014-02-10 23:19:08 +0000
+++ server/broker/exchg_impl_test.go	2014-04-04 14:39:41 +0000
@@ -20,6 +20,8 @@
 	"encoding/json"
 
 	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/server/store"
 )
 
 type exchangesImplSuite struct{}
@@ -56,3 +58,31 @@
 	res = filterByLevel(5, 10, nil)
 	c.Check(len(res), Equals, 0)
 }
+
+func (s *exchangesImplSuite) TestChannelFilter(c *C) {
+	payloads := []json.RawMessage{
+		json.RawMessage(`{"a/x": 3}`),
+		json.RawMessage(`{"b/x": 4}`),
+		json.RawMessage(`{"a/y": 5}`),
+		json.RawMessage(`{"a/x": 6}`),
+	}
+	decoded := make([]map[string]interface{}, 4)
+	for i, p := range payloads {
+		err := json.Unmarshal(p, &decoded[i])
+		c.Assert(err, IsNil)
+	}
+
+	other := store.InternalChannelId("1")
+
+	c.Check(channelFilter("", store.SystemInternalChannelId, nil, nil), IsNil)
+	c.Check(channelFilter("", other, payloads[1:], decoded), DeepEquals, payloads[1:])
+
+	// use tag when channel is the sytem channel
+
+	c.Check(channelFilter("c/z", store.SystemInternalChannelId, payloads, decoded), HasLen, 0)
+
+	c.Check(channelFilter("a/x", store.SystemInternalChannelId, payloads, decoded), DeepEquals, []json.RawMessage{payloads[0], payloads[3]})
+
+	c.Check(channelFilter("a/x", store.SystemInternalChannelId, payloads[1:], decoded), DeepEquals, []json.RawMessage{payloads[3]})
+
+}

=== modified file 'server/broker/simple/simple.go'
--- server/broker/simple/simple.go	2014-02-21 16:04:44 +0000
+++ server/broker/simple/simple.go	2014-04-04 14:39:41 +0000
@@ -46,11 +46,13 @@
 
 // simpleBrokerSession represents a session in the broker.
 type simpleBrokerSession struct {
-	registered bool
-	deviceId   string
-	done       chan bool
-	exchanges  chan broker.Exchange
-	levels     broker.LevelsMap
+	registered   bool
+	deviceId     string
+	model        string
+	imageChannel string
+	done         chan bool
+	exchanges    chan broker.Exchange
+	levels       broker.LevelsMap
 	// for exchanges
 	exchgScratch broker.ExchangesScratchArea
 }
@@ -75,6 +77,14 @@
 	return sess.deviceId
 }
 
+func (sess *simpleBrokerSession) DeviceImageModel() string {
+	return sess.model
+}
+
+func (sess *simpleBrokerSession) DeviceImageChannel() string {
+	return sess.imageChannel
+}
+
 func (sess *simpleBrokerSession) Levels() broker.LevelsMap {
 	return sess.levels
 }
@@ -147,6 +157,7 @@
 				TopLevel:             topLevel,
 				NotificationPayloads: payloads,
 			}
+			broadcastExchg.Init()
 			sess.exchanges <- broadcastExchg
 		}
 	}
@@ -157,6 +168,14 @@
 // pending notifications as well.
 func (b *SimpleBroker) Register(connect *protocol.ConnectMsg) (broker.BrokerSession, error) {
 	// xxx sanity check DeviceId
+	model, err := broker.GetInfoString(connect, "device", "?")
+	if err != nil {
+		return nil, err
+	}
+	imageChannel, err := broker.GetInfoString(connect, "channel", "?")
+	if err != nil {
+		return nil, err
+	}
 	levels := map[store.InternalChannelId]int64{}
 	for hexId, v := range connect.Levels {
 		id, err := store.HexToInternalChannelId(hexId)
@@ -166,14 +185,16 @@
 		levels[id] = v
 	}
 	sess := &simpleBrokerSession{
-		deviceId:  connect.DeviceId,
-		done:      make(chan bool),
-		exchanges: make(chan broker.Exchange, b.sessionQueueSize),
-		levels:    levels,
+		deviceId:     connect.DeviceId,
+		model:        model,
+		imageChannel: imageChannel,
+		done:         make(chan bool),
+		exchanges:    make(chan broker.Exchange, b.sessionQueueSize),
+		levels:       levels,
 	}
 	b.sessionCh <- sess
 	<-sess.done
-	err := b.feedPending(sess)
+	err = b.feedPending(sess)
 	if err != nil {
 		return nil, err
 	}
@@ -219,6 +240,7 @@
 					TopLevel:             topLevel,
 					NotificationPayloads: payloads,
 				}
+				broadcastExchg.Init()
 				for _, sess := range b.registry {
 					sess.exchanges <- broadcastExchg
 				}

=== modified file 'server/broker/simple/simple_test.go'
--- server/broker/simple/simple_test.go	2014-02-10 23:29:53 +0000
+++ server/broker/simple/simple_test.go	2014-04-04 14:39:41 +0000
@@ -48,6 +48,7 @@
 	sto := store.NewInMemoryPendingStore()
 	muchLater := time.Now().Add(10 * time.Minute)
 	notification1 := json.RawMessage(`{"m": "M"}`)
+	decoded1 := map[string]interface{}{"m": "M"}
 	sto.AppendToChannel(store.SystemInternalChannelId, notification1, muchLater)
 	b := NewSimpleBroker(sto, testBrokerConfig, nil)
 	sess := &simpleBrokerSession{
@@ -60,6 +61,7 @@
 		ChanId:               store.SystemInternalChannelId,
 		TopLevel:             1,
 		NotificationPayloads: []json.RawMessage{notification1},
+		Decoded:              []map[string]interface{}{decoded1},
 	})
 }
 

=== modified file 'server/broker/testing/impls.go'
--- server/broker/testing/impls.go	2014-01-23 20:13:22 +0000
+++ server/broker/testing/impls.go	2014-04-04 14:39:41 +0000
@@ -24,6 +24,8 @@
 // Test implementation of BrokerSession.
 type TestBrokerSession struct {
 	DeviceId     string
+	Model        string
+	ImageChannel string
 	Exchanges    chan broker.Exchange
 	LevelsMap    broker.LevelsMap
 	exchgScratch broker.ExchangesScratchArea
@@ -33,6 +35,14 @@
 	return tbs.DeviceId
 }
 
+func (tbs *TestBrokerSession) DeviceImageModel() string {
+	return tbs.Model
+}
+
+func (tbs *TestBrokerSession) DeviceImageChannel() string {
+	return tbs.ImageChannel
+}
+
 func (tbs *TestBrokerSession) SessionChannel() <-chan broker.Exchange {
 	return tbs.Exchanges
 }

=== modified file 'server/broker/testsuite/suite.go'
--- server/broker/testsuite/suite.go	2014-03-19 23:46:18 +0000
+++ server/broker/testsuite/suite.go	2014-04-04 14:39:41 +0000
@@ -81,10 +81,20 @@
 	b := s.MakeBroker(sto, testBrokerConfig, nil)
 	b.Start()
 	defer b.Stop()
-	sess, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1", Levels: map[string]int64{"0": 5}})
+	sess, err := b.Register(&protocol.ConnectMsg{
+		Type:     "connect",
+		DeviceId: "dev-1",
+		Levels:   map[string]int64{"0": 5},
+		Info: map[string]interface{}{
+			"device":  "model",
+			"channel": "daily",
+		},
+	})
 	c.Assert(err, IsNil)
 	c.Assert(s.RevealSession(b, "dev-1"), Equals, sess)
 	c.Assert(sess.DeviceIdentifier(), Equals, "dev-1")
+	c.Check(sess.DeviceImageModel(), Equals, "model")
+	c.Check(sess.DeviceImageChannel(), Equals, "daily")
 	c.Assert(sess.ExchangeScratchArea(), Not(IsNil))
 	c.Check(sess.Levels(), DeepEquals, broker.LevelsMap(map[store.InternalChannelId]int64{
 		store.SystemInternalChannelId: 5,
@@ -105,6 +115,22 @@
 	c.Check(err, FitsTypeOf, &broker.ErrAbort{})
 }
 
+func (s *CommonBrokerSuite) TestRegistrationInfoErrors(c *C) {
+	sto := store.NewInMemoryPendingStore()
+	b := s.MakeBroker(sto, testBrokerConfig, nil)
+	b.Start()
+	defer b.Stop()
+	info := map[string]interface{}{
+		"device": -1,
+	}
+	_, err := b.Register(&protocol.ConnectMsg{Type: "connect", Info: info})
+	c.Check(err, Equals, broker.ErrUnexpectedValue)
+	info["device"] = "m"
+	info["channel"] = -1
+	_, err = b.Register(&protocol.ConnectMsg{Type: "connect", Info: info})
+	c.Check(err, Equals, broker.ErrUnexpectedValue)
+}
+
 func (s *CommonBrokerSuite) TestRegistrationFeedPending(c *C) {
 	sto := store.NewInMemoryPendingStore()
 	notification1 := json.RawMessage(`{"m": "M"}`)
@@ -149,6 +175,7 @@
 func (s *CommonBrokerSuite) TestBroadcast(c *C) {
 	sto := store.NewInMemoryPendingStore()
 	notification1 := json.RawMessage(`{"m": "M"}`)
+	decoded1 := map[string]interface{}{"m": "M"}
 	b := s.MakeBroker(sto, testBrokerConfig, nil)
 	b.Start()
 	defer b.Stop()
@@ -168,6 +195,7 @@
 			ChanId:               store.SystemInternalChannelId,
 			TopLevel:             1,
 			NotificationPayloads: []json.RawMessage{notification1},
+			Decoded:              []map[string]interface{}{decoded1},
 		})
 	}
 	select {
@@ -178,6 +206,7 @@
 			ChanId:               store.SystemInternalChannelId,
 			TopLevel:             1,
 			NotificationPayloads: []json.RawMessage{notification1},
+			Decoded:              []map[string]interface{}{decoded1},
 		})
 	}
 }