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

[John Lenton]

A super simple connectivity api (in the "am i connected?" sense)

Complete with a little example program.

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

13. By John Lenton on 2014-01-20

Merged networkmanager into connectivity.

14. By John Lenton on 2014-01-20

Merged networkmanager into connectivity.

15. By John Lenton on 2014-01-20

Merged networkmanager into connectivity.

16. By John Lenton on 2014-01-20

sync up with the changes to the other branches

[Samuele Pedroni (pedronis)]

you can avoid the done flag by:

136 + if cs.lastSent == true {
137 + log.Infof("Sending 'disconnected'.")
138 + cs.lastSent = false
139 + done = true
140 + }
141 + cs.timer.Stop()
142 + cs.webgetC = nil
143 + cs.timer.Reset(stabilizingTimeout)
144 + cs.currentState = v

changing the order of the if to be last, then you can use plain return directly return cs.lastSent, nil

same change would work for the 2nd done = true,

147 + cs.timer.Stop()

no need to stop the timer if it has just triggered

does +func (cs *connectedState) ConnectTimeout() need to be public?

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

17. By John Lenton on 2014-01-20

addressed issues raised by pedronis during peer review

18. By John Lenton on 2014-01-20

renaming a couple more channel names to match /ch$/i

19. By John Lenton on 2014-01-20

aaand forgot to catch a label

[Samuele Pedroni (pedronis)]

review: Approve

