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

[John Lenton]

reworked bus.Endpoint to have a Dial() method, added an AutoRedialer() and put the redialing logic in there (for use on sessionbus as well, later).

Reworked bus.Endpoint to have a Dial() method, added an AutoRedialer() and put the redialing logic in there (for use on sessionbus as well, later).

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

24. By John Lenton on 2014-01-23

be less silly for tests

[Samuele Pedroni (pedronis)]

I think the random jitter could be included after 20sec already, also probably it should be optional?

./bus/connectivity/ and /bus/testing run tests twice because of double invoking TestingT

[John Lenton (chipaca)]

Agreed about the jitter on both counts; will come back to it and refactor it a tad once it's been used so I don't miss anything.

Fixing the double-invoking, and the test slowness.

[Samuele Pedroni (pedronis)]

406 + endp.Close()

maybe there should be a defer endp.Close around as well

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

25. By John Lenton on 2014-01-24

made timeouts public, and stomp on them in the tests

[John Lenton (chipaca)]

defer endp.Close around where? Sorry if I'm being obtuse...

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

26. By John Lenton on 2014-01-24

merged trunk

[Samuele Pedroni (pedronis)]

 so here is a commented version of what I was saying: https://pastebin.canonical.com/103599/

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

27. By John Lenton on 2014-01-27

made the jitter something provided by the dialer itself

28. By John Lenton on 2014-01-27

Merged endpoint-not-bus into redialer.

29. By John Lenton on 2014-01-27

merged trunk

30. By John Lenton on 2014-01-27

make Jitter take the base duration as argument

31. By John Lenton on 2014-01-27

made the docs a bit better

[Samuele Pedroni (pedronis)]

review: Approve

=== modified file 'bus/bus.go'
--- bus/bus.go	2014-01-20 19:02:17 +0000
+++ bus/bus.go	2014-01-27 13:02:37 +0000
@@ -31,7 +31,7 @@
 // This is the Bus itself.
 type Bus interface {
 	String() string
-	Connect(Address, logger.Logger) (Endpoint, error)
+	Endpoint(Address, logger.Logger) Endpoint
 }
 
 type concreteBus dbus.StandardBus
@@ -58,13 +58,8 @@
 }
 
 // Connect() connects to the bus, and returns the bus endpoint (and/or error).
