Merge lp:~chipaca/ubuntu-push/session-refactor-002 into lp:ubuntu-push/automatic

[John Lenton]

Unmerged revisions

367. By John Lenton on 2015-02-12

tmp checking; does not work

366. By John Lenton on 2015-02-06

protect the chs with a lock. any lock will do.

365. By John Lenton on 2015-02-06

added SetChForTesting, for testing

364. By John Lenton on 2015-02-06

first step

363. By John Lenton on 2015-02-05

Merged explicit-check-for-oversize-webcheck-response-bodies into session-refactor.

=== modified file 'client/client.go'
--- client/client.go	2015-02-12 14:49:15 +0000
+++ client/client.go	2015-02-12 14:49:16 +0000
@@ -478,16 +478,20 @@
 // doLoop connects events with their handlers
 func (client *PushClient) doLoop(connhandler func(bool), bcasthandler func(*session.BroadcastNotification) error, ucasthandler func(session.AddressedNotification) error, errhandler func(error), unregisterhandler func(*click.AppId), accountshandler func()) {
 	for {
+		bch := client.session.GetBroadcastCh()
+		uch := client.session.GetNotificationsCh()
+		ech := client.session.GetErrCh()
+		client.log.Debugf("XXX S: %#v -- B:%v U:%v E:%v", client.session, bch, uch, ech)
 		select {
 		case <-client.accountsCh:
 			accountshandler()
 		case state := <-client.connCh:
 			connhandler(state)
-		case bcast := <-client.session.GetBroadcastCh():
+		case bcast := <-bch:
 			bcasthandler(bcast)
-		case aucast := <-client.session.GetNotificationsCh():
+		case aucast := <-uch:
 			ucasthandler(aucast)
-		case err := <-client.session.GetErrCh():
+		case err := <-ech:
 			errhandler(err)
 		case count := <-client.sessionConnectedCh:
 			client.log.Debugf("session connected after %d attempts", count)
 
=== modified file 'client/client_test.go'
--- client/client_test.go	2015-02-12 14:49:15 +0000
+++ client/client_test.go	2015-02-12 14:49:16 +0000
@@ -714,7 +714,7 @@
 	cli.hasConnectivity = true
 	defer cli.session.Close()
 	cli.handleErr(errors.New("bananas"))
-	c.Check(cs.log.Captured(), Matches, ".*session exited.*bananas\n")
+	c.Check(cs.log.Captured(), Matches, "(?ism).*session exited.*bananas")
 }
 
 /*****************************************************************
@@ -775,8 +775,7 @@
 	cli.session.Dial()
 	cli.hasConnectivity = true
 
-	// cli.session.State() will be "Error" here, for now at least
-	c.Check(cli.session.State(), Not(Equals), session.Disconnected)
+	c.Check(cli.session.State(), Equals, session.Disconnected) // internally Error, but invisible now
 	cli.handleConnState(false)
 	c.Check(cli.session.State(), Equals, session.Disconnected)
 }
@@ -1162,11 +1161,14 @@
 	c.Check(cli.hasConnectivity, Equals, false)
 	cli.connCh <- true
 	tick()
+	cs.log.Debugf("================================================================")
 	c.Check(cli.hasConnectivity, Equals, true)
 	cli.connCh <- false
 	tick()
 	c.Check(cli.hasConnectivity, Equals, false)
 
+	cs.log.Debugf("here")
+
 	//  * session.BroadcastCh to the notifications handler
 	c.Check(d.bcastCount, Equals, 0)
 	bcastCh <- positiveBroadcastNotification
 
=== modified file 'client/session/session.go'
--- client/session/session.go	2015-02-12 14:49:15 +0000
+++ client/session/session.go	2015-02-12 14:49:16 +0000
@@ -37,6 +37,7 @@
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/protocol"
 	"launchpad.net/ubuntu-push/util"
+	"runtime"
 )
 
 var (
@@ -132,6 +133,122 @@
 	SetChForTesting(chan *BroadcastNotification, chan AddressedNotification, chan error)
 }
 
+// SessionManager presents a ClientSession interface, but hides the error states.
+type SessionManager struct {
+	session          ClientSession
+	serverAddrSpec   string
+	conf             ClientSessionConfig
+	deviceId         string
+	seenStateFactory func() (seenstate.SeenState, error)
+	log              logger.Logger
+	lck              sync.Mutex
+}
+
+func funcName() string {
+	pc, _, _, _ := runtime.Caller(2)
+	return runtime.FuncForPC(pc).Name()
+}
+
+func (sm *SessionManager) lock() {
+	sm.log.Debugf("[%s] locking...", funcName())
+	sm.lck.Lock()
+	sm.log.Debugf("[%s] locked.", funcName())
+}
+
+func (sm *SessionManager) unlock() {
+	sm.lck.Unlock()
+	sm.log.Debugf("[%s] unlocked.", funcName())
+}
+
+func newSessionManager(serverAddrSpec string, conf ClientSessionConfig,
+	deviceId string, seenStateFactory func() (seenstate.SeenState, error),
+	log logger.Logger) (*SessionManager, error) {
+	sm := &SessionManager{
+		session:          nil,
+		serverAddrSpec:   serverAddrSpec,
+		conf:             conf,
+		deviceId:         deviceId,
+		seenStateFactory: seenStateFactory,
+		log:              log,
+	}
+	return sm, sm.newSession()
+}
+
+func (sm *SessionManager) newSession() error {
+	if sm.state() != Disconnected {
+		return errors.New("trying to create a new session with non-stopped non-errored one existing.")
+	}
+	sess, err := newSession(sm.serverAddrSpec, sm.conf, sm.deviceId, sm.seenStateFactory, sm.log)
+	if err != nil {
+		return err
+	}
+	sm.session = sess
+	return nil
+}
+
+func (sm *SessionManager) State() ClientSessionState {
+	sm.lock()
+	defer sm.unlock()
+	return sm.state()
+}
+func (sm *SessionManager) state() ClientSessionState {
+	if sm.session == nil {
+		return Disconnected
+	}
+	state := sm.session.State()
+	if state == Error {
+		return Disconnected
+	}
+	return state
+}
+
+func (sm *SessionManager) AutoRedial(done chan uint32) {
+	sm.lock()
+	defer sm.unlock()
+	//	sm.newSession()
+	sm.session.AutoRedial(done)
+}
+
+func (sm *SessionManager) Close() {
+	sm.lock()
+	defer sm.unlock()
+	sm.session.Close()
+}
+
+func (sm *SessionManager) ClearCookie() {
+	sm.lock()
+	defer sm.unlock()
+	sm.session.ClearCookie()
+}
+
+func (sm *SessionManager) Dial() error {
+	sm.lock()
+	defer sm.unlock()
+	return sm.session.Dial()
+}
+
+func (sm *SessionManager) GetBroadcastCh() chan *BroadcastNotification {
+	sm.lock()
+	defer sm.unlock()
+	return sm.session.GetBroadcastCh()
+}
+func (sm *SessionManager) GetNotificationsCh() chan AddressedNotification {
+	sm.lock()
+	defer sm.unlock()
+	return sm.session.GetNotificationsCh()
+}
+func (sm *SessionManager) GetErrCh() chan error {
+	sm.lock()
+	defer sm.unlock()
+	return sm.session.GetErrCh()
+}
+
+func (sm *SessionManager) SetChForTesting(bch chan *BroadcastNotification, nch chan AddressedNotification, ech chan error) {
+	sm.lock()
+	defer sm.unlock()
+	sm.session.SetChForTesting(bch, nch, ech)
+}
+
 // ConcreteSession holds a client<->server session and its configuration.
 type ConcreteSession struct {
 	// configuration
@@ -191,7 +308,7 @@
 func NewSession(serverAddrSpec string, conf ClientSessionConfig,
 	deviceId string, seenStateFactory func() (seenstate.SeenState, error),
 	log logger.Logger) (ClientSession, error) {
-	return newSession(serverAddrSpec, conf, deviceId, seenStateFactory, log)
+	return newSessionManager(serverAddrSpec, conf, deviceId, seenStateFactory, log)
 }
 
 func newSession(serverAddrSpec string, conf ClientSessionConfig,