=== added directory 'connectivity'
=== added file 'connectivity/connectivity.go'
--- connectivity/connectivity.go	1970-01-01 00:00:00 +0000
+++ connectivity/connectivity.go	2014-01-20 17:45:15 +0000
@@ -0,0 +1,190 @@
+/*
+ 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 connectivity a single, simple stream of booleans to answer
+// the quesiton “are we connected?”.
+//
+// It can potentially fire two falses in a row, if a disconnected
+// state is followed by a dbus watch error. Other than that, it's edge
+// triggered.
+package connectivity
+
+import (
+	"errors"
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/config"
+	"launchpad.net/ubuntu-push/connectivity/webchecker"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/networkmanager"
+	"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
+	// How long to wait between online connectivity checks.
+	RecheckTimeout config.ConfigTimeDuration
+	// The URL against which to do the connectivity check.
+	ConnectivityCheckURL string
+	// The expected MD5 of the content at the ConnectivityCheckURL
+	ConnectivityCheckMD5 string
+}
+
+type connectedState struct {
+	networkStateCh <-chan networkmanager.State
+	config         Config
+	log            logger.Logger
+	bus            bus.Bus
+	connAttempts   uint32
+	webget         func(ch chan<- bool)
+	webgetCh       chan bool
+	currentState   networkmanager.State
+	lastSent       bool
+	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)
+
+		// Get the current state.
+		initial = nm.GetState()
+		if initial == networkmanager.Unknown {
+			cs.log.Debugf("Failed to get state at attempt.")
+			conn.Close()
+			continue
+		}
+
+		// set up the watch
+		ch, err := nm.WatchState()
+		if err != nil {
+			cs.log.Debugf("Failed to set up the watch: %s", err)
+			conn.Close()
+			continue
+		}
+
+		cs.networkStateCh = ch
+		cs.log.Debugf("worked at attempt %d. Resetting counter.\n", cs.connAttempts)
+		return initial
+	}
+}
+
+// connectedStateStep takes one step forwards in the “am I connected?”
+// answering state machine.
+func (cs *connectedState) connectedStateStep() (bool, error) {
+	stabilizingTimeout := cs.config.StabilizingTimeout.Duration
+	recheckTimeout := cs.config.RecheckTimeout.Duration
+	log := cs.log
+
+Loop:
+	for {
+		select {
+		case v, ok := <-cs.networkStateCh:
+			if !ok {
+				// tear it all down and start over
+				return false, errors.New("Got not-OK from StateChanged watch")
+			}
+			cs.webgetCh = nil
+			cs.currentState = v
+			cs.timer.Reset(stabilizingTimeout)
+			log.Debugf("State changed to %s. Assuming disconnect.", v)
+			if cs.lastSent == true {
+				log.Infof("Sending 'disconnected'.")
+				cs.lastSent = false
+				break Loop
+			}
+
+		case <-cs.timer.C:
+			if cs.currentState == networkmanager.ConnectedGlobal {
+				log.Debugf("May be connected; checking...")
+				cs.webgetCh = make(chan bool)
+				go cs.webget(cs.webgetCh)
+			}
+
+		case connected := <-cs.webgetCh:
+			cs.timer.Reset(recheckTimeout)
+			log.Debugf("Connection check says: %t", connected)
+			cs.webgetCh = nil
+			if connected && cs.lastSent == false {
+				log.Infof("Sending 'connected'.")
+				cs.lastSent = true
+				break Loop
+			}
+		}
+	}
+	return cs.lastSent, nil
+}
+
+// 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) {
+	wg := webchecker.New(config.ConnectivityCheckURL, config.ConnectivityCheckMD5, log)
+	cs := &connectedState{
+		config: config,
+		log:    log,
+		bus:    busType,
+		webget: wg.Webcheck,
+	}
+
+Start:
+	log.Infof("Sending initial 'disconnected'.")
+	out <- false
+	cs.lastSent = false
+	cs.currentState = cs.start()
+	cs.timer = time.NewTimer(cs.config.StabilizingTimeout.Duration)
+
+	for {
+		v, err := cs.connectedStateStep()
+		if err != nil {
+			// tear it all down and start over
+			log.Errorf("%s", err)
+			goto Start
+		}
+		out <- v
+	}
+}

=== added file 'connectivity/connectivity_test.go'
--- connectivity/connectivity_test.go	1970-01-01 00:00:00 +0000
+++ connectivity/connectivity_test.go	2014-01-20 17:45:15 +0000
@@ -0,0 +1,266 @@
+/*
+ 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 connectivity
+
+import (
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	testingbus "launchpad.net/ubuntu-push/bus/testing"
+	"launchpad.net/ubuntu-push/config"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/networkmanager"
+	"launchpad.net/ubuntu-push/testing/condition"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+// hook up gocheck
+func Test(t *testing.T) { TestingT(t) }
+
+type ConnSuite struct{}
+
+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))
+}
+
+// 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
+}
+
+/*
+   tests for connectedState's Start() method
+*/
+
+// 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}
+
+	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}
+
+	c.Check(cs.start(), Equals, networkmanager.Connecting)
+	c.Check(cs.connAttempts, Equals, uint32(3)) // 1 more than the Fail2Work
+}
+
+// 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}
+
+	c.Check(cs.start(), Equals, networkmanager.Connecting)
+
+	c.Check(cs.connAttempts, Equals, uint32(6))
+}
+
+// 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.
+func (s *ConnSuite) TestStartRetriesWatch(c *C) {
+	nmcond := condition.Chain(
+		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,
+		uint32(networkmanager.Connecting),
+		uint32(networkmanager.ConnectedGlobal))
+	cs := connectedState{config: cfg, log: nullog, bus: tb}
+
+	c.Check(cs.start(), Equals, networkmanager.Connecting)
+	c.Check(cs.connAttempts, Equals, uint32(2))
+	c.Check(<-cs.networkStateCh, Equals, networkmanager.Connecting)
+	c.Check(<-cs.networkStateCh, Equals, networkmanager.ConnectedGlobal)
+}
+
+/*
+   tests for connectedStateStep()
+*/
+
+func (s *ConnSuite) TestSteps(c *C) {
+	webget_works := func(ch chan<- bool) { ch <- true }
+	webget_fails := func(ch chan<- bool) { ch <- false }
+
+	cfg := Config{
+		RecheckTimeout: config.ConfigTimeDuration{10 * time.Millisecond},
+	}
+	ch := make(chan networkmanager.State, 10)
+	cs := &connectedState{
+		config:         cfg,
+		networkStateCh: ch,
+		timer:          time.NewTimer(time.Second),
+		log:            nullog,
+		webget:         webget_works,
+		lastSent:       false,
+	}
+	ch <- networkmanager.ConnectedGlobal
+	f, e := cs.connectedStateStep()
+	c.Check(e, IsNil)
+	c.Check(f, Equals, true)
+	ch <- networkmanager.ConnectedGlobal // a ConnectedGlobal when connected signals trouble
+	f, e = cs.connectedStateStep()
+	c.Check(e, IsNil)
+	c.Check(f, Equals, false) // so we assume a disconnect happened
+	f, e = cs.connectedStateStep()
+	c.Check(e, IsNil)
+	c.Check(f, Equals, true) // and if the web check works, go back to connected
+
+	// same scenario, but with failing web check
+	cs.webget = webget_fails
+	ch <- networkmanager.ConnectedGlobal
+	f, e = cs.connectedStateStep()
+	c.Check(e, IsNil)
+	c.Check(f, Equals, false) // first false is from assuming a Connected signals trouble
+
+	// the next call to Step will time out
+	_ch := make(chan bool, 1)
+	_t := time.NewTimer(10 * time.Millisecond)
+
+	go func() {
+		f, e := cs.connectedStateStep()
+		c.Check(e, IsNil)
+		_ch <- f
+	}()
+
+	select {
+	case <-_ch:
+		c.Fatal("test failed to timeout")
+	case <-_t.C:
+	}
+
+	// put it back together again
+	cs.webget = webget_works
+	// now an recheckTimeout later, we'll get true
+	c.Check(<-_ch, Equals, true)
+
+	ch <- networkmanager.Disconnected    // this should trigger a 'false'
+	ch <- networkmanager.Disconnected    // this should not
+	ch <- networkmanager.ConnectedGlobal // this should trigger a 'true'
+
+	f, e = cs.connectedStateStep()
+	c.Check(e, IsNil)
+	c.Check(f, Equals, false)
+	f, e = cs.connectedStateStep()
+	c.Check(e, IsNil)
+	c.Check(f, Equals, true)
+
+	close(ch) // this should make it error out
+	_, e = cs.connectedStateStep()
+	c.Check(e, NotNil)
+}
+
+/*
+   tests for ConnectedState()
+*/
+
+// Todo: get rid of duplication between this and webchecker_test
+const (
+	staticText = "something ipsum dolor something"
+	staticHash = "6155f83b471583f47c99998a472a178f"
+)
+
+// mkHandler makes an http.HandlerFunc that returns the provided text
+// for whatever request it's given.
+func mkHandler(text string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.(http.Flusher).Flush()
+		w.Write([]byte(text))
+		w.(http.Flusher).Flush()
+	}
+}
+
+// :oboT
+
+// yes, this is an integration test
+func (s *ConnSuite) TestRun(c *C) {
+	ts := httptest.NewServer(mkHandler(staticText))
+	defer ts.Close()
+
+	cfg := Config{
+		ConnectivityCheckURL: ts.URL,
+		ConnectivityCheckMD5: staticHash,
+		RecheckTimeout:       config.ConfigTimeDuration{time.Second},
+	}
+
+	busType := testingbus.NewTestingBus(condition.Work(true), condition.Work(true),
+		uint32(networkmanager.ConnectedGlobal),
+		uint32(networkmanager.ConnectedGlobal),
+		uint32(networkmanager.Disconnected),
+	)
+
+	out := make(chan bool)
+	dt := time.Second / 10
+	timer := time.NewTimer(dt)
+	go ConnectedState(busType, cfg, nullog, out)
+	var v bool
+	expecteds := []bool{
+		false, // first state is always false
+		true,  // then it should be true as per ConnectedGlobal above
+		false, // then, false (upon receiving the next ConnectedGlobal)
+		true,  // then it should be true (webcheck passed)
+		false, // then it should be false (Disconnected)
+		false, // then it should be false again because it's restarted
+	}
+
+	for i, expected := range expecteds {
+		timer.Reset(dt)
+		select {
+		case v = <-out:
+			break
+		case <-timer.C:
+			c.Fatalf("Timed out before getting value (#%d)", i+1)
+		}
+
+		c.Check(v, Equals, expected)
+	}
+}

