Merge lp:~chipaca/ubuntu-push/actual-client-v0 into lp:ubuntu-push

[John Lenton]

v0 of the actual client. Not covered by tests yet.

v0 of the actual client. Not covered by tests yet.

[lp:~chipaca/ubuntu-push/actual-client-v0]

28. By John Lenton on 2014-01-27

moved client config to etc

29. By John Lenton on 2014-01-27

merged pipeline; conflict in the redialer fixed

30. By John Lenton on 2014-01-27

merged trunk, resolved conflict in redialer

[Samuele Pedroni (pedronis)]

I think main is testable if it gets split in some parts

Unmerged revisions

30. By John Lenton on 2014-01-27

merged trunk, resolved conflict in redialer

29. By John Lenton on 2014-01-27

merged pipeline; conflict in the redialer fixed

28. By John Lenton on 2014-01-27

moved client config to etc

=== modified file 'bus/connectivity/connectivity.go'
--- bus/connectivity/connectivity.go	2014-01-23 14:33:08 +0000
+++ bus/connectivity/connectivity.go	2014-01-27 18:11:05 +0000
@@ -34,21 +34,21 @@
 
 // the configuration for ConnectedState, with the idea that you'd populate it
 // from a config file.
-type Config struct {
+type ConnectivityConfig struct {
 	// how long to wait after a state change to make sure it's "stable"
 	// before acting on it
-	StabilizingTimeout config.ConfigTimeDuration
+	StabilizingTimeout config.ConfigTimeDuration `json:"stabilizing_timeout"`
 	// How long to wait between online connectivity checks.
-	RecheckTimeout config.ConfigTimeDuration
+	RecheckTimeout config.ConfigTimeDuration `json:"recheck_timeout"`
 	// The URL against which to do the connectivity check.
-	ConnectivityCheckURL string
+	ConnectivityCheckURL string `json:"connectivity_check_url"`
 	// The expected MD5 of the content at the ConnectivityCheckURL
-	ConnectivityCheckMD5 string
+	ConnectivityCheckMD5 string `json:"connectivity_check_md5"`
 }
 
 type connectedState struct {
 	networkStateCh <-chan networkmanager.State
-	config         Config
+	config         ConnectivityConfig
 	log            logger.Logger
 	endp           bus.Endpoint
 	connAttempts   uint32
@@ -140,7 +140,7 @@
 //
 // 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) {
+func ConnectedState(endp bus.Endpoint, config ConnectivityConfig, log logger.Logger, out chan<- bool) {
 	wg := NewWebchecker(config.ConnectivityCheckURL, config.ConnectivityCheckMD5, log)
 	cs := &connectedState{
 		config: config,
 
=== modified file 'bus/connectivity/connectivity_test.go'
--- bus/connectivity/connectivity_test.go	2014-01-24 14:12:22 +0000
+++ bus/connectivity/connectivity_test.go	2014-01-27 18:11:05 +0000
@@ -58,7 +58,7 @@
 // when given a working config and bus, Start() will work
 func (s *ConnSuite) TestStartWorks(c *C) {
 	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Work(true), uint32(networkmanager.Connecting))
-	cs := connectedState{config: Config{}, log: nullog, endp: endp}
+	cs := connectedState{config: ConnectivityConfig{}, log: nullog, endp: endp}
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 }
@@ -66,7 +66,7 @@
 // if the bus fails a couple of times, we're still OK
 func (s *ConnSuite) TestStartRetriesConnect(c *C) {
 	endp := testingbus.NewTestingEndpoint(condition.Fail2Work(2), condition.Work(true), uint32(networkmanager.Connecting))
-	cs := connectedState{config: Config{}, log: nullog, endp: endp}
+	cs := connectedState{config: ConnectivityConfig{}, log: nullog, endp: endp}
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 	c.Check(cs.connAttempts, Equals, uint32(3)) // 1 more than the Fail2Work
@@ -75,7 +75,7 @@
 // when the calls to NetworkManager fail for a bit, we're still OK
 func (s *ConnSuite) TestStartRetriesCall(c *C) {
 	endp := testingbus.NewTestingEndpoint(condition.Work(true), condition.Fail2Work(5), uint32(networkmanager.Connecting))
-	cs := connectedState{config: Config{}, log: nullog, endp: endp}
+	cs := connectedState{config: ConnectivityConfig{}, log: nullog, endp: endp}
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 
@@ -93,7 +93,7 @@
 	endp := testingbus.NewTestingEndpoint(condition.Work(true), nmcond,
 		uint32(networkmanager.Connecting),
 		uint32(networkmanager.ConnectedGlobal))
-	cs := connectedState{config: Config{}, log: nullog, endp: endp}
+	cs := connectedState{config: ConnectivityConfig{}, log: nullog, endp: endp}
 
 	c.Check(cs.start(), Equals, networkmanager.Connecting)
 	c.Check(cs.connAttempts, Equals, uint32(2))
@@ -109,7 +109,7 @@
 	var webget_p condition.Interface = condition.Work(true)
 	recheck_timeout := 50 * time.Millisecond
 
-	cfg := Config{
+	cfg := ConnectivityConfig{
 		RecheckTimeout: config.ConfigTimeDuration{recheck_timeout},
 	}
 	ch := make(chan networkmanager.State, 10)
@@ -184,7 +184,7 @@
 	ts := httptest.NewServer(mkHandler(staticText))
 	defer ts.Close()
 
-	cfg := Config{
+	cfg := ConnectivityConfig{
 		ConnectivityCheckURL: ts.URL,
 		ConnectivityCheckMD5: staticHash,
 		RecheckTimeout:       config.ConfigTimeDuration{time.Second},
 
=== added file 'client.json'
--- client.json	1970-01-01 00:00:00 +0000
+++ client.json	2014-01-27 18:11:05 +0000
@@ -0,0 +1,9 @@
+{
+    "exchange_timeout": "30s",
+    "addr": ":9090",
+    "cert_pem_file": "server/acceptance/config/testing.cert",
+    "stabilizing_timeout": "2s",
+    "recheck_timeout": "10m",
+    "connectivity_check_url": "http://start.ubuntu.com/connectivity-check.html",
+    "connectivity_check_md5": "4589f42e1546aa47ca181e5d949d310b"
+}
 
=== added file 'client/client.go'
--- client/client.go	1970-01-01 00:00:00 +0000
+++ client/client.go	2014-01-27 18:11:05 +0000
@@ -0,0 +1,141 @@
+package main
+
+import (
+	"launchpad.net/go-dbus/v1"
+	"launchpad.net/ubuntu-push/bus"
+	"launchpad.net/ubuntu-push/bus/connectivity"
+	"launchpad.net/ubuntu-push/bus/networkmanager"
+	"launchpad.net/ubuntu-push/bus/notifications"
+	"launchpad.net/ubuntu-push/bus/urldispatcher"
+	"launchpad.net/ubuntu-push/client/session"
+	"launchpad.net/ubuntu-push/config"
+	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/util"
+	"launchpad.net/ubuntu-push/whoopsie/identifier"
+	"os"
+)
+
+type configuration struct {
+	connectivity.ConnectivityConfig
+	session.ClientConfig
+}
+
+const (
+	configFName string = "/etc/ubuntu-push/client.json"
+)
+
+func notify_update(nots *notifications.RawNotifications, log logger.Logger) {
+	action_id := "my_action_id"
+	a := []string{action_id, "Go get it!"} // action value not visible on the phone
+	h := map[string]*dbus.Variant{"x-canonical-switch-to-application": &dbus.Variant{true}}
+	not_id, err := nots.Notify(
+		"ubuntu-push-client",               // app name
+		uint32(0),                          // id
+		"update_manager_icon",              // icon
+		"There's an updated system image!", // summary
+		"You've got to get it! Now! Run!",  // body
+		a,              // actions
+		h,              // hints
+		int32(10*1000), // timeout
+	)
+	if err != nil {
+		log.Fatalf("%s", err)
+	}
+	log.Debugf("Got notification id %d\n", not_id)
+}
+
+func main() {
+	log := logger.NewSimpleLogger(os.Stderr, "debug")
+	f, err := os.Open(configFName)
+	if err != nil {
+		log.Fatalf("reading config: %v", err)
+	}
+	cfg := &configuration{}
+	err = config.ReadConfig(f, cfg)
+	if err != nil {
+		log.Fatalf("reading config: %v", err)
+	}
+	whopId := identifier.New()
+	err = whopId.Generate()
+	if err != nil {
+		log.Fatalf("Generating device id: %v", err)
+	}
+	deviceId := whopId.String()
+	log.Debugf("Connecting as device id %s", deviceId)
+	session, err := session.NewSession(cfg.ClientConfig, log, deviceId)
+	if err != nil {
+		log.Fatalf("%s", err)
+	}
+	// ^^ up to this line, things that never change
+	var is_connected, ok bool
+	// vv from this line, things that never stay the same
+	for {
+		log.Debugf("Here we go!")
+		is_connected = false
+		connCh := make(chan bool)
+		iniCh := make(chan uint32)
+
+		notEndp := bus.SessionBus.Endpoint(notifications.BusAddress, log)
+		urlEndp := bus.SessionBus.Endpoint(urldispatcher.BusAddress, log)
+
+		go func() { iniCh <- util.AutoRetry(session.Reset) }()
+		go func() { iniCh <- util.AutoRedial(notEndp) }()
+		go func() { iniCh <- util.AutoRedial(urlEndp) }()
+		go connectivity.ConnectedState(bus.SystemBus.Endpoint(networkmanager.BusAddress, log), cfg.ConnectivityConfig, log, connCh)
+
+		<-iniCh
+		<-iniCh
+		<-iniCh
+		nots := notifications.Raw(notEndp, log)
+		urld := urldispatcher.New(urlEndp, log)
+
+		actnCh, err := nots.WatchActions()
+		if err != nil {
+			log.Errorf("%s", err)
+			continue
+		}
+
+	InnerLoop:
+		for {
+			select {
+			case is_connected, ok = <-connCh:
+				// handle connectivty changes
+				// disconnect session if offline, reconnect if online
+				if !ok {
+					log.Errorf("connectivity checker crashed? restarting everything")
+					break InnerLoop
+				}
+				// fallthrough
+				// oh, silly ol' go doesn't like that.
+				if is_connected {
+					err = session.Reset()
+					if err != nil {
+						break InnerLoop
+					}
+				}
+			case <-session.ErrCh:
+				// handle session errors
+				// restart if online, otherwise ignore
+				if is_connected {
+					err = session.Reset()
+					if err != nil {
+						break InnerLoop
+					}
+				}
+			case <-session.MsgCh:
+				// handle push notifications
+				// pop up client notification
+				// what to do does not depend on the rest
+				// (... for now)
+				log.Debugf("got a notification! let's pop it up.")
+				notify_update(nots, log)
+			case <-actnCh:
+				// handle action clicks
+				// launch system updates
+				// what to do does not depend on the rest
+				// (... for now)
+				urld.DispatchURL("settings:///system/system-update")
+			}
+		}
+	}
+}
 
=== modified file 'client/session/session.go'
--- client/session/session.go	2014-01-27 18:11:05 +0000
+++ client/session/session.go	2014-01-27 18:11:05 +0000
@@ -50,7 +50,7 @@
 
 var _ LevelMap = &mapLevelMap{}
 
-type Config struct {
+type ClientConfig struct {
 	// session configuration
 	ExchangeTimeout config.ConfigTimeDuration `json:"exchange_timeout"`
 	// server connection config
@@ -75,7 +75,7 @@
 	MsgCh chan *Notification
 }
 
-func NewSession(config Config, log logger.Logger, deviceId string) (*ClientSession, error) {
+func NewSession(config ClientConfig, log logger.Logger, deviceId string) (*ClientSession, error) {
 	sess := &ClientSession{
 		ExchangeTimeout: config.ExchangeTimeout.TimeDuration(),
 		ServerAddr:      config.Addr.HostPort(),
 
=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-01-27 18:11:05 +0000
+++ client/session/session_test.go	2014-01-27 18:11:05 +0000
@@ -49,7 +49,7 @@
 ****************************************************************/
 
 func (cs *clientSessionSuite) TestNewSessionPlainWorks(c *C) {
-	cfg := Config{}
+	cfg := ClientConfig{}
 	sess, err := NewSession(cfg, nullog, "wah")
 	c.Check(sess, NotNil)
 	c.Check(err, IsNil)
@@ -58,7 +58,7 @@
 var certfile string = helpers.SourceRelative("../../server/acceptance/config/testing.cert")
 
 func (cs *clientSessionSuite) TestNewSessionPEMWorks(c *C) {
-	cfg := Config{CertPEMFile: certfile}
+	cfg := ClientConfig{CertPEMFile: certfile}
 	sess, err := NewSession(cfg, nullog, "wah")
 	c.Check(sess, NotNil)
 	c.Assert(err, IsNil)
@@ -66,14 +66,14 @@
 }
 
 func (cs *clientSessionSuite) TestNewSessionBadPEMFilePathFails(c *C) {
-	cfg := Config{CertPEMFile: "/no/such/path"}
+	cfg := ClientConfig{CertPEMFile: "/no/such/path"}
 	sess, err := NewSession(cfg, nullog, "wah")
 	c.Check(sess, IsNil)
 	c.Check(err, NotNil)
 }
 
 func (cs *clientSessionSuite) TestNewSessionBadPEMFileContentFails(c *C) {
-	cfg := Config{CertPEMFile: "/etc/passwd"}
+	cfg := ClientConfig{CertPEMFile: "/etc/passwd"}
 	sess, err := NewSession(cfg, nullog, "wah")
 	c.Check(sess, IsNil)
 	c.Check(err, NotNil)
@@ -214,7 +214,7 @@
  ****************************************************************/
 
 func (cs *clientSessionSuite) TestRunFailsIfNilConnection(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	// not connected!
 	err = sess.run()
@@ -223,7 +223,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunFailsIfNilProtocolator(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname()} // ok, have a constructor
 	sess.Protocolator = nil                       // but no protocol, seeficare.
@@ -233,7 +233,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunFailsIfSetDeadlineFails(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname(),
 		DeadlineCondition: condition.Work(false)} // setdeadline will fail
@@ -243,7 +243,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunFailsIfWriteFails(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname(),
 		WriteCondition: condition.Work(false)} // write will fail
@@ -253,7 +253,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunConnectMessageFails(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname()}
 	errCh := make(chan error, 1)
@@ -278,7 +278,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunConnackReadError(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname()}
 	errCh := make(chan error, 1)
@@ -300,7 +300,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunBadConnack(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname()}
 	errCh := make(chan error, 1)
@@ -322,7 +322,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunMainloopReadError(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname()}
 	errCh := make(chan error, 1)
@@ -349,7 +349,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunPongWriteError(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname()}
 	errCh := make(chan error, 1)
@@ -378,7 +378,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunPingPong(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname()}
 	errCh := make(chan error, 1)
@@ -406,7 +406,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunBadAckWrite(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname()}
 	errCh := make(chan error, 1)
@@ -444,7 +444,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunBroadcastWrongChannel(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname()}
 	errCh := make(chan error, 1)
@@ -482,7 +482,7 @@
 }
 
 func (cs *clientSessionSuite) TestRunBroadcastRightChannel(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: testname()}
 	sess.ErrCh = make(chan error, 1)
@@ -528,7 +528,7 @@
  */
 
 func (cs *clientSessionSuite) TestDialFailsWithNoAddress(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	err = sess.Dial()
 	c.Assert(err, NotNil)
@@ -539,7 +539,7 @@
 	lp, err := net.Listen("tcp", ":0")
 	c.Assert(err, IsNil)
 	defer lp.Close()
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.ServerAddr = lp.Addr().String()
 	err = sess.Dial()
@@ -548,7 +548,7 @@
 }
 
 func (cs *clientSessionSuite) TestResetFailsWithoutProtocolator(c *C) {
-	sess, _ := NewSession(Config{}, debuglog, "wah")
+	sess, _ := NewSession(ClientConfig{}, debuglog, "wah")
 	sess.Protocolator = nil
 	err := sess.Reset()
 	c.Assert(err, NotNil)
@@ -556,7 +556,7 @@
 }
 
 func (cs *clientSessionSuite) TestResetFailsWithNoAddress(c *C) {
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	err = sess.Reset()
 	c.Assert(err, NotNil)
@@ -571,7 +571,7 @@
 	c.Assert(err, IsNil)
 	defer lp.Close()
 
-	sess, err := NewSession(Config{}, debuglog, "wah")
+	sess, err := NewSession(ClientConfig{}, debuglog, "wah")
 	c.Assert(err, IsNil)
 	sess.ServerAddr = lp.Addr().String()
 	sess.Connection = &testConn{Name: testname()}
 
=== modified file 'util/redialer.go'
--- util/redialer.go	2014-01-27 13:02:26 +0000
+++ util/redialer.go	2014-01-27 18:11:05 +0000
@@ -49,15 +49,14 @@
 	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 {
+// AutoRetry keeps on calling f() until it stops returning an error.
+// It does exponential backoff, adding jitter at each step back.
+func AutoRetry(f func() error, jitter func(time.Duration) time.Duration) 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 {
+		if f() == nil {
 			return dialAttempts + 1
 		}
 		if dialAttempts < numTimeouts {
@@ -65,7 +64,7 @@
 		} else {
 			timeout = Timeouts[numTimeouts-1]
 		}
-		timeout += dialer.Jitter(timeout)
+		timeout += jitter(timeout)
 		dialAttempts++
 		select {
 		case <-quitRedialing:
@@ -75,6 +74,13 @@
 	}
 }
 
+// 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 {
+	return AutoRetry(dialer.Dial, dialer.Jitter)
+}
+
 func init() {
 	ps := []int{1, 2, 5, 11, 19, 37, 67, 113, 191} // 3 pₙ₊₁ ≥ 5 pₙ
 	Timeouts = make([]time.Duration, len(ps))