-func (bus concreteBus) Connect(addr Address, log logger.Logger) (Endpoint, error) {
-	conn, err := dbus.Connect(bus.dbusType())
-	if err != nil {
-		return nil, err
-	} else {
-		return newEndpoint(conn, addr, log), nil
-	}
+func (bus concreteBus) Endpoint(addr Address, log logger.Logger) Endpoint {
+	return newEndpoint(bus, addr, log)
 }
 
 /*

=== modified file 'bus/bus_test.go'
--- bus/bus_test.go	2014-01-20 12:36:21 +0000
+++ bus/bus_test.go	2014-01-27 13:02:37 +0000
@@ -22,12 +22,11 @@
 	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
 	"launchpad.net/ubuntu-push/logger"
-	"os"
 	"testing"
 )
 
 // hook up gocheck
-func Test(t *testing.T) { TestingT(t) }
+func BusTest(t *testing.T) { TestingT(t) }
 
 type BusSuite struct{}
 
@@ -46,22 +45,8 @@
 	c.Check(SessionBus.(concreteBus).dbusType(), DeepEquals, dbus.SessionBus)
 }
 
-// Tests that we can connect to the *actual* system bus.
-// XXX maybe connect to a mock/fake/etc bus?
-func (s *BusSuite) TestConnect(c *C) {
-	b, err := SystemBus.Connect(Address{"", "", ""}, nullog)
-	c.Assert(err, IsNil)
-	defer b.Close()
-}
-
-// Test that if we try to connect to the session bus when no session
-// bus is available, we get a reasonable result (i.e., an error).
-func (s *BusSuite) TestConnectCanFail(c *C) {
-	db := "DBUS_SESSION_BUS_ADDRESS"
-	odb := os.Getenv(db)
-	defer os.Setenv(db, odb)
-	os.Setenv(db, "")
-
-	_, err := SessionBus.Connect(Address{"", "", ""}, nullog)
-	c.Check(err, NotNil)
+// Tests that we can get an endpoint back
+func (s *BusSuite) TestEndpoint(c *C) {
+	endp := SystemBus.Endpoint(Address{"", "", ""}, nullog)
+	c.Assert(endp, NotNil)
 }

=== modified file 'bus/connectivity/connectivity.go'
--- bus/connectivity/connectivity.go	2014-01-27 13:02:37 +0000
+++ bus/connectivity/connectivity.go	2014-01-27 13:02:37 +0000
@@ -28,14 +28,13 @@
 	"launchpad.net/ubuntu-push/bus/networkmanager"
 	"launchpad.net/ubuntu-push/config"
 	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/util"
 	"time"
 )
 
 // the configuration for ConnectedState, with the idea that you'd populate it
 // from a config file.
 type Config struct {
-	// a list of timeouts, for backoff. Should be roughly doubling.
-	ConnectTimeouts []config.ConfigTimeDuration
 	// how long to wait after a state change to make sure it's "stable"
 	// before acting on it
 	StabilizingTimeout config.ConfigTimeDuration
@@ -51,7 +50,7 @@
 	networkStateCh <-chan networkmanager.State
 	config         Config
 	log            logger.Logger
-	bus            bus.Bus
+	endp           bus.Endpoint
 	connAttempts   uint32
 	webget         func(ch chan<- bool)
 	webgetCh       chan bool
@@ -60,41 +59,19 @@
 	timer          *time.Timer
 }
 
-// implements the logic for connect timeouts backoff
-//
-// (walk the list of timeouts, and repeat the last one until done; cope with
-// the list being empty; keep track of connection attempts).
-func (cs *connectedState) connectTimeout() time.Duration {
-	var timeout config.ConfigTimeDuration
-	timeouts := cs.config.ConnectTimeouts
-	if cs.connAttempts < uint32(len(timeouts)) {
-		timeout = timeouts[cs.connAttempts]
-	} else if len(timeouts) > 0 {
-		timeout = cs.config.ConnectTimeouts[len(timeouts)-1]
-	}
-	cs.connAttempts++
-	return timeout.Duration
-}
-
 // start connects to the bus, gets the initial NetworkManager state, and sets
 // up the watch.
 func (cs *connectedState) start() networkmanager.State {
 	var initial networkmanager.State
 	for {
-		time.Sleep(cs.connectTimeout())
-		cs.log.Debugf("Starting DBus connection attempt %d\n", cs.connAttempts)
-		conn, err := cs.bus.Connect(networkmanager.BusAddress, cs.log)
-		if err != nil {
-			cs.log.Debugf("DBus connection attempt %d failed.\n", cs.connAttempts)
-			continue
-		}
-		nm := networkmanager.New(conn, cs.log)
+		cs.connAttempts += util.AutoRedial(cs.endp)
+		nm := networkmanager.New(cs.endp, cs.log)
 
 		// Get the current state.
 		initial = nm.GetState()
 		if initial == networkmanager.Unknown {
-			cs.log.Debugf("Failed to get state at attempt.")
-			conn.Close()
+			cs.log.Debugf("Failed to get state.")
+			cs.endp.Close()
 			continue
 		}
 
@@ -102,12 +79,11 @@
 		ch, err := nm.WatchState()
 		if err != nil {
 			cs.log.Debugf("Failed to set up the watch: %s", err)
-			conn.Close()
+			cs.endp.Close()
 			continue
 		}
 
 		cs.networkStateCh = ch
-		cs.log.Debugf("worked at attempt %d. Resetting counter.\n", cs.connAttempts)
 		return initial
 	}
 }
@@ -161,12 +137,15 @@
 // ConnectedState sends the initial NetworkManager state and changes to it
 // over the "out" channel. Sends "false" as soon as it detects trouble, "true"
 // after checking actual connectivity.
-func ConnectedState(busType bus.Bus, config Config, log logger.Logger, out chan<- bool) {
+//
+// The endpoint need not be dialed; connectivity will Dial() and Close()
+// it as it sees fit.
+func ConnectedState(endp bus.Endpoint, config Config, log logger.Logger, out chan<- bool) {
 	wg := NewWebchecker(config.ConnectivityCheckURL, config.ConnectivityCheckMD5, log)
 	cs := &connectedState{
 		config: config,
 		log:    log,
-		bus:    busType,
+		endp:   endp,
 		webget: wg.Webcheck,
 	}
 

=== modified file 'bus/connectivity/connectivity_test.go'
--- bus/connectivity/connectivity_test.go	2014-01-27 13:02:37 +0000
+++ bus/connectivity/connectivity_test.go	2014-01-27 13:02:37 +0000
@@ -24,6 +24,7 @@
 	"launchpad.net/ubuntu-push/config"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/testing/condition"
+	"launchpad.net/ubuntu-push/util"
 	"net/http/httptest"
 	"testing"
 	"time"
@@ -32,39 +33,22 @@
 // hook up gocheck
 func Test(t *testing.T) { TestingT(t) }
 
-type ConnSuite struct{}
+type ConnSuite struct {
+	timeouts []time.Duration
+}
 
 var _ = Suite(&ConnSuite{})
 
 var nullog = logger.NewSimpleLogger(ioutil.Discard, "error")
 
-/*
-   tests for connectedState's ConnectTimeout() method
-*/
-
-// When given no timeouts, ConnectTimeout() returns 0 forever
-func (s *ConnSuite) TestConnectTimeoutWorksWithNoTimeouts(c *C) {
-	cs := connectedState{}
-	c.Check(cs.connectTimeout(), Equals, time.Duration(0))
-	c.Check(cs.connectTimeout(), Equals, time.Duration(0))
+func (s *ConnSuite) SetUpSuite(c *C) {
+	s.timeouts = util.Timeouts
+	util.Timeouts = []time.Duration{0, 0, 0, 0}
 }
 
-// when given a few timeouts, ConnectTimeout() returns them each in
-// turn, and then repeats the last one
-func (s *ConnSuite) TestConnectTimeoutWorks(c *C) {
-	ts := []config.ConfigTimeDuration{
-		config.ConfigTimeDuration{0},
-		config.ConfigTimeDuration{2 * time.Second},
-		config.ConfigTimeDuration{time.Second},
-	}
-	cs := connectedState{config: Config{ConnectTimeouts: ts}}
-	c.Check(cs.connectTimeout(), Equals, time.Duration(0))
-	c.Check(cs.connectTimeout(), Equals, 2*time.Second)
-	c.Check(cs.connectTimeout(), Equals, time.Second)
-	c.Check(cs.connectTimeout(), Equals, time.Second)
-	c.Check(cs.connectTimeout(), Equals, time.Second)
-	c.Check(cs.connectTimeout(), Equals, time.Second)
-	// ... ad nauseam
+func (s *ConnSuite) TearDownSuite(c *C) {
+	util.Timeouts = s.timeouts
+	s.timeouts = nil
 }
 
 /*
@@ -73,19 +57,16 @@
 
 // when given a working config and bus, Start() will work
 func (s *ConnSuite) TestStartWorks(c *C) {
-	cfg := Config{}
-	tb := testingbus.NewTestingBus(condition.Work(true), condition.Work(true), uint32(networkmanager.Connecting))
-	cs := connectedState{config: cfg, log: nullog, bus: tb}
+	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(networkmanager.Connecting))
+	cs := connectedState{config: Config{}, log: nullog, endp: endp}
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 }
 
 // if the bus fails a couple of times, we're still OK
 func (s *ConnSuite) TestStartRetriesConnect(c *C) {
-	timeouts := []config.ConfigTimeDuration{config.ConfigTimeDuration{0}}
-	cfg := Config{ConnectTimeouts: timeouts}
-	tb := testingbus.NewTestingBus(condition.Fail2Work(2), condition.Work(true), uint32(networkmanager.Connecting))
-	cs := connectedState{config: cfg, log: nullog, bus: tb}
+	endp := testingbus.NewTestingEndpoint(condition.Fail2Work(2), condition.Work(true), uint32(networkmanager.Connecting))
+	cs := connectedState{config: Config{}, log: nullog, endp: endp}
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 	c.Check(cs.connAttempts, Equals, uint32(3)) // 1 more than the Fail2Work
@@ -93,9 +74,8 @@
 
 // when the calls to NetworkManager fail for a bit, we're still OK
 func (s *ConnSuite) TestStartRetriesCall(c *C) {
-	cfg := Config{}
-	tb := testingbus.NewTestingBus(condition.Work(true), condition.Fail2Work(5), uint32(networkmanager.Connecting))
-	cs := connectedState{config: cfg, log: nullog, bus: tb}
+	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Fail2Work(5), uint32(networkmanager.Connecting))
+	cs := connectedState{config: Config{}, log: nullog, endp: endp}
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 
@@ -110,11 +90,10 @@
 		1, condition.Work(true), // 1 call to nm works
 		1, condition.Work(false), // 1 call to nm fails
 		0, condition.Work(true)) // and everything works from there on
-	cfg := Config{}
-	tb := testingbus.NewTestingBus(condition.Work(true), nmcond,
+	endp := testingbus.NewTestingEndpoint(condition.Work(true), nmcond,
 		uint32(networkmanager.Connecting),
 		uint32(networkmanager.ConnectedGlobal))
-	cs := connectedState{config: cfg, log: nullog, bus: tb}
+	cs := connectedState{config: Config{}, log: nullog, endp: endp}
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 	c.Check(cs.connAttempts, Equals, uint32(2))
@@ -211,7 +190,7 @@
 		RecheckTimeout:       config.ConfigTimeDuration{time.Second},
 	}
 
-	busType := testingbus.NewTestingBus(condition.Work(true), condition.Work(true),
+	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Work(true),
 		uint32(networkmanager.ConnectedGlobal),
 		uint32(networkmanager.ConnectedGlobal),
 		uint32(networkmanager.Disconnected),
@@ -220,7 +199,7 @@
 	out := make(chan bool)
 	dt := time.Second / 10
 	timer := time.NewTimer(dt)
-	go ConnectedState(busType, cfg, nullog, out)
+	go ConnectedState(endp, cfg, nullog, out)
 	var v bool
 	expecteds := []bool{
 		false, // first state is always false

=== modified file 'bus/connectivity/webchecker_test.go'
--- bus/connectivity/webchecker_test.go	2014-01-27 13:02:37 +0000
+++ bus/connectivity/webchecker_test.go	2014-01-27 13:02:37 +0000
@@ -18,15 +18,15 @@
 
 import (
 	. "launchpad.net/gocheck"
+	"launchpad.net/ubuntu-push/util"
 	"net/http"
 	"net/http/httptest"
-	"testing"
+	"time"
 )
 
-// hook up gocheck
-func TestWebcheck(t *testing.T) { TestingT(t) }
-
-type WebcheckerSuite struct{}
+type WebcheckerSuite struct {
+	timeouts []time.Duration
+}
 
 var _ = Suite(&WebcheckerSuite{})
 
@@ -60,6 +60,16 @@
 	}
 }
 
+func (s *WebcheckerSuite) SetUpSuite(c *C) {
+	s.timeouts = util.Timeouts
+	util.Timeouts = []time.Duration{0}
+}
+
+func (s *WebcheckerSuite) TearDownSuite(c *C) {
+	util.Timeouts = s.timeouts
+	s.timeouts = nil
+}
+
 // Webchecker sends true when everything works
 func (s *WebcheckerSuite) TestWorks(c *C) {
 	ts := httptest.NewServer(mkHandler(staticText))

=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2014-01-23 00:21:38 +0000
+++ bus/endpoint.go	2014-01-27 13:02:37 +0000
@@ -22,6 +22,7 @@
 	"fmt"
 	"launchpad.net/go-dbus/v1"
 	"launchpad.net/ubuntu-push/logger"
+	"time"
 )
 
 /*****************************************************************
@@ -33,25 +34,23 @@
 	WatchSignal(member string, f func(...interface{}), d func()) error
 	Call(member string, args ...interface{}) ([]interface{}, error)
 	GetProperty(property string) (interface{}, error)
+	Dial() error
 	Close()
+	String() string
+	Jitter(time.Duration) time.Duration
 }
 
 type endpoint struct {
+	busT  Bus
 	bus   *dbus.Connection
 	proxy *dbus.ObjectProxy
-	iface string
+	addr  Address
 	log   logger.Logger
 }
 
 // constructor
-func newEndpoint(bus *dbus.Connection, addr Address, log logger.Logger) *endpoint {
-	endp := new(endpoint)
-	endp.bus = bus
-	endp.proxy = bus.Object(addr.Name, dbus.ObjectPath(addr.Path))
-	endp.iface = addr.Interface
-	endp.log = log
-
-	return endp
+func newEndpoint(bus Bus, addr Address, log logger.Logger) *endpoint {
+	return &endpoint{busT: bus, addr: addr, log: log}
 }
 
 // ensure endpoint implements Endpoint
@@ -61,13 +60,24 @@
    public methods
 */
 
+// Dial() (re)establishes the connection with dbus
+func (endp *endpoint) Dial() error {
+	bus, err := dbus.Connect(endp.busT.(concreteBus).dbusType())
+	if err != nil {
+		return err
+	}
+	endp.bus = bus
+	endp.proxy = bus.Object(endp.addr.Name, dbus.ObjectPath(endp.addr.Path))
+	return nil
+}
+
 // WatchSignal() takes a member name and sets up a watch for it (on the name,
 // path and interface provided when creating the endpoint), and then calls f()
 // with the unpacked value. If it's unable to set up the watch it'll return an
 // error. If the watch fails once established, d() is called. Typically f()
 // sends the values over a channel, and d() would close the channel.
 func (endp *endpoint) WatchSignal(member string, f func(...interface{}), d func()) error {
-	watch, err := endp.proxy.WatchSignal(endp.iface, member)
+	watch, err := endp.proxy.WatchSignal(endp.addr.Interface, member)
 	if err != nil {
 		endp.log.Debugf("Failed to set up the watch: %s", err)
 		return err
@@ -82,7 +92,7 @@
 // provided when creating the endpoint). The return value is unpacked before
 // being returned.
 func (endp *endpoint) Call(member string, args ...interface{}) ([]interface{}, error) {
-	msg, err := endp.proxy.Call(endp.iface, member, args...)
+	msg, err := endp.proxy.Call(endp.addr.Interface, member, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -95,7 +105,7 @@
 // creating the endpoint. The return value is unpacked into a dbus.Variant,
 // and its value returned.
 func (endp *endpoint) GetProperty(property string) (interface{}, error) {
-	msg, err := endp.proxy.Call("org.freedesktop.DBus.Properties", "Get", endp.iface, property)
+	msg, err := endp.proxy.Call("org.freedesktop.DBus.Properties", "Get", endp.addr.Interface, property)
 	if err != nil {
 		return nil, err
 	}
@@ -118,6 +128,18 @@
 // Close the connection to dbus.
 func (endp *endpoint) Close() {
 	endp.bus.Close()
+	endp.bus = nil
+	endp.proxy = nil
+}
+
+// String() performs advanced endpoint stringification
+func (endp *endpoint) String() string {
+	return fmt.Sprintf("<Connection to %s %#v>", endp.bus, endp.addr)
+}
+
+// Jitter() returns 0: no need to jitter D-Bus connections.
+func (endp *endpoint) Jitter(_ time.Duration) time.Duration {
+	return 0
 }
 
 /*

=== modified file 'bus/endpoint_test.go'
--- bus/endpoint_test.go	2014-01-20 13:45:30 +0000
+++ bus/endpoint_test.go	2014-01-27 13:02:37 +0000
@@ -18,6 +18,7 @@
 
 import (
 	. "launchpad.net/gocheck"
+	"os"
 	"testing"
 )
 
@@ -30,3 +31,29 @@
 
 // TODO: this is going to remain empty until go-dbus grows some
 // testing amenities (already talked about it with jamesh)
+
+// Tests that we can connect to the *actual* system bus.
+// XXX maybe connect to a mock/fake/etc bus?
+func (s *BusSuite) TestDial(c *C) {
+	endp := newEndpoint(SystemBus, Address{"", "", ""}, nullog)
+	c.Assert(endp.bus, IsNil)
+	err := endp.Dial()
+	c.Assert(err, IsNil)
+	defer endp.Close() // yes, a second close. On purpose.
+	c.Assert(endp.bus, NotNil)
+	endp.Close()              // the first close. If you're counting right.
+	c.Assert(endp.bus, IsNil) // Close cleans up
+}
+
+// Test that if we try to connect to the session bus when no session
+// bus is available, we get a reasonable result (i.e., an error).
+func (s *BusSuite) TestDialCanFail(c *C) {
+	db := "DBUS_SESSION_BUS_ADDRESS"
+	odb := os.Getenv(db)
+	defer os.Setenv(db, odb)
+	os.Setenv(db, "")
+
+	endp := newEndpoint(SessionBus, Address{"", "", ""}, nullog)
+	err := endp.Dial()
+	c.Check(err, NotNil)
+}

=== modified file 'bus/networkmanager/networkmanager_test.go'
--- bus/networkmanager/networkmanager_test.go	2014-01-23 00:21:38 +0000
+++ bus/networkmanager/networkmanager_test.go	2014-01-27 13:02:37 +0000
@@ -47,41 +47,41 @@
 
 // TestNew doesn't test much at all. If this fails, all is wrong in the world.
 func (s *NMSuite) TestNew(c *C) {
-	nm := New(testingbus.NewTestingEndpoint(condition.Work(true)), nullog)
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(true)), nullog)
 	c.Check(nm, NotNil)
 }
 
 // GetState returns the right state when everything works
 func (s *NMSuite) TestGetState(c *C) {
-	nm := New(testingbus.NewTestingEndpoint(condition.Work(true), uint32(ConnectedGlobal)), nullog)
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), uint32(ConnectedGlobal)), nullog)
 	state := nm.GetState()
 	c.Check(state, Equals, ConnectedGlobal)
 }
 
 // GetState returns the right state when dbus fails
 func (s *NMSuite) TestGetStateFail(c *C) {
-	nm := New(testingbus.NewTestingEndpoint(condition.Work(false), uint32(ConnectedGlobal)), nullog)
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false), uint32(ConnectedGlobal)), nullog)
 	state := nm.GetState()
 	c.Check(state, Equals, Unknown)
 }
 
 // GetState returns the right state when dbus works but delivers rubbish values
 func (s *NMSuite) TestGetStateRubbishValues(c *C) {
-	nm := New(testingbus.NewTestingEndpoint(condition.Work(false), 42), nullog)
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false), 42), nullog)
 	state := nm.GetState()
 	c.Check(state, Equals, Unknown)
 }
 
 // GetState returns the right state when dbus works but delivers a rubbish structure
 func (s *NMSuite) TestGetStateRubbishStructure(c *C) {
-	nm := New(testingbus.NewMultiValuedTestingEndpoint(condition.Work(true), []interface{}{}), nullog)
+	nm := New(testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{}), nullog)
 	state := nm.GetState()
 	c.Check(state, Equals, Unknown)
 }
 
 // WatchState sends a stream of States over the channel
 func (s *NMSuite) TestWatchState(c *C) {
-	tc := testingbus.NewTestingEndpoint(condition.Work(true), uint32(Unknown), uint32(Asleep), uint32(ConnectedGlobal))
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), uint32(Unknown), uint32(Asleep), uint32(ConnectedGlobal))
 	nm := New(tc, nullog)
 	ch, err := nm.WatchState()
 	c.Check(err, IsNil)
@@ -91,14 +91,14 @@
 
 // WatchState returns on error if the dbus call fails
 func (s *NMSuite) TestWatchStateFails(c *C) {
-	nm := New(testingbus.NewTestingEndpoint(condition.Work(false)), nullog)
+	nm := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), nullog)
 	_, err := nm.WatchState()
 	c.Check(err, NotNil)
 }
 
 // WatchState calls close on its channel when the watch bails
 func (s *NMSuite) TestWatchClosesOnWatchBail(c *C) {
-	tc := testingbus.NewTestingEndpoint(condition.Work(true))
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true))
 	nm := New(tc, nullog)
 	ch, err := nm.WatchState()
 	c.Check(err, IsNil)

=== modified file 'bus/notifications/raw_test.go'
--- bus/notifications/raw_test.go	2014-01-27 13:02:37 +0000
+++ bus/notifications/raw_test.go	2014-01-27 13:02:37 +0000
@@ -39,7 +39,7 @@
 var nullog = logger.NewSimpleLogger(ioutil.Discard, "error")
 
 func (s *RawSuite) TestNotifies(c *C) {
-	endp := testibus.NewTestingEndpoint(condition.Work(true), uint32(1))
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(true), uint32(1))
 	raw := Raw(endp, nullog)
 	nid, err := raw.Notify("", 0, "", "", "", nil, nil, 0)
 	c.Check(err, IsNil)
@@ -47,21 +47,21 @@
 }
 
 func (s *RawSuite) TestNotifiesFails(c *C) {
-	endp := testibus.NewTestingEndpoint(condition.Work(false))
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
 	raw := Raw(endp, nullog)
 	_, err := raw.Notify("", 0, "", "", "", nil, nil, 0)
 	c.Check(err, NotNil)
 }
 
 func (s *RawSuite) TestNotifiesFailsWeirdly(c *C) {
-	endp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true), []interface{}{1, 2})
+	endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{1, 2})
 	raw := Raw(endp, nullog)
 	_, err := raw.Notify("", 0, "", "", "", nil, nil, 0)
 	c.Check(err, NotNil)
 }
 
 func (s *RawSuite) TestWatchActions(c *C) {
-	endp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true),
+	endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true),
 		[]interface{}{uint32(1), "hello"})
 	raw := Raw(endp, nullog)
 	ch, err := raw.WatchActions()
@@ -80,7 +80,7 @@
 }
 
 func (s *RawSuite) TestWatchActionsFails(c *C) {
-	endp := testibus.NewTestingEndpoint(condition.Work(false))
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
 	raw := Raw(endp, nullog)
 	_, err := raw.WatchActions()
 	c.Check(err, NotNil)

=== modified file 'bus/testing/testing_bus.go'
--- bus/testing/testing_bus.go	2014-01-21 13:21:19 +0000
+++ bus/testing/testing_bus.go	2014-01-27 13:02:37 +0000
@@ -21,7 +21,6 @@
 // Here, the bus.Bus implementation.
 
 import (
-	"errors"
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/testing/condition"
@@ -32,22 +31,21 @@
  */
 
 type testingBus struct {
-	TestCond condition.Interface
-	TestEndp bus.Endpoint
+	endp bus.Endpoint
 }
 
 // Build a bus.Bus that takes a condition to determine whether it should work,
 // as well as a condition and series of return values for the testing
 // bus.Endpoint it builds.
-func NewTestingBus(clientTC condition.Interface, busTC condition.Interface, retvals ...interface{}) bus.Bus {
-	return &testingBus{clientTC, NewTestingEndpoint(busTC, retvals...)}
+func NewTestingBus(dialTC condition.Interface, callTC condition.Interface, retvals ...interface{}) bus.Bus {
+	return &testingBus{NewTestingEndpoint(dialTC, callTC, retvals...)}
 }
 
 // Build a bus.Bus that takes a condition to determine whether it should work,
 // as well as a condition and a series of lists of return values for the
 // testing bus.Endpoint it builds.
-func NewMultiValuedTestingBus(clientTC condition.Interface, busTC condition.Interface, retvalses ...[]interface{}) bus.Bus {
-	return &testingBus{clientTC, NewMultiValuedTestingEndpoint(busTC, retvalses...)}
+func NewMultiValuedTestingBus(dialTC condition.Interface, callTC condition.Interface, retvalses ...[]interface{}) bus.Bus {
+	return &testingBus{NewMultiValuedTestingEndpoint(dialTC, callTC, retvalses...)}
 }
 
 // ensure testingBus implements bus.Interface
@@ -57,12 +55,8 @@
    public methods
 */
 
-func (tb *testingBus) Connect(info bus.Address, log logger.Logger) (bus.Endpoint, error) {
-	if tb.TestCond.OK() {
-		return tb.TestEndp, nil
-	} else {
-		return nil, errors.New(tb.TestCond.String())
-	}
+func (tb *testingBus) Endpoint(info bus.Address, log logger.Logger) bus.Endpoint {
+	return tb.endp
 }
 
 func (tb *testingBus) String() string {

=== modified file 'bus/testing/testing_bus_test.go'
--- bus/testing/testing_bus_test.go	2014-01-21 13:38:03 +0000
+++ bus/testing/testing_bus_test.go	2014-01-27 13:02:37 +0000
@@ -30,46 +30,40 @@
 
 var _ = Suite(&TestingBusSuite{})
 
-// Test Connect() on a working bus returns an endpoint that looks right
-func (s *TestingBusSuite) TestConnectWorks(c *C) {
+// Test Endpoint() on a working bus returns an endpoint that looks right
+func (s *TestingBusSuite) TestEndpointWorks(c *C) {
 	addr := bus.Address{"", "", ""}
 	tb := NewTestingBus(condition.Work(true), condition.Work(false), 42, 42, 42)
-	endp, err := tb.Connect(addr, nil)
+	endp := tb.Endpoint(addr, nil)
+	err := endp.Dial()
 	c.Check(err, IsNil)
-	c.Check(endp, FitsTypeOf, &testingEndpoint{})
-	c.Check(endp.(*testingEndpoint).cond.OK(), Equals, false)
+	c.Assert(endp, FitsTypeOf, &testingEndpoint{})
+	c.Check(endp.(*testingEndpoint).callCond.OK(), Equals, false)
 	c.Check(endp.(*testingEndpoint).retvals, HasLen, 3)
 }
 
-// Test Connect() on a working "multi-valued" bus returns an endpoint that looks right
-func (s *TestingBusSuite) TestConnectMultiValued(c *C) {
+// Test Endpoint() on a working "multi-valued" bus returns an endpoint that looks right
+func (s *TestingBusSuite) TestEndpointMultiValued(c *C) {
 	addr := bus.Address{"", "", ""}
 	tb := NewMultiValuedTestingBus(condition.Work(true), condition.Work(true),
 		[]interface{}{42, 17},
 		[]interface{}{42, 17, 13},
 		[]interface{}{42},
 	)
-	endpp, err := tb.Connect(addr, nil)
+	endpp := tb.Endpoint(addr, nil)
+	err := endpp.Dial()
 	c.Check(err, IsNil)
 	endp, ok := endpp.(*testingEndpoint)
-	c.Check(ok, Equals, true)
-	c.Check(endp.cond.OK(), Equals, true)
+	c.Assert(ok, Equals, true)
+	c.Check(endp.callCond.OK(), Equals, true)
 	c.Assert(endp.retvals, HasLen, 3)
 	c.Check(endp.retvals[0], HasLen, 2)
 	c.Check(endp.retvals[1], HasLen, 3)
 	c.Check(endp.retvals[2], HasLen, 1)
 }
 
-// Test Connect() with a non-working bus fails
-func (s *TestingBusSuite) TestConnectNoWork(c *C) {
-	addr := bus.Address{"", "", ""}
-	tb := NewTestingBus(condition.Work(false), condition.Work(true))
-	_, err := tb.Connect(addr, nil)
-	c.Check(err, NotNil)
-}
-
 // Test TestingBus stringifies sanely
 func (s *TestingBusSuite) TestStringifyBus(c *C) {
-	tb := NewTestingBus(condition.Work(false), condition.Work(true))
+	tb := NewTestingBus(nil, nil)
 	c.Check(tb.String(), Matches, ".*TestingBus.*")
 }

=== modified file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	2014-01-27 10:26:34 +0000
+++ bus/testing/testing_endpoint.go	2014-01-27 13:02:37 +0000
@@ -20,14 +20,16 @@
 
 import (
 	"errors"
+	"fmt"
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/testing/condition"
 	"time"
 )
 
 type testingEndpoint struct {
-	cond    condition.Interface
-	retvals [][]interface{}
+	dialCond condition.Interface
+	callCond condition.Interface
+	retvals  [][]interface{}
 }
 
 // Build a bus.Endpoint that calls OK() on its condition before returning
@@ -35,22 +37,22 @@
 //
 // NOTE: Call() always returns the first return value; Watch() will provide
 // each of them in turn, irrespective of whether Call has been called.
-func NewMultiValuedTestingEndpoint(cond condition.Interface, retvalses ...[]interface{}) bus.Endpoint {
-	return &testingEndpoint{cond, retvalses}
+func NewMultiValuedTestingEndpoint(dialCond condition.Interface, callCond condition.Interface, retvalses ...[]interface{}) bus.Endpoint {
+	return &testingEndpoint{dialCond, callCond, retvalses}
 }
 
-func NewTestingEndpoint(cond condition.Interface, retvals ...interface{}) bus.Endpoint {
+func NewTestingEndpoint(dialCond condition.Interface, callCond condition.Interface, retvals ...interface{}) bus.Endpoint {
 	retvalses := make([][]interface{}, len(retvals))
 	for i, x := range retvals {
 		retvalses[i] = []interface{}{x}
 	}
-	return &testingEndpoint{cond, retvalses}
+	return &testingEndpoint{dialCond, callCond, retvalses}
 }
 
 // See Endpoint's WatchSignal. This WatchSignal will check its condition to
 // decide whether to return an error, or provide each of its return values
 func (tc *testingEndpoint) WatchSignal(member string, f func(...interface{}), d func()) error {
-	if tc.cond.OK() {
+	if tc.callCond.OK() {
 		go func() {
 			for _, v := range tc.retvals {
 				f(v...)
@@ -67,7 +69,7 @@
 // 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) {
-	if tc.cond.OK() {
+	if tc.callCond.OK() {
 		if len(tc.retvals) == 0 {
 			panic("No return values provided!")
 		}
@@ -90,8 +92,27 @@
 	return rvs[0], err
 }
 
+// See Endpoint's Dial. This one will check its dialCondition to
+// decide whether to return an error or not.
+func (endp *testingEndpoint) Dial() error {
+	if endp.dialCond.OK() {
+		return nil
+	} else {
+		return errors.New("dialCond said No.")
+	}
+}
+
+// Advanced stringifobabulation
+func (endp *testingEndpoint) String() string {
+	return fmt.Sprintf("&testingEndpoint{dialCond:(%s) callCond:(%s) retvals:(%#v)",
+		endp.dialCond, endp.callCond, endp.retvals)
+}
+
 // see Endpoint's Close. This one does nothing.
 func (tc *testingEndpoint) Close() {}
 
+// see Endpoint's Jitter.
+func (tc *testingEndpoint) Jitter(_ time.Duration) time.Duration { return 0 }
+
 // ensure testingEndpoint implements bus.Endpoint
 var _ bus.Endpoint = &testingEndpoint{}

=== modified file 'bus/testing/testing_endpoint_test.go'
--- bus/testing/testing_endpoint_test.go	2014-01-23 00:21:38 +0000
+++ bus/testing/testing_endpoint_test.go	2014-01-27 13:02:37 +0000
@@ -20,6 +20,7 @@
 	. "launchpad.net/gocheck"
 	"launchpad.net/ubuntu-push/testing/condition"
 	"testing"
+	"time"
 )
 
 // hook up gocheck
@@ -33,7 +34,7 @@
 // provided, as advertised.
 func (s *TestingEndpointSuite) TestCallReturnsFirstRetval(c *C) {
 	var m, n uint32 = 42, 17
-	endp := NewTestingEndpoint(condition.Work(true), m, n)
+	endp := NewTestingEndpoint(nil, condition.Work(true), m, n)
 	vs, e := endp.Call("what")
 	c.Check(e, IsNil)
 	c.Check(vs, HasLen, 1)
@@ -43,7 +44,7 @@
 // Test the same Call() but with multi-valued endpoint
 func (s *TestingEndpointSuite) TestMultiValuedCall(c *C) {
 	var m, n uint32 = 42, 17
-	endp := NewMultiValuedTestingEndpoint(condition.Work(true), []interface{}{m}, []interface{}{n})
+	endp := NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{m}, []interface{}{n})
 	vs, e := endp.Call("what")
 	c.Check(e, IsNil)
 	c.Check(vs, HasLen, 1)
@@ -52,7 +53,7 @@
 
 // Test that Call() with a negative condition returns an error.
 func (s *TestingEndpointSuite) TestCallFails(c *C) {
-	endp := NewTestingEndpoint(condition.Work(false))
+	endp := NewTestingEndpoint(nil, condition.Work(false))
 	_, e := endp.Call("what")
 	c.Check(e, NotNil)
 }
@@ -60,7 +61,7 @@
 // Test that Call() with a positive condition and no return values panics with
 // a helpful message.
 func (s *TestingEndpointSuite) TestCallPanicsWithNiceMessage(c *C) {
-	endp := NewTestingEndpoint(condition.Work(true))
+	endp := NewTestingEndpoint(nil, condition.Work(true))
 	c.Check(func() { endp.Call("") }, PanicMatches, "No return values provided.*")
 }
 
@@ -68,7 +69,7 @@
 // values over the channel.
 func (s *TestingEndpointSuite) TestWatch(c *C) {
 	var m, n uint32 = 42, 17
-	endp := NewTestingEndpoint(condition.Work(true), m, n)
+	endp := NewTestingEndpoint(nil, condition.Work(true), m, n)
 	ch := make(chan uint32)
 	e := endp.WatchSignal("what", func(us ...interface{}) { ch <- us[0].(uint32) }, func() { close(ch) })
 	c.Check(e, IsNil)
@@ -78,7 +79,7 @@
 
 // Test that WatchSignal() calls the destructor callback when it runs out values
 func (s *TestingEndpointSuite) TestWatchDestructor(c *C) {
-	endp := NewTestingEndpoint(condition.Work(true))
+	endp := NewTestingEndpoint(nil, condition.Work(true))
 	ch := make(chan uint32)
 	e := endp.WatchSignal("what", func(us ...interface{}) {}, func() { close(ch) })
 	c.Check(e, IsNil)
@@ -88,14 +89,14 @@
 
 // Test the endpoint can be closed
 func (s *TestingEndpointSuite) TestCloser(c *C) {
-	endp := NewTestingEndpoint(condition.Work(true))
+	endp := NewTestingEndpoint(nil, condition.Work(true))
 	endp.Close()
 	// ... yay?
 }
 
 // Test that WatchSignal() with a negative condition returns an error.
 func (s *TestingEndpointSuite) TestWatchFails(c *C) {
-	endp := NewTestingEndpoint(condition.Work(false))
+	endp := NewTestingEndpoint(nil, condition.Work(false))
 	e := endp.WatchSignal("what", func(us ...interface{}) {}, func() {})
 	c.Check(e, NotNil)
 }
@@ -103,8 +104,41 @@
 // Tests that GetProperty() works
 func (s *TestingEndpointSuite) TestGetProperty(c *C) {
 	var m uint32 = 42
-	endp := NewTestingEndpoint(condition.Work(true), m)
+	endp := NewTestingEndpoint(nil, condition.Work(true), m)
 	v, e := endp.GetProperty("what")
 	c.Check(e, IsNil)
 	c.Check(v, Equals, m)
 }
+
+// Tests that GetProperty() fails, too
+func (s *TestingEndpointSuite) TestGetPropertyFails(c *C) {
+	endp := NewTestingEndpoint(nil, condition.Work(false))
+	_, e := endp.GetProperty("what")
+	c.Check(e, NotNil)
+}
+
+// Tests that GetProperty() also fails if it's fed garbage
+func (s *TestingEndpointSuite) TestGetPropertyFailsGargling(c *C) {
+	endp := NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{})
+	_, e := endp.GetProperty("what")
+	c.Check(e, NotNil)
+}
+
+// Test Dial() with a non-working bus fails
+func (s *TestingBusSuite) TestDialNoWork(c *C) {
+	endp := NewTestingEndpoint(condition.Work(false), nil)
+	err := endp.Dial()
+	c.Check(err, NotNil)
+}
+
+// Test testingEndpoints serialize, more or less
+func (s *TestingBusSuite) TestEndpointString(c *C) {
+	endp := NewTestingEndpoint(condition.Fail2Work(2), nil, "hello there")
+	c.Check(endp.String(), Matches, ".*Still Broken.*hello there.*")
+}
+
+// Test testingEndpoints have no jitters
+func (s *TestingBusSuite) TestEndpointJitter(c *C) {
+	endp := NewTestingEndpoint(nil, nil)
+	c.Check(endp.Jitter(time.Duration(42)), Equals, time.Duration(0))
+}

=== modified file 'bus/urldispatcher/urldispatcher_test.go'
--- bus/urldispatcher/urldispatcher_test.go	2014-01-27 13:02:37 +0000
+++ bus/urldispatcher/urldispatcher_test.go	2014-01-27 13:02:37 +0000
@@ -35,14 +35,14 @@
 var nullog = logger.NewSimpleLogger(ioutil.Discard, "error")
 
 func (s *UDSuite) TestWorks(c *C) {
-	endp := testibus.NewMultiValuedTestingEndpoint(condition.Work(true), []interface{}{})
+	endp := testibus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{})
 	ud := New(endp, nullog)
 	err := ud.DispatchURL("this")
 	c.Check(err, IsNil)
 }
 
 func (s *UDSuite) TestFailsIfCallFails(c *C) {
-	endp := testibus.NewTestingEndpoint(condition.Work(false))
+	endp := testibus.NewTestingEndpoint(nil, condition.Work(false))
 	ud := New(endp, nullog)
 	err := ud.DispatchURL("this")
 	c.Check(err, NotNil)

=== added directory 'util'
=== added file 'util/redialer.go'
--- util/redialer.go	1970-01-01 00:00:00 +0000
+++ util/redialer.go	2014-01-27 13:02:37 +0000
@@ -0,0 +1,86 @@
+/*
+ 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 util
+
+import (
+	"math/rand"
+	"time"
+)
+
+// A Dialer is an object that knows how to establish a connection, and
+// where you'd usually want some kind of back off if that connection
+// fails.
+type Dialer interface {
+	Dial() error
+	String() string
+	Jitter(time.Duration) time.Duration
+}
+
+// The timeouts used during backoff. While this is public, you'd
+// usually not need to meddle with it.
+var Timeouts []time.Duration
+
+var ( //  for use in testing
+	quitRedialing chan bool = make(chan bool)
+)
+
+// Jitter returns a random time.Duration somewhere in [-spread, spread].
+//
+// This is meant as a default implementation for Dialers to use if wanted.
+func Jitter(spread time.Duration) time.Duration {
+	if spread < 0 {
+		panic("spread must be non-negative")
+	}
+	n := int64(spread)
+	return time.Duration(rand.Int63n(2*n+1) - n)
+}
+
+// AutoRedialer takes a Dialer and retries its Dial() method until it
+// stops returning an error. It does exponential (optionally
+// jitter'ed) backoff.
+func AutoRedial(dialer Dialer) uint32 {
+	var timeout time.Duration
+	var dialAttempts uint32 = 0 // unsigned so it can wrap safely ...
+	var numTimeouts uint32 = uint32(len(Timeouts))
+	for {
+		if dialer.Dial() == nil {
+			return dialAttempts + 1
+		}
+		if dialAttempts < numTimeouts {
+			timeout = Timeouts[dialAttempts]
+		} else {
+			timeout = Timeouts[numTimeouts-1]
+		}
+		timeout += dialer.Jitter(timeout)
+		dialAttempts++
+		select {
+		case <-quitRedialing:
+			return dialAttempts
+		case <-time.NewTimer(timeout).C:
+		}
+	}
+}
+
+func init() {
+	ps := []int{1, 2, 5, 11, 19, 37, 67, 113, 191} // 3 pₙ₊₁ ≥ 5 pₙ
+	Timeouts = make([]time.Duration, len(ps))
+	for i, n := range ps {
+		Timeouts[i] = time.Duration(n) * time.Second
+	}
+
+	rand.Seed(time.Now().Unix()) // good enough for us (not crypto, yadda)
+}

=== added file 'util/redialer_test.go'
--- util/redialer_test.go	1970-01-01 00:00:00 +0000
+++ util/redialer_test.go	2014-01-27 13:02:37 +0000
@@ -0,0 +1,84 @@
+/*
+ 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 util
+
+import (
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	testibus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/testing/condition"
+	"testing"
+	"time"
+)
+
+// hook up gocheck
+func TestRedialer(t *testing.T) { TestingT(t) }
+
+type RedialerSuite struct {
+	timeouts []time.Duration
+}
+
+var nullog = logger.NewSimpleLogger(ioutil.Discard, "error")
+var _ = Suite(&RedialerSuite{})
+
+func (s *RedialerSuite) SetUpSuite(c *C) {
+	s.timeouts = Timeouts
+	Timeouts = []time.Duration{0, 0}
+}
+
+func (s *RedialerSuite) TearDownSuite(c *C) {
+	Timeouts = s.timeouts
+	s.timeouts = nil
+}
+
+func (s *RedialerSuite) TestWorks(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Fail2Work(3), nil)
+	// instead of bus.Dial(), we do AutoRedial(bus)
+	c.Check(AutoRedial(endp), Equals, uint32(4))
+}
+
+func (s *RedialerSuite) TestCanBeStopped(c *C) {
+	endp := testibus.NewTestingEndpoint(condition.Work(false), nil)
+	go func() { c.Check(AutoRedial(endp), Equals, uint32(1)) }()
+	quitRedialing <- true
+}
+
+func (s *RedialerSuite) TestJitter(c *C) {
+	num_tries := 20       // should do the math
+	spread := time.Second //
+	has_neg := false
+	has_pos := false
+	has_zero := true
+	for i := 0; i < num_tries; i++ {
+		n := Jitter(spread)
+		if n > 0 {
+			has_pos = true
+		} else if n < 0 {
+			has_neg = true
+		} else {
+			has_zero = true
+		}
+	}
+	c.Check(has_neg, Equals, true)
+	c.Check(has_pos, Equals, true)
+	c.Check(has_zero, Equals, true)
+
+	// a negative spread is caught in the reasonable place
+	c.Check(func() { Jitter(time.Duration(-1)) }, PanicMatches,
+		"spread must be non-negative")
+}