Merge lp:~chipaca/ubuntu-push/cherrypickings into lp:ubuntu-push

[John Lenton]

[ Samuele Pedroni ]
  * gave the client the ability to get config from commandline
    ( => easier automated testing) (LP: #1311600)

  [ John Lenton ]
  * Ensure ubuntu-push-client is the only one running in the session.
    (LP: #1309432)
  * Remove supurious numbers in brackets in notifications. (LP: #1308145)
  * Check the server certificate and server name. (LP: #1297969)
  * Loop whoopsie_identifier_generate until it starts working. (LP: #1309237)
  * In the session: set a flag on connect, clear it on successfully
    replying to ping or broadcast messages, check it at the top of
    autoredial. Also track the last autoredial, and set the delay flag if
    autoredial is re-called too quickly. (LP: #1309231)

[ Samuele Pedroni ]
  * gave the client the ability to get config from commandline
    ( => easier automated testing) (LP: #1311600)

  [ John Lenton ]
  * Ensure ubuntu-push-client is the only one running in the session.
    (LP: #1309432)
  * Remove supurious numbers in brackets in notifications. (LP: #1308145)
  * Check the server certificate and server name. (LP: #1297969)
  * Loop whoopsie_identifier_generate until it starts working. (LP: #1309237)
  * In the session: set a flag on connect, clear it on successfully
    replying to ping or broadcast messages, check it at the top of
    autoredial. Also track the last autoredial, and set the delay flag if
    autoredial is re-called too quickly. (LP: #1309231)

[lp:~chipaca/ubuntu-push/cherrypickings]

109. By John Lenton on 2014-04-21

fix changelog

110. By John Lenton on 2014-04-23

updated changelog with link to lp:216466

111. By John Lenton on 2014-04-23

updated changelog with link to lp:1311600 which is what it should be

=== modified file 'client/client.go'
--- client/client.go	2014-04-11 16:37:48 +0000
+++ client/client.go	2014-04-23 11:53:01 +0000
@@ -57,7 +57,7 @@
 	// The PEM-encoded server certificate
 	CertPEMFile string `json:"cert_pem_file"`
 	// The logging level (one of "debug", "info", "error")
-	LogLevel string `json:"log_level"`
+	LogLevel logger.ConfigLogLevel `json:"log_level"`
 }
 
 // PushClient is the Ubuntu Push Notifications client-side daemon.
@@ -95,13 +95,13 @@
 
 // configure loads its configuration, and sets it up.
 func (client *PushClient) configure() error {
-	f, err := os.Open(client.configPath)
+	_, err := os.Stat(client.configPath)
 	if err != nil {
-		return fmt.Errorf("opening config: %v", err)
+		return fmt.Errorf("config: %v", err)
 	}
-	err = config.ReadConfig(f, &client.config)
+	err = config.ReadFiles(&client.config, client.configPath, "<flags>")
 	if err != nil {
-		return fmt.Errorf("reading config: %v", err)
+		return fmt.Errorf("config: %v", err)
 	}
 	// ignore spaces
 	client.config.Addr = strings.Replace(client.config.Addr, " ", "", -1)
@@ -110,7 +110,7 @@
 	}
 
 	// later, we'll be specifying more logging options in the config file
-	client.log = logger.NewSimpleLogger(os.Stderr, client.config.LogLevel)
+	client.log = logger.NewSimpleLogger(os.Stderr, client.config.LogLevel.Level())
 
 	// overridden for testing
 	client.idder = identifier.New()
@@ -285,9 +285,6 @@
 	h := map[string]*dbus.Variant{"x-canonical-switch-to-application": &dbus.Variant{true}}
 	nots := notifications.Raw(client.notificationsEndp, client.log)
 	body := "Tap to open the system updater."
-	if msg != nil {
-		body = fmt.Sprintf("[%d] %s", msg.TopLevel, body)
-	}
 	not_id, err := nots.Notify(
 		"ubuntu-push-client",               // app name
 		uint32(0),                          // id

=== modified file 'client/client_test.go'
--- client/client_test.go	2014-04-11 16:21:45 +0000
+++ client/client_test.go	2014-04-23 11:53:01 +0000
@@ -19,10 +19,12 @@
 import (
 	"encoding/json"
 	"errors"
+	"flag"
 	"fmt"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
+	"os"
 	"path/filepath"
 	"reflect"
 	"testing"
@@ -37,6 +39,7 @@
 	testibus "launchpad.net/ubuntu-push/bus/testing"
 	"launchpad.net/ubuntu-push/client/session"
 	"launchpad.net/ubuntu-push/client/session/levelmap"
+	"launchpad.net/ubuntu-push/config"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
 	"launchpad.net/ubuntu-push/util"
@@ -79,6 +82,7 @@
 }
 
 func (cs *clientSuite) SetUpSuite(c *C) {
+	config.IgnoreParsedFlags = true // because configure() uses <flags>
 	cs.timeouts = util.SwapTimeouts([]time.Duration{0})
 	cs.leveldbPath = ""
 }
@@ -142,6 +146,16 @@
 	c.Check(cli.config.ExchangeTimeout.TimeDuration(), Equals, time.Duration(10*time.Millisecond))
 }
 
+func (cs *clientSuite) TestConfigureWorksWithFlags(c *C) {
+	flag.CommandLine = flag.NewFlagSet("client", flag.ContinueOnError)
+	os.Args = []string{"client", "-addr", "foo:7777"}
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	err := cli.configure()
+	c.Assert(err, IsNil)
+	c.Assert(cli.config, NotNil)
+	c.Check(cli.config.Addr, Equals, "foo:7777")
+}
+
 func (cs *clientSuite) TestConfigureSetsUpLog(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	c.Check(cli.log, IsNil)
@@ -163,7 +177,7 @@
 	c.Check(cli.idder, IsNil)
 	err := cli.configure()
 	c.Assert(err, IsNil)
-	c.Assert(cli.idder, DeepEquals, identifier.New())
+	c.Assert(cli.idder, FitsTypeOf, identifier.New())
 }
 
 func (cs *clientSuite) TestConfigureSetsUpEndpoints(c *C) {

=== modified file 'client/gethosts/gethost.go'
--- client/gethosts/gethost.go	2014-03-24 15:32:29 +0000
+++ client/gethosts/gethost.go	2014-04-23 11:53:01 +0000
@@ -49,8 +49,10 @@
 	}
 }
 
-type expected struct {
-	Hosts []string
+// Host contains the domain and hosts returned by the remote endpoint
+type Host struct {
+	Domain string
+	Hosts  []string
 }
 
 var (
@@ -60,7 +62,7 @@
 )
 
 // Get gets a list of hosts consulting the endpoint.
-func (gh *GetHost) Get() ([]string, error) {
+func (gh *GetHost) Get() (*Host, error) {
 	resp, err := gh.cli.Get(gh.endpointUrl + "?h=" + gh.hash)
 	if err != nil {
 		return nil, err
@@ -80,7 +82,7 @@
 	if err != nil {
 		return nil, err
 	}
-	var parsed expected
+	var parsed Host
 	err = json.Unmarshal(body, &parsed)
 	if err != nil {
 		return nil, ErrTemporary
@@ -88,5 +90,5 @@
 	if len(parsed.Hosts) == 0 {
 		return nil, ErrTemporary
 	}
-	return parsed.Hosts, nil
+	return &parsed, nil
 }

=== modified file 'client/gethosts/gethost_test.go'
--- client/gethosts/gethost_test.go	2014-03-31 14:31:07 +0000
+++ client/gethosts/gethost_test.go	2014-04-23 11:53:01 +0000
@@ -45,7 +45,8 @@
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		x := r.FormValue("h")
 		b, err := json.Marshal(map[string]interface{}{
-			"hosts": []string{"http://" + x},
+			"domain": "example.com",
+			"hosts":  []string{"http://" + x},
 		})
 		if err != nil {
 			panic(err)
@@ -57,7 +58,8 @@
 	gh := New("foobar", ts.URL, 1*time.Second)
 	res, err := gh.Get()
 	c.Assert(err, IsNil)
-	c.Check(res, DeepEquals, []string{"http://c1130408a700afe0"})
+	c.Check(*res, DeepEquals,
+		Host{Domain: "example.com", Hosts: []string{"http://c1130408a700afe0"}})
 }
 
 func (s *getHostsSuite) TestGetTimeout(c *C) {
@@ -97,4 +99,6 @@
 
 	scenario(http.StatusOK, "{", ErrTemporary)
 	scenario(http.StatusOK, "{}", ErrTemporary)
+	scenario(http.StatusOK, `{"domain": "example.com"}`, ErrTemporary)
+	scenario(http.StatusOK, `{"hosts": ["one"]}`, nil)
 }

=== modified file 'client/session/session.go'
--- client/session/session.go	2014-04-04 13:55:00 +0000
+++ client/session/session.go	2014-04-23 11:53:01 +0000
@@ -73,7 +73,7 @@
 )
 
 type hostGetter interface {
-	Get() ([]string, error)
+	Get() (*gethosts.Host, error)
 }
 
 // ClientSessionConfig groups the client session configuration.
@@ -115,6 +115,26 @@
 	stateP *uint32
 	ErrCh  chan error
 	MsgCh  chan *Notification
+	// autoredial knobs
+	shouldDelayP    *uint32
+	lastAutoRedial  time.Time
+	redialDelay     func(*ClientSession) time.Duration
+	redialJitter    func(time.Duration) time.Duration
+	redialDelays    []time.Duration
+	redialDelaysIdx int
+}
+
+func redialDelay(sess *ClientSession) time.Duration {
+	if sess.ShouldDelay() {
+		t := sess.redialDelays[sess.redialDelaysIdx]
+		if len(sess.redialDelays) > sess.redialDelaysIdx+1 {
+			sess.redialDelaysIdx++
+		}
+		return t + sess.redialJitter(t)
+	} else {
+		sess.redialDelaysIdx = 0
+		return 0
+	}
 }
 
 func NewSession(serverAddrSpec string, conf ClientSessionConfig,
@@ -131,6 +151,7 @@
 	if hostsEndpoint != "" {
 		getHost = gethosts.New(deviceId, hostsEndpoint, conf.ExchangeTimeout)
 	}
+	var shouldDelay uint32 = 0
 	sess := &ClientSession{
 		ClientSessionConfig: conf,
 		getHost:             getHost,
@@ -139,10 +160,14 @@
 		Log:                 log,
 		Protocolator:        protocol.NewProtocol0,
 		Levels:              levels,
-		TLS:                 &tls.Config{InsecureSkipVerify: true}, // XXX
+		TLS:                 &tls.Config{},
 		stateP:              &state,
 		timeSince:           time.Since,
+		shouldDelayP:        &shouldDelay,
+		redialDelay:         redialDelay,
+		redialDelays:        util.Timeouts(),
 	}
+	sess.redialJitter = sess.Jitter
 	if sess.PEM != nil {
 		cp := x509.NewCertPool()
 		ok := cp.AppendCertsFromPEM(sess.PEM)
@@ -154,6 +179,18 @@
 	return sess, nil
 }
 
+func (sess *ClientSession) ShouldDelay() bool {
+	return atomic.LoadUint32(sess.shouldDelayP) != 0
+}
+
+func (sess *ClientSession) setShouldDelay() {
+	atomic.StoreUint32(sess.shouldDelayP, uint32(1))
+}
+
+func (sess *ClientSession) clearShouldDelay() {
+	atomic.StoreUint32(sess.shouldDelayP, uint32(0))
+}
+
 func (sess *ClientSession) State() ClientSessionState {
 	return ClientSessionState(atomic.LoadUint32(sess.stateP))
 }
@@ -180,14 +217,17 @@
 		if sess.deliveryHosts != nil && sess.timeSince(sess.deliveryHostsTimestamp) < sess.HostsCachingExpiryTime {
 			return nil
 		}
-		hosts, err := sess.getHost.Get()
+		host, 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
+		sess.deliveryHosts = host.Hosts
+		if sess.TLS != nil {
+			sess.TLS.ServerName = host.Domain
+		}
 	} else {
 		sess.deliveryHosts = sess.fallbackHosts
 	}
@@ -234,6 +274,7 @@
 // connect to a server using the configuration in the ClientSession
 // and set up the connection.
 func (sess *ClientSession) connect() error {
+	sess.setShouldDelay()
 	sess.startConnectionAttempt()
 	var err error
 	var conn net.Conn
@@ -263,7 +304,12 @@
 
 func (sess *ClientSession) AutoRedial(doneCh chan uint32) {
 	sess.stopRedial()
+	if time.Since(sess.lastAutoRedial) < 2*time.Second {
+		sess.setShouldDelay()
+	}
+	time.Sleep(sess.redialDelay(sess))
 	sess.retrier = util.NewAutoRedialer(sess)
+	sess.lastAutoRedial = time.Now()
 	go func() { doneCh <- sess.retrier.Redial() }()
 }
 
@@ -289,6 +335,7 @@
 	err := sess.proto.WriteMessage(protocol.PingPongMsg{Type: "pong"})
 	if err == nil {
 		sess.Log.Debugf("ping.")
+		sess.clearShouldDelay()
 	} else {
 		sess.setState(Error)
 		sess.Log.Errorf("unable to pong: %s", err)
@@ -330,6 +377,7 @@
 		sess.Log.Errorf("unable to ack broadcast: %s", err)
 		return err
 	}
+	sess.clearShouldDelay()
 	sess.Log.Debugf("broadcast chan:%v app:%v topLevel:%d payloads:%s",
 		bcast.ChanId, bcast.AppId, bcast.TopLevel, bcast.Payloads)
 	if bcast.ChanId == protocol.SystemChannelId {

=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-04-04 13:55:00 +0000
+++ client/session/session_test.go	2014-04-23 11:53:01 +0000
@@ -32,12 +32,13 @@
 
 	. "launchpad.net/gocheck"
 
+	"launchpad.net/ubuntu-push/client/gethosts"
 	"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"
+	"launchpad.net/ubuntu-push/util"
 )
 
 func TestSession(t *testing.T) { TestingT(t) }
@@ -214,6 +215,10 @@
 	c.Check(sess, NotNil)
 	c.Check(err, IsNil)
 	c.Check(sess.fallbackHosts, DeepEquals, []string{"foo:443"})
+	// the session is happy and redial delayer is default
+	c.Check(sess.ShouldDelay(), Equals, false)
+	c.Check(fmt.Sprintf("%#v", sess.redialDelay), Equals, fmt.Sprintf("%#v", redialDelay))
+	c.Check(sess.redialDelays, DeepEquals, util.Timeouts())
 	// but no root CAs set
 	c.Check(sess.TLS.RootCAs, IsNil)
 	c.Check(sess.State(), Equals, Disconnected)
@@ -264,16 +269,17 @@
 }
 
 type testHostGetter struct {
-	hosts []string
-	err   error
+	domain string
+	hosts  []string
+	err    error
 }
 
-func (thg *testHostGetter) Get() ([]string, error) {
-	return thg.hosts, thg.err
+func (thg *testHostGetter) Get() (*gethosts.Host, error) {
+	return &gethosts.Host{thg.domain, thg.hosts}, thg.err
 }
 
 func (cs *clientSessionSuite) TestGetHostsRemote(c *C) {
-	hostGetter := &testHostGetter{[]string{"foo:443", "bar:443"}, nil}
+	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
 	sess := &ClientSession{getHost: hostGetter, timeSince: time.Since}
 	err := sess.getHosts()
 	c.Assert(err, IsNil)
@@ -284,7 +290,7 @@
 	sess, err := NewSession("", dummyConf, "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	hostsErr := errors.New("failed")
-	hostGetter := &testHostGetter{nil, hostsErr}
+	hostGetter := &testHostGetter{"", nil, hostsErr}
 	sess.getHost = hostGetter
 	err = sess.getHosts()
 	c.Assert(err, Equals, hostsErr)
@@ -293,7 +299,7 @@
 }
 
 func (cs *clientSessionSuite) TestGetHostsRemoteCaching(c *C) {
-	hostGetter := &testHostGetter{[]string{"foo:443", "bar:443"}, nil}
+	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
 	sess := &ClientSession{
 		getHost: hostGetter,
 		ClientSessionConfig: ClientSessionConfig{
@@ -318,7 +324,7 @@
 }
 
 func (cs *clientSessionSuite) TestGetHostsRemoteCachingReset(c *C) {
-	hostGetter := &testHostGetter{[]string{"foo:443", "bar:443"}, nil}
+	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
 	sess := &ClientSession{
 		getHost: hostGetter,
 		ClientSessionConfig: ClientSessionConfig{
@@ -427,7 +433,9 @@
 	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{"nowhere"}
+	sess.clearShouldDelay()
 	err = sess.connect()
+	c.Check(sess.ShouldDelay(), Equals, true)
 	c.Check(err, ErrorMatches, ".*connect.*address.*")
 	c.Check(sess.State(), Equals, Error)
 }
@@ -439,7 +447,9 @@
 	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{srv.Addr().String()}
+	sess.clearShouldDelay()
 	err = sess.connect()
+	c.Check(sess.ShouldDelay(), Equals, true)
 	c.Check(err, IsNil)
 	c.Check(sess.Connection, NotNil)
 	c.Check(sess.State(), Equals, Connected)
@@ -452,7 +462,9 @@
 	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{"nowhere", srv.Addr().String()}
+	sess.clearShouldDelay()
 	err = sess.connect()
+	c.Check(sess.ShouldDelay(), Equals, true)
 	c.Check(err, IsNil)
 	c.Check(sess.Connection, NotNil)
 	c.Check(sess.State(), Equals, Connected)
@@ -466,7 +478,9 @@
 	srv.Close()
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{srv.Addr().String()}
+	sess.clearShouldDelay()
 	err = sess.connect()
+	c.Check(sess.ShouldDelay(), Equals, true)
 	c.Check(err, ErrorMatches, ".*connection refused")
 	c.Check(sess.State(), Equals, Error)
 }
@@ -548,6 +562,27 @@
 	c.Check(<-ch, Not(Equals), 0)
 }
 
+func (cs *clientSessionSuite) TestAutoRedialCallsRedialDelay(c *C) {
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	flag := false
+	sess.redialDelay = func(sess *ClientSession) time.Duration { flag = true; return 0 }
+	sess.AutoRedial(nil)
+	c.Check(flag, Equals, true)
+}
+
+func (cs *clientSessionSuite) TestAutoRedialSetsRedialDelayIfTooQuick(c *C) {
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	sess.redialDelay = func(sess *ClientSession) time.Duration { return 0 }
+	sess.AutoRedial(nil)
+	c.Check(sess.ShouldDelay(), Equals, false)
+	sess.stopRedial()
+	sess.clearShouldDelay()
+	sess.AutoRedial(nil)
+	c.Check(sess.ShouldDelay(), Equals, true)
+}
+
 /****************************************************************
   handlePing() tests
 ****************************************************************/
@@ -594,6 +629,24 @@
 	c.Check(s.sess.State(), Equals, Error)
 }
 
+func (s *msgSuite) TestHandlePingClearsDelay(c *C) {
+	s.sess.setShouldDelay()
+	s.upCh <- nil // no error
+	c.Check(s.sess.handlePing(), IsNil)
+	c.Assert(len(s.downCh), Equals, 1)
+	c.Check(<-s.downCh, Equals, protocol.PingPongMsg{Type: "pong"})
+	c.Check(s.sess.ShouldDelay(), Equals, false)
+}
+
+func (s *msgSuite) TestHandlePingDoesNotClearsDelayOnError(c *C) {
+	s.sess.setShouldDelay()
+	s.upCh <- errors.New("Pong")
+	c.Check(s.sess.handlePing(), NotNil)
+	c.Assert(len(s.downCh), Equals, 1)
+	c.Check(<-s.downCh, Equals, protocol.PingPongMsg{Type: "pong"})
+	c.Check(s.sess.ShouldDelay(), Equals, true)
+}
+
 /****************************************************************
   handleBroadcast() tests
 ****************************************************************/
@@ -687,6 +740,32 @@
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"nak"})
 }
 
+func (s *msgSuite) TestHandleBroadcastClearsDelay(c *C) {
+	s.sess.setShouldDelay()
+
+	msg := serverMsg{"broadcast", protocol.BroadcastMsg{},
+		protocol.NotificationsMsg{}, protocol.ConnBrokenMsg{}}
+	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, IsNil)
+
+	c.Check(s.sess.ShouldDelay(), Equals, false)
+}
+
+func (s *msgSuite) TestHandleBroadcastDoesNotClearDelayOnError(c *C) {
+	s.sess.setShouldDelay()
+
+	msg := serverMsg{"broadcast", protocol.BroadcastMsg{},
+		protocol.NotificationsMsg{}, protocol.ConnBrokenMsg{}}
+	go func() { s.errCh <- s.sess.handleBroadcast(&msg) }()
+	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
+	s.upCh <- errors.New("bcast")
+	c.Check(<-s.errCh, NotNil)
+
+	c.Check(s.sess.ShouldDelay(), Equals, true)
+}
+
 /****************************************************************
   handleConnBroken() tests
 ****************************************************************/
@@ -1087,9 +1166,64 @@
 
 var (
 	dialTestTimeout = 100 * time.Millisecond
-	dialTestConf    = ClientSessionConfig{ExchangeTimeout: dialTestTimeout}
+	dialTestConf    = ClientSessionConfig{
+		ExchangeTimeout: dialTestTimeout,
+		PEM:             helpers.TestCertPEMBlock,
+	}
 )
 
+func (cs *clientSessionSuite) TestDialBadServerName(c *C) {
+	// a borked server name
+	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)
+	// advertise
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		b, err := json.Marshal(map[string]interface{}{
+			"domain": "xyzzy", // <-- *** THIS *** is the bit that'll break it
+			"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{}
+	sess.Connection = tconn
+
+	upCh := make(chan interface{}, 5)
+	downCh := make(chan interface{}, 5)
+	errCh := make(chan error, 1)
+	proto := &testProtocol{up: upCh, down: downCh}
+	sess.Protocolator = func(net.Conn) protocol.Protocol { return proto }
+
+	go func() {
+		errCh <- sess.Dial()
+	}()
+
+	srv, err := lst.Accept()
+	c.Assert(err, IsNil)
+
+	// connect done
+
+	_, err = protocol.ReadWireFormatVersion(srv, dialTestTimeout)
+	c.Check(err, NotNil)
+
+	c.Check(<-errCh, NotNil)
+	c.Check(sess.State(), Equals, Error)
+}
+
 func (cs *clientSessionSuite) TestDialWorks(c *C) {
 	// happy path thoughts
 	cert, err := tls.X509KeyPair(helpers.TestCertPEMBlock, helpers.TestKeyPEMBlock)
@@ -1104,7 +1238,8 @@
 	// 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()},
+			"domain": "localhost",
+			"hosts":  []string{"nowhere", lst.Addr().String()},
 		})
 		if err != nil {
 			panic(err)
@@ -1223,3 +1358,38 @@
 	c.Assert(err, IsNil)
 	// connect done
 }
+
+/****************************************************************
+  redialDelay() tests
+****************************************************************/
+
+func (cs *clientSessionSuite) TestShouldDelay(c *C) {
+	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	c.Check(sess.ShouldDelay(), Equals, false)
+	sess.setShouldDelay()
+	c.Check(sess.ShouldDelay(), Equals, true)
+	sess.clearShouldDelay()
+	c.Check(sess.ShouldDelay(), Equals, false)
+}
+
+func (cs *clientSessionSuite) TestRedialDelay(c *C) {
+	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	sess.redialDelays = []time.Duration{17, 42}
+	n := 0
+	sess.redialJitter = func(time.Duration) time.Duration { n++; return 0 }
+	// we get increasing delays while we're unhappy
+	sess.setShouldDelay()
+	c.Check(redialDelay(sess), Equals, time.Duration(17))
+	c.Check(redialDelay(sess), Equals, time.Duration(42))
+	c.Check(redialDelay(sess), Equals, time.Duration(42))
+	// once we're happy, delays drop to 0
+	sess.clearShouldDelay()
+	c.Check(redialDelay(sess), Equals, time.Duration(0))
+	// and start again from the top if we become unhappy again
+	sess.setShouldDelay()
+	c.Check(redialDelay(sess), Equals, time.Duration(17))
+	// and redialJitter got called every time shouldDelay was true
+	c.Check(n, Equals, 4)
+}

=== modified file 'config/config.go'
--- config/config.go	2014-03-25 18:49:18 +0000
+++ config/config.go	2014-04-23 11:53:01 +0000
@@ -20,6 +20,7 @@
 import (
 	"encoding/json"
 	"errors"
+	"flag"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -27,6 +28,7 @@
 	"os"
 	"path/filepath"
 	"reflect"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -118,6 +120,22 @@
 	return fillDestConfig(destValue, p1)
 }
 
+// FromString are config holders that can be set by parsing a string.
+type FromString interface {
+	SetFromString(enc string) error
+}
+
+// UnmarshalJSONViaString helps unmarshalling from JSON for FromString
+// supporting config holders.
+func UnmarshalJSONViaString(dest FromString, b []byte) error {
+	var enc string
+	err := json.Unmarshal(b, &enc)
+	if err != nil {
+		return err
+	}
+	return dest.SetFromString(enc)
+}
+
 // ConfigTimeDuration can hold a time.Duration in a configuration struct,
 // that is parsed from a string as supported by time.ParseDuration.
 type ConfigTimeDuration struct {
@@ -125,13 +143,11 @@
 }
 
 func (ctd *ConfigTimeDuration) UnmarshalJSON(b []byte) error {
-	var enc string
-	var v time.Duration
-	err := json.Unmarshal(b, &enc)
-	if err != nil {
-		return err
-	}
-	v, err = time.ParseDuration(enc)
+	return UnmarshalJSONViaString(ctd, b)
+}
+
+func (ctd *ConfigTimeDuration) SetFromString(enc string) error {
+	v, err := time.ParseDuration(enc)
 	if err != nil {
 		return err
 	}
@@ -148,12 +164,11 @@
 type ConfigHostPort string
 
 func (chp *ConfigHostPort) UnmarshalJSON(b []byte) error {
-	var enc string
-	err := json.Unmarshal(b, &enc)
-	if err != nil {
-		return err
-	}
-	_, _, err = net.SplitHostPort(enc)
+	return UnmarshalJSONViaString(chp, b)
+}
+
+func (chp *ConfigHostPort) SetFromString(enc string) error {
+	_, _, err := net.SplitHostPort(enc)
 	if err != nil {
 		return err
 	}
@@ -198,23 +213,117 @@
 	return ioutil.ReadFile(p)
 }
 
-// ReadFiles reads configuration from a set of files. Uses ReadConfig internally.
+// used to implement getting config values with flag.Parse()
+type val struct {
+	destField destField
+	accu      map[string]json.RawMessage
+}
+
+func (v *val) String() string { // used to show default
+	return string(v.accu[v.destField.configName()])
+}
+
+func (v *val) IsBoolFlag() bool {
+	return v.destField.fld.Type.Kind() == reflect.Bool
+}
+
+func (v *val) marshalAsNeeded(s string) (json.RawMessage, error) {
+	var toMarshal interface{}
+	switch v.destField.dest.(type) {
+	case *string, FromString:
+		toMarshal = s
+	case *bool:
+		bit, err := strconv.ParseBool(s)
+		if err != nil {
+			return nil, err
+		}
+		toMarshal = bit
+	default:
+		return json.RawMessage(s), nil
+	}
+	return json.Marshal(toMarshal)
+}
+
+func (v *val) Set(s string) error {
+	marshalled, err := v.marshalAsNeeded(s)
+	if err != nil {
+		return err
+	}
+	v.accu[v.destField.configName()] = marshalled
+	return nil
+}
+
+func readOneConfig(accu map[string]json.RawMessage, cfgPath string) error {
+	r, err := os.Open(cfgPath)
+	if err != nil {
+		return err
+	}
+	defer r.Close()
+	err = json.NewDecoder(r).Decode(&accu)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// used to implement -cfg@=
+type readConfigAtVal struct {
+	accu map[string]json.RawMessage
+}
+
+func (v *readConfigAtVal) String() string {
+	return "<config.json>"
+}
+
+func (v *readConfigAtVal) Set(path string) error {
+	return readOneConfig(v.accu, path)
+}
+
+// readUsingFlags gets config values from command line flags.
+func readUsingFlags(accu map[string]json.RawMessage, destValue reflect.Value) error {
+	if flag.Parsed() {
+		if IgnoreParsedFlags {
+			return nil
+		}
+		return fmt.Errorf("too late, flags already parsed")
+	}
+	destStruct := destValue.Elem()
+	for destField := range traverseStruct(destStruct) {
+		help := destField.fld.Tag.Get("help")
+		flag.Var(&val{destField, accu}, destField.configName(), help)
+	}
+	flag.Var(&readConfigAtVal{accu}, "cfg@", "get config values from file")
+	flag.Parse()
+	return nil
+}
+
+// IgnoreParsedFlags will just have ReadFiles ignore <flags> if the
+// command line was already parsed.
+var IgnoreParsedFlags = false
+
+// ReadFiles reads configuration from a set of files. The string
+// "<flags>" can be used as a pseudo file-path, it will consider
+// command line flags, invoking flag.Parse(). Among those the flag
+// -cfg@=FILE can be used to get further config values from FILE.
 func ReadFiles(destConfig interface{}, cfgFpaths ...string) error {
 	destValue, err := checkDestConfig("destConfig", destConfig)
 	if err != nil {
 		return err
 	}
 	// do the parsing in two phases for better error handling
-	var p1 map[string]json.RawMessage
+	p1 := make(map[string]json.RawMessage)
 	readOne := false
 	for _, cfgPath := range cfgFpaths {
+		if cfgPath == "<flags>" {
+			err := readUsingFlags(p1, destValue)
+			if err != nil {
+				return err
+			}
+			readOne = true
+			continue
+		}
 		if _, err := os.Stat(cfgPath); err == nil {
-			r, err := os.Open(cfgPath)
-			if err != nil {
-				return err
-			}
-			defer r.Close()
-			err = json.NewDecoder(r).Decode(&p1)
+			err := readOneConfig(p1, cfgPath)
 			if err != nil {
 				return err
 			}

=== modified file 'config/config_test.go'
--- config/config_test.go	2014-03-25 18:49:18 +0000
+++ config/config_test.go	2014-04-23 11:53:01 +0000
@@ -18,6 +18,9 @@
 
 import (
 	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -230,3 +233,105 @@
 	c.Check(res, DeepEquals, []string{"b", "c_list", "d"})
 
 }
+
+type testConfig3 struct {
+	A bool
+	B string
+	C []string           `json:"c_list"`
+	D ConfigTimeDuration `help:"duration"`
+	E ConfigHostPort
+	F string
+}
+
+type configFlagsSuite struct{}
+
+var _ = Suite(&configFlagsSuite{})
+
+func (s *configFlagsSuite) SetUpTest(c *C) {
+	flag.CommandLine = flag.NewFlagSet("cmd", flag.PanicOnError)
+	// supress outputs
+	flag.Usage = func() { flag.PrintDefaults() }
+	flag.CommandLine.SetOutput(ioutil.Discard)
+}
+
+func (s *configFlagsSuite) TestReadUsingFlags(c *C) {
+	os.Args = []string{"cmd", "-a=1", "-b=foo", "-c_list", `["x","y"]`, "-d", "10s", "-e=localhost:80"}
+	var cfg testConfig3
+	p := make(map[string]json.RawMessage)
+	err := readUsingFlags(p, reflect.ValueOf(&cfg))
+	c.Assert(err, IsNil)
+	c.Check(p, DeepEquals, map[string]json.RawMessage{
+		"a":      json.RawMessage("true"),
+		"b":      json.RawMessage(`"foo"`),
+		"c_list": json.RawMessage(`["x","y"]`),
+		"d":      json.RawMessage(`"10s"`),
+		"e":      json.RawMessage(`"localhost:80"`),
+	})
+}
+
+func (s *configFlagsSuite) TestReadUsingFlagsBoolError(c *C) {
+	os.Args = []string{"cmd", "-a=zoo"}
+	var cfg testConfig3
+	p := make(map[string]json.RawMessage)
+	c.Check(func() { readUsingFlags(p, reflect.ValueOf(&cfg)) }, PanicMatches, ".*invalid boolean.*-a.*")
+}
+
+func (s *configFlagsSuite) TestReadFilesAndFlags(c *C) {
+	// test <flags> pseudo file
+	os.Args = []string{"cmd", "-b=x"}
+	tmpDir := c.MkDir()
+	cfgPath := filepath.Join(tmpDir, "cfg.json")
+	err := ioutil.WriteFile(cfgPath, []byte(`{"a": 42, "c_list": ["y", "z"]}`), os.ModePerm)
+	c.Assert(err, IsNil)
+	var cfg testConfig1
+	err = ReadFiles(&cfg, cfgPath, "<flags>")
+	c.Assert(err, IsNil)
+	c.Check(cfg.A, Equals, 42)
+	c.Check(cfg.B, Equals, "x")
+	c.Check(cfg.C, DeepEquals, []string{"y", "z"})
+}
+
+func (s *configFlagsSuite) TestReadFilesAndFlagsConfigAtSupport(c *C) {
+	// test <flags> pseudo file
+	tmpDir := c.MkDir()
+	cfgPath := filepath.Join(tmpDir, "cfg.json")
+	os.Args = []string{"cmd", "-a=42", fmt.Sprintf("-cfg@=%s", cfgPath)}
+	err := ioutil.WriteFile(cfgPath, []byte(`{"b": "x", "c_list": ["y", "z"]}`), os.ModePerm)
+	c.Assert(err, IsNil)
+	var cfg testConfig1
+	err = ReadFiles(&cfg, "<flags>")
+	c.Assert(err, IsNil)
+	c.Check(cfg.A, Equals, 42)
+	c.Check(cfg.B, Equals, "x")
+	c.Check(cfg.C, DeepEquals, []string{"y", "z"})
+}
+
+func (s *configFlagsSuite) TestReadUsingFlagsHelp(c *C) {
+	os.Args = []string{"cmd", "-h"}
+	buf := bytes.NewBufferString("")
+	flag.CommandLine.Init("cmd", flag.ContinueOnError)
+	flag.CommandLine.SetOutput(buf)
+	var cfg testConfig3
+	p := map[string]json.RawMessage{
+		"d": json.RawMessage(`"2s"`),
+	}
+	readUsingFlags(p, reflect.ValueOf(&cfg))
+	c.Check(buf.String(), Matches, `(?s).*-cfg@=<config.json>: get config values from file\n.*-d="2s": duration.*`)
+}
+
+func (s *configFlagsSuite) TestReadUsingFlagsAlreadyParsed(c *C) {
+	os.Args = []string{"cmd"}
+	flag.Parse()
+	var cfg struct{}
+	p := make(map[string]json.RawMessage)
+	err := readUsingFlags(p, reflect.ValueOf(&cfg))
+	c.Assert(err, ErrorMatches, "too late, flags already parsed")
+	err = ReadFiles(&cfg, "<flags>")
+	c.Assert(err, ErrorMatches, "too late, flags already parsed")
+	IgnoreParsedFlags = true
+	defer func() {
+		IgnoreParsedFlags = false
+	}()
+	err = ReadFiles(&cfg, "<flags>")
+	c.Assert(err, IsNil)
+}

=== modified file 'debian/changelog'
--- debian/changelog	2014-04-11 18:31:57 +0000
+++ debian/changelog	2014-04-23 11:53:01 +0000
@@ -1,3 +1,22 @@
+ubuntu-push (0.2.1-0ubuntu1) UNRELEASED; urgency=high
+
+  [ Samuele Pedroni ]
+  * gave the client the ability to get config from commandline
+    ( => easier automated testing) (LP: #1311600)
+
+  [ John Lenton ]
+  * Ensure ubuntu-push-client is the only one running in the session.
+    (LP: #1309432)
+  * Remove supurious numbers in brackets in notifications. (LP: #1308145)
+  * Check the server certificate and server name. (LP: #1297969)
+  * Loop whoopsie_identifier_generate until it starts working. (LP: #1309237)
+  * In the session: set a flag on connect, clear it on successfully
+    replying to ping or broadcast messages, check it at the top of
+    autoredial. Also track the last autoredial, and set the delay flag if
+    autoredial is re-called too quickly. (LP: #1309231)
+
+ -- John Lenton <[e-mail]>  Fri, 18 Apr 2014 10:42:31 +0100
+
 ubuntu-push (0.2+14.04.20140411-0ubuntu1) trusty; urgency=medium
 
   [ John Lenton ]

=== modified file 'logger/logger.go'
--- logger/logger.go	2014-02-24 10:27:38 +0000
+++ logger/logger.go	2014-04-23 11:53:01 +0000
@@ -23,6 +23,8 @@
 	"log"
 	"os"
 	"runtime"
+
+	"launchpad.net/ubuntu-push/config"
 )
 
 // Logger is a simple logger interface with logging at levels.
@@ -119,3 +121,28 @@
 		lg.outputFunc(2, fmt.Sprintf("DEBUG "+format, v...))
 	}
 }
+
+// config bits
+
+// ConfigLogLevel can hold a log level in a configuration struct.
+type ConfigLogLevel string
+
+func (cll *ConfigLogLevel) ConfigFromJSONString() {}
+
+func (cll *ConfigLogLevel) UnmarshalJSON(b []byte) error {
+	return config.UnmarshalJSONViaString(cll, b)
+}
+
+func (cll *ConfigLogLevel) SetFromString(enc string) error {
+	_, ok := levelToNLevel[enc]
+	if !ok {
+		return fmt.Errorf("not a log level: %s", enc)
+	}
+	*cll = ConfigLogLevel(enc)
+	return nil
+}
+
+// Level returns the log level string held in cll.
+func (cll ConfigLogLevel) Level() string {
+	return string(cll)
+}

=== modified file 'logger/logger_test.go'
--- logger/logger_test.go	2014-02-10 22:51:43 +0000
+++ logger/logger_test.go	2014-04-23 11:53:01 +0000
@@ -25,6 +25,8 @@
 	"testing"
 
 	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/config"
 )
 
 func TestLogger(t *testing.T) { TestingT(t) }
@@ -138,3 +140,26 @@
 	logger.Output(1, "foobaz")
 	c.Check(buf.String(), Matches, "logger_test.go:[0-9]+: foobar\nlogger_test.go:[0-9]+: foobaz\n")
 }
+
+type testLogLevelConfig struct {
+	Lvl ConfigLogLevel
+}
+
+func (s *loggerSuite) TestReadConfigLogLevel(c *C) {
+	buf := bytes.NewBufferString(`{"lvl": "debug"}`)
+	var cfg testLogLevelConfig
+	err := config.ReadConfig(buf, &cfg)
+	c.Assert(err, IsNil)
+	c.Check(cfg.Lvl.Level(), Equals, "debug")
+}
+
+func (s *loggerSuite) TestReadConfigLogLevelErrors(c *C) {
+	var cfg testLogLevelConfig
+	checkError := func(jsonCfg string, expectedError string) {
+		buf := bytes.NewBufferString(jsonCfg)
+		err := config.ReadConfig(buf, &cfg)
+		c.Check(err, ErrorMatches, expectedError)
+	}
+	checkError(`{"lvl": 1}`, "lvl:.*type string")
+	checkError(`{"lvl": "foo"}`, "lvl: not a log level: foo")
+}

=== modified file 'server/acceptance/cmd/acceptanceclient.go'
--- server/acceptance/cmd/acceptanceclient.go	2014-04-10 13:52:31 +0000
+++ server/acceptance/cmd/acceptanceclient.go	2014-04-23 11:53:01 +0000
@@ -48,13 +48,18 @@
 		fmt.Fprintf(os.Stderr, "Usage: acceptancclient [options] <config.json> <device id>\n")
 		flag.PrintDefaults()
 	}
+	missingArg := func(what string) {
+		fmt.Fprintf(os.Stderr, "missing %s\n", what)
+		flag.Usage()
+		os.Exit(2)
+	}
 	flag.Parse()
 	narg := flag.NArg()
 	switch {
 	case narg < 1:
-		log.Fatal("missing config file")
+		missingArg("config file")
 	case narg < 2:
-		log.Fatal("missing device-id")
+		missingArg("device-id")
 	}
 	configFName := flag.Arg(0)
 	f, err := os.Open(configFName)

=== modified file 'ubuntu-push-client.go'
--- ubuntu-push-client.go	2014-03-12 13:25:20 +0000
+++ ubuntu-push-client.go	2014-04-23 11:53:01 +0000
@@ -19,12 +19,37 @@
 import (
 	"log"
 
+	"launchpad.net/go-dbus/v1"
 	"launchpad.net/go-xdg/v0"
 
 	"launchpad.net/ubuntu-push/client"
 )
 
+const NAME = "com.ubuntu.PushNotifications"
+
+// grabName grabs ownership of the dbus name, and bails the client as
+// soon as somebody else grabs it.
+func grabName() {
+	conn, err := dbus.Connect(dbus.SessionBus)
+	if err != nil {
+		log.Fatalf("bus: %v", err)
+	}
+
+	flags := dbus.NameFlagAllowReplacement | dbus.NameFlagReplaceExisting
+	n := conn.RequestName(NAME, flags)
+	go func() {
+		for err := range n.C {
+			if err != nil {
+				log.Fatalf("FATAL: name channel got: %v", err)
+			}
+		}
+	}()
+}
+
 func main() {
+	// XXX: this is a quick hack to ensure unicity
+	grabName()
+
 	cfgFname, err := xdg.Config.Find("ubuntu-push-client/config.json")
 	if err != nil {
 		log.Fatalf("unable to find a configuration file: %v", err)

=== modified file 'whoopsie/identifier/identifier.go'
--- whoopsie/identifier/identifier.go	2014-02-21 16:17:28 +0000
+++ whoopsie/identifier/identifier.go	2014-04-23 11:53:01 +0000
@@ -27,6 +27,7 @@
 import "C"
 import "unsafe"
 import "errors"
+import "time"
 
 // an Id knows how to generate itself, and how to stringify itself.
 type Id interface {
@@ -36,12 +37,17 @@
 
 // Identifier is the default Id implementation.
 type Identifier struct {
-	value string
+	value     string
+	generator func(**C.char, **C.GError)
+}
+
+func generator(csp **C.char, errp **C.GError) {
+	C.whoopsie_identifier_generate(csp, errp)
 }
 
 // New creates an Identifier, but does not call Generate() on it.
 func New() Id {
-	return &Identifier{}
+	return &Identifier{generator: generator}
 }
 
 // Generate makes the Identifier create the identifier itself.
@@ -49,8 +55,18 @@
 	var gerr *C.GError
 	var cs *C.char
 	defer C.g_free((C.gpointer)(unsafe.Pointer(cs)))
-	C.whoopsie_identifier_generate(&cs, &gerr)
-
+
+	for i := 0; i < 200; i++ {
+		id.generator(&cs, &gerr)
+
+		if cs != nil || gerr != nil {
+			goto SuccessMaybe
+		}
+		time.Sleep(600 * time.Millisecond)
+	}
+	return errors.New("whoopsie_identifier_generate still bad after 2m; giving up")
+
+SuccessMaybe:
 	if gerr != nil {
 		return errors.New(C.GoString((*C.char)(gerr.message)))
 	} else {

=== modified file 'whoopsie/identifier/identifier_test.go'
--- whoopsie/identifier/identifier_test.go	2014-01-15 15:51:50 +0000
+++ whoopsie/identifier/identifier_test.go	2014-04-23 11:53:01 +0000
@@ -41,3 +41,18 @@
 func (s *IdentifierSuite) TestIdentifierInterface(c *C) {
 	_ = []Id{New()}
 }
+
+// TestFailure checks that Identifier survives whoopsie shenanigans
+func (s *IdentifierSuite) TestIdentifierSurvivesShenanigans(c *C) {
+	count := 0
+	// using _Ctype* as a workaround for gocheck also having a C
+	gen := func(csp **_Ctype_char, errp **_Ctype_GError) {
+		count++
+		if count > 3 {
+			generator(csp, errp)
+		}
+	}
+	id := &Identifier{generator: gen}
+	id.Generate()
+	c.Check(id.String(), HasLen, 128)
+}