=== added directory 'connectivity/example'
=== added file 'connectivity/example/main.go'
--- connectivity/example/main.go	1970-01-01 00:00:00 +0000
+++ connectivity/example/main.go	2014-01-20 17:45:15 +0000
@@ -0,0 +1,54 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// a silly example of the connectivity api
+package main
+
+import (
+	"fmt"
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/config"
+	"launchpad.net/ubuntu-push/connectivity"
+	"launchpad.net/ubuntu-push/logger"
+	"os"
+	"strings"
+)
+
+func main() {
+	log := logger.NewSimpleLogger(os.Stderr, "error")
+
+	paths := []string{"thing.json", "connectivity/example/thing.json"}
+	for _, path := range paths {
+		cff, err := os.Open(path)
+		if err == nil {
+			var cfg connectivity.Config
+			err = config.ReadConfig(cff, &cfg)
+			if err != nil {
+				log.Fatalf("%s", err)
+			}
+
+			ch := make(chan bool)
+			go connectivity.ConnectedState(bus.SystemBus, cfg, log, ch)
+
+			for c := range ch {
+				fmt.Println("Are we connected?", c)
+			}
+			return
+		}
+	}
+	log.Fatalf("Unable to open the config file; tried %s.", strings.Join(paths, ", "))
+
+}

=== added file 'connectivity/example/thing.json'
--- connectivity/example/thing.json	1970-01-01 00:00:00 +0000
+++ connectivity/example/thing.json	2014-01-20 17:45:15 +0000
@@ -0,0 +1,7 @@
+{
+    "connectTimeouts": ["0s", "2s", "3s", "5s", "11s", "19s", "37s", "67s"],
+    "stabilizingTimeout": "2s",
+    "recheckTimeout": "10m",
+    "connectivityCheckURL": "http://start.ubuntu.com/connectivity-check.html",
+    "connectivityCheckMD5": "4589f42e1546aa47ca181e5d949d310b"
+}

=== added directory 'connectivity/webchecker'
=== added file 'connectivity/webchecker/webchecker.go'
--- connectivity/webchecker/webchecker.go	1970-01-01 00:00:00 +0000
+++ connectivity/webchecker/webchecker.go	2014-01-20 17:45:15 +0000
@@ -0,0 +1,80 @@
+/*
+ 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 webchecker checks whether we're actually connected by doing an http
+// GET to the Ubuntu connectivity check URL,
+// http://start.ubuntu.com/connectivity-check.html
+//
+// We could make it be https to make extra doubly sure, but it's expensive
+// overkill for the majority of cases.
+package webchecker
+
+import (
+	"crypto/md5"
+	"fmt"
+	"io"
+	"launchpad.net/ubuntu-push/logger"
+	"net/http"
+)
+
+// how much web would a webchecker check
+
+type Webchecker interface {
+	// Webcheck checks whether retrieving the URL works, and if its
+	// contents match the target. If so, then it sends true; if anything
+	// fails, it sends false.
+	Webcheck(chan<- bool)
+}
+
+type webchecker struct {
+	log    logger.Logger
+	url    string
+	target string
+}
+
+// Build a webchecker for the given URL, that should match the target MD5.
+func New(url string, target string, log logger.Logger) Webchecker {
+	return &webchecker{log, url, target}
+}
+
+// ensure webchecker implements Webchecker
+var _ Webchecker = &webchecker{}
+
+func (wb *webchecker) Webcheck(ch chan<- bool) {
+	response, err := http.Get(wb.url)
+	if err != nil {
+		wb.log.Errorf("While GETting %s: %s", wb.url, err)
+		ch <- false
+		return
+	}
+	defer response.Body.Close()
+	hash := md5.New()
+	_, err = io.CopyN(hash, response.Body, 1024)
+	if err != io.EOF {
+		wb.log.Errorf("Reading %s, expecting EOF, got: %s",
+			wb.url, err)
+		ch <- false
+		return
+	}
+	sum := fmt.Sprintf("%x", hash.Sum(nil))
+	if sum == wb.target {
+		wb.log.Infof("Connectivity check passed.")
+		ch <- true
+	} else {
+		wb.log.Infof("Connectivity check failed: content mismatch.")
+		ch <- false
+	}
+}

=== added file 'connectivity/webchecker/webchecker_test.go'
--- connectivity/webchecker/webchecker_test.go	1970-01-01 00:00:00 +0000
+++ connectivity/webchecker/webchecker_test.go	2014-01-20 17:45:15 +0000
@@ -0,0 +1,106 @@
+/*
+ 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 webchecker
+
+import (
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/ubuntu-push/logger"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// hook up gocheck
+func Test(t *testing.T) { TestingT(t) }
+
+type WebcheckerSuite struct{}
+
+var _ = Suite(&WebcheckerSuite{})
+
+var nullog = logger.NewSimpleLogger(ioutil.Discard, "error")
+
+const (
+	staticText = "something ipsum dolor something"
+	staticHash = "6155f83b471583f47c99998a472a178f"
+	bigText    = `Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+ Vivamus tincidunt vitae sapien tempus fermentum. Cras commodo augue luctu,
+ tempus libero sit amet, laoreet lectus. Vestibulum ali justo et malesuada
+ placerat. Pellentesque viverra luctus velit, adipiscing fermentum tortori
+ vehicula nec. Integer tincidunt purus et pretium vestibulum. Donec portas
+ suscipit pulvinar. Suspendisse potenti. Donec sit amet pharetra nisl, sit
+ amet posuere orci. In feugiat elitist nec augue fringilla, a rutrum risus
+ posuere. Aliquam erat volutpat. Morbi aliquam arcu et eleifend placeraten.
+ Pellentesque egestas varius aliquam. In egestas nisi sed ipsum tristiquer
+ lacinia. Sed vitae nisi non eros consectetur vestibulum vehicularum vitae.
+ Curabitur cursus consectetur eros, in vestibulum turpis cursus at i lorem.
+ Pellentesque ultrices arcu ut massa faucibus, e consequat sapien placerat.
+ Maecenas quis ultricies mi. Phasellus turpis nisl, porttitor ac mi cursus,
+ euismod imperdiet lorem. Donec facilisis est id dignissim imperdiet.`
+	bigHash = "9bf86bce26e8f2d9c9d9bd4a98f9e668"
+)
+
+// mkHandler makes an http.HandlerFunc that returns the provided text
+// for whatever request it's given.
+func mkHandler(text string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.(http.Flusher).Flush()
+		w.Write([]byte(text))
+		w.(http.Flusher).Flush()
+	}
+}
+
+// Webchecker sends true when everything works
+func (s *WebcheckerSuite) TestWorks(c *C) {
+	ts := httptest.NewServer(mkHandler(staticText))
+	defer ts.Close()
+
+	ck := New(ts.URL, staticHash, nullog)
+	ch := make(chan bool, 1)
+	ck.Webcheck(ch)
+	c.Check(<-ch, Equals, true)
+}
+
+// Webchecker sends false if the download fails.
+func (s *WebcheckerSuite) TestActualFails(c *C) {
+	ck := New("garbage://", "", nullog)
+	ch := make(chan bool, 1)
+	ck.Webcheck(ch)
+	c.Check(<-ch, Equals, false)
+}
+
+// Webchecker sends false if the hash doesn't match
+func (s *WebcheckerSuite) TestHashFails(c *C) {
+	ts := httptest.NewServer(mkHandler(""))
+	defer ts.Close()
+
+	ck := New(ts.URL, staticHash, nullog)
+	ch := make(chan bool, 1)
+	ck.Webcheck(ch)
+	c.Check(<-ch, Equals, false)
+}
+
+// Webchecker sends false if the download is too big
+func (s *WebcheckerSuite) TestTooBigFails(c *C) {
+	ts := httptest.NewServer(mkHandler(bigText))
+	defer ts.Close()
+
+	ck := New(ts.URL, bigHash, nullog)
+	ch := make(chan bool, 1)
+	ck.Webcheck(ch)
+	c.Check(<-ch, Equals, false)
+}

=== modified file 'networkmanager/networkmanager.go'
--- networkmanager/networkmanager.go	2014-01-20 13:44:58 +0000
+++ networkmanager/networkmanager.go	2014-01-20 17:45:15 +0000
@@ -53,6 +53,7 @@
 	return &networkManager{endp, log}
 }
 
+// ensure networkManager implements NetworkManager
 var _ NetworkManager = &networkManager{}
 
 /*