Merge lp:~chipaca/ubuntu-push/elements-of-client-session-toponomy into lp:ubuntu-push

[John Lenton]

Starting to take shape.

Client session, volume 5: elements of client session toponomy.

[lp:~chipaca/ubuntu-push/elements-of-client-session-toponomy]

41. By John Lenton on 2014-01-31

Merged introduction-to-quantum-client-sessions into elements-of-client-session-toponomy.

42. By John Lenton on 2014-01-31

Merged introduction-to-quantum-client-sessions into elements-of-client-session-toponomy.

43. By John Lenton on 2014-01-31

Merged introduction-to-quantum-client-sessions into elements-of-client-session-toponomy.

44. By John Lenton on 2014-01-31

Merged introduction-to-quantum-client-sessions into elements-of-client-session-toponomy.

45. By John Lenton on 2014-01-31

Merged introduction-to-quantum-client-sessions into elements-of-client-session-toponomy.

46. By John Lenton on 2014-01-31

Merged introduction-to-quantum-client-sessions into elements-of-client-session-toponomy.

47. By John Lenton on 2014-01-31

Merged introduction-to-quantum-client-sessions into elements-of-client-session-toponomy.

48. By John Lenton on 2014-01-31

brought back testConn.SetDeadline; added a proto.SetDeadline before sending the connect msg; fixed the tests appropriately; added a check on the type of the Connn^Cssages in TestStart*.

49. By John Lenton on 2014-01-31

Merged introduction-to-quantum-client-sessions into elements-of-client-session-toponomy.

50. By John Lenton on 2014-01-31

Merged introduction-to-quantum-client-sessions into elements-of-client-session-toponomy.

[Samuele Pedroni (pedronis)]

42 + err = proto.ReadMessage(&connAck)

around here there should be a sanity check that connAck.Type is "connack"

114 + c.Check(err.Error(), Matches, ".*deadline.*")

gocheck has c.Check(err, ErrorMatches, ...)

I just noticed that upCh downCh are still from the point of view of the server, I suppose we need to live with that if we want to share later unless we can invent neutral names

[lp:~chipaca/ubuntu-push/elements-of-client-session-toponomy]

51. By John Lenton on 2014-01-31

sanity check to connack; used ErrorMatches in tests

[Samuele Pedroni (pedronis)]

there are still some:

client/session/session_test.go:396: c.Check(err.Error(), Equals, "Read")
client/session/session_test.go:446: c.Check(err.Error(), Matches, ".*deadline.*")
client/session/session_test.go:456: c.Check(err.Error(), Matches, ".*write.*")
client/session/session_test.go:482: c.Check(err.Error(), Matches, "Overflow.*null")
client/session/session_test.go:506: c.Check(err.Error(), Matches, ".*EOF.*")

review: Approve

[lp:~chipaca/ubuntu-push/elements-of-client-session-toponomy]

52. By John Lenton on 2014-01-31

more ErrorMatches

=== modified file 'client/session/session.go'
--- client/session/session.go	2014-01-31 17:40:56 +0000
+++ client/session/session.go	2014-01-31 19:56:23 +0000
@@ -22,6 +22,7 @@
 	"crypto/tls"
 	"crypto/x509"
 	"errors"
+	"fmt"
 	"launchpad.net/ubuntu-push/client/session/levelmap"
 	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/protocol"
@@ -138,7 +139,7 @@
 		sess.Levels.Set(bcast.ChanId, bcast.TopLevel)
 		sess.MsgCh <- &Notification{}
 	} else {
-		sess.Log.Debugf("what is this weird channel, %s?", bcast.ChanId)
+		sess.Log.Debugf("what is this weird channel, %#v?", bcast.ChanId)
 	}
 	return nil
 }
@@ -165,3 +166,44 @@
 		}
 	}
 }
+
+// Call this when you've connected and are ready to start running.
+func (sess *ClientSession) start() error {
+	conn := sess.Connection
+	err := conn.SetDeadline(time.Now().Add(sess.ExchangeTimeout))
+	if err != nil {
+		return err
+	}
+	_, err = conn.Write(wireVersionBytes)
+	// The Writer docs: Write must return a non-nil error if it returns
+	// n < len(p). So, no need to check number of bytes written, hooray.
+	if err != nil {
+		return err
+	}
+	proto := sess.Protocolator(conn)
+	proto.SetDeadline(time.Now().Add(sess.ExchangeTimeout))
+	err = proto.WriteMessage(protocol.ConnectMsg{
+		Type:     "connect",
+		DeviceId: sess.DeviceId,
+		Levels:   sess.Levels.GetAll(),
+	})
+	if err != nil {
+		return err
+	}
+	var connAck protocol.ConnAckMsg
+	err = proto.ReadMessage(&connAck)
+	if err != nil {
+		return err
+	}
+	if connAck.Type != "connack" {
+		return fmt.Errorf("expecting CONNACK, got %#v", connAck.Type)
+	}
+	pingInterval, err := time.ParseDuration(connAck.Params.PingInterval)
+	if err != nil {
+		return err
+	}
+	sess.proto = proto
+	sess.pingInterval = pingInterval
+	sess.Log.Debugf("Connected %v.", conn.LocalAddr())
+	return nil
+}

=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-01-31 17:40:56 +0000
+++ client/session/session_test.go	2014-01-31 19:56:23 +0000
@@ -20,6 +20,7 @@
 	"encoding/json"
 	"errors"
 	"fmt"
+	"io"
 	"io/ioutil"
 	. "launchpad.net/gocheck"
 	"launchpad.net/ubuntu-push/logger"
@@ -73,11 +74,29 @@
 	}
 }
 
-func (tc *testConn) SetDeadline(t time.Time) error      { panic("SetDeadline not implemented.") }
+func (tc *testConn) SetDeadline(t time.Time) error {
+	tc.Deadlines = append(tc.Deadlines, t.Sub(time.Now()))
+	if tc.DeadlineCondition == nil || tc.DeadlineCondition.OK() {
+		return nil
+	} else {
+		return errors.New("deadliner on fire")
+	}
+}
+
 func (tc *testConn) SetReadDeadline(t time.Time) error  { panic("SetReadDeadline not implemented.") }
 func (tc *testConn) SetWriteDeadline(t time.Time) error { panic("SetWriteDeadline not implemented.") }
 func (tc *testConn) Read(buf []byte) (n int, err error) { panic("Read not implemented.") }
-func (tc *testConn) Write(buf []byte) (int, error)      { panic("Write not implemented.") }
+
+func (tc *testConn) Write(buf []byte) (int, error) {
+	store := make([]byte, len(buf))
+	copy(store, buf)
+	tc.Writes = append(tc.Writes, store)
+	if tc.WriteCondition == nil || tc.WriteCondition.OK() {
+		return len(store), nil
+	} else {
+		return -1, errors.New("writer on fire")
+	}
+}
 
 // test protocol (from session_test)
 
@@ -174,8 +193,7 @@
 	sess, err := NewSession("", nil, 0, "wah", debuglog)
 	c.Assert(err, IsNil)
 	err = sess.Dial()
-	c.Assert(err, NotNil)
-	c.Check(err.Error(), Matches, ".*dial.*address.*")
+	c.Check(err, ErrorMatches, ".*dial.*address.*")
 }
 
 func (cs *clientSessionSuite) TestDialConnects(c *C) {
@@ -196,9 +214,7 @@
 	srv.Close()
 	c.Assert(err, IsNil)
 	err = sess.Dial()
-	c.Check(sess.Connection, IsNil)
-	c.Assert(err, NotNil)
-	c.Check(err.Error(), Matches, ".*connection refused")
+	c.Check(err, ErrorMatches, ".*connection refused")
 }
 
 /****************************************************************
@@ -376,8 +392,7 @@
 func (s *runSuite) TestRunReadError(c *C) {
 	s.upCh <- errors.New("Read")
 	err := <-s.errCh
-	c.Assert(err, NotNil)
-	c.Check(err.Error(), Equals, "Read")
+	c.Check(err, ErrorMatches, "Read")
 }
 
 func (s *runSuite) TestRunPing(c *C) {
@@ -416,3 +431,145 @@
 	s.upCh <- failure
 	c.Check(<-s.errCh, Equals, failure)
 }
+
+/****************************************************************
+  start() tests
+****************************************************************/
+func (cs *clientSessionSuite) TestStartFailsIfSetDeadlineFails(c *C) {
+	sess, err := NewSession("", nil, 0, "wah", debuglog)
+	c.Assert(err, IsNil)
+	sess.Connection = &testConn{Name: "TestStartFailsIfSetDeadlineFails",
+		DeadlineCondition: condition.Work(false)} // setdeadline will fail
+	err = sess.start()
+	c.Check(err, ErrorMatches, ".*deadline.*")
+}
+
+func (cs *clientSessionSuite) TestStartFailsIfWriteFails(c *C) {
+	sess, err := NewSession("", nil, 0, "wah", debuglog)
+	c.Assert(err, IsNil)
+	sess.Connection = &testConn{Name: "TestStartFailsIfWriteFails",
+		WriteCondition: condition.Work(false)} // write will fail
+	err = sess.start()
+	c.Check(err, ErrorMatches, ".*write.*")
+}
+
+func (cs *clientSessionSuite) TestStartConnectMessageFails(c *C) {
+	sess, err := NewSession("", nil, 0, "wah", debuglog)
+	c.Assert(err, IsNil)
+	sess.Connection = &testConn{Name: "TestStartConnectMessageFails"}
+	errCh := make(chan error, 1)
+	upCh := make(chan interface{}, 5)
+	downCh := make(chan interface{}, 5)
+	proto := &testProtocol{up: upCh, down: downCh}
+	sess.Protocolator = func(_ net.Conn) protocol.Protocol { return proto }
+
+	go func() {
+		errCh <- sess.start()
+	}()
+
+	c.Check(takeNext(downCh), Equals, "deadline 0")
+	c.Check(takeNext(downCh), DeepEquals, protocol.ConnectMsg{
+		Type:     "connect",
+		DeviceId: sess.DeviceId,
+		Levels:   map[string]int64{},
+	})
+	upCh <- errors.New("Overflow error in /dev/null")
+	err = <-errCh
+	c.Check(err, ErrorMatches, "Overflow.*null")
+}
+
+func (cs *clientSessionSuite) TestStartConnackReadError(c *C) {
+	sess, err := NewSession("", nil, 0, "wah", debuglog)
+	c.Assert(err, IsNil)
+	sess.Connection = &testConn{Name: "TestStartConnackReadError"}
+	errCh := make(chan error, 1)
+	upCh := make(chan interface{}, 5)
+	downCh := make(chan interface{}, 5)
+	proto := &testProtocol{up: upCh, down: downCh}
+	sess.Protocolator = func(_ net.Conn) protocol.Protocol { return proto }
+
+	go func() {
+		errCh <- sess.start()
+	}()
+
+	c.Check(takeNext(downCh), Equals, "deadline 0")
+	_, ok := takeNext(downCh).(protocol.ConnectMsg)
+	c.Check(ok, Equals, true)
+	upCh <- nil // no error
+	upCh <- io.EOF
+	err = <-errCh
+	c.Check(err, ErrorMatches, ".*EOF.*")
+}
+
+func (cs *clientSessionSuite) TestStartBadConnack(c *C) {
+	sess, err := NewSession("", nil, 0, "wah", debuglog)
+	c.Assert(err, IsNil)
+	sess.Connection = &testConn{Name: "TestStartBadConnack"}
+	errCh := make(chan error, 1)
+	upCh := make(chan interface{}, 5)
+	downCh := make(chan interface{}, 5)
+	proto := &testProtocol{up: upCh, down: downCh}
+	sess.Protocolator = func(_ net.Conn) protocol.Protocol { return proto }
+
+	go func() {
+		errCh <- sess.start()
+	}()
+
+	c.Check(takeNext(downCh), Equals, "deadline 0")
+	_, ok := takeNext(downCh).(protocol.ConnectMsg)
+	c.Check(ok, Equals, true)
+	upCh <- nil // no error
+	upCh <- protocol.ConnAckMsg{Type: "connack"}
+	err = <-errCh
+	c.Check(err, ErrorMatches, ".*invalid.*")
+}
+
+func (cs *clientSessionSuite) TestStartNotConnack(c *C) {
+	sess, err := NewSession("", nil, 0, "wah", debuglog)
+	c.Assert(err, IsNil)
+	sess.Connection = &testConn{Name: "TestStartBadConnack"}
+	errCh := make(chan error, 1)
+	upCh := make(chan interface{}, 5)
+	downCh := make(chan interface{}, 5)
+	proto := &testProtocol{up: upCh, down: downCh}
+	sess.Protocolator = func(_ net.Conn) protocol.Protocol { return proto }
+
+	go func() {
+		errCh <- sess.start()
+	}()
+
+	c.Check(takeNext(downCh), Equals, "deadline 0")
+	_, ok := takeNext(downCh).(protocol.ConnectMsg)
+	c.Check(ok, Equals, true)
+	upCh <- nil // no error
+	upCh <- protocol.ConnAckMsg{Type: "connnak"}
+	err = <-errCh
+	c.Check(err, ErrorMatches, ".*CONNACK.*")
+}
+
+func (cs *clientSessionSuite) TestStartWorks(c *C) {
+	sess, err := NewSession("", nil, 0, "wah", debuglog)
+	c.Assert(err, IsNil)
+	sess.Connection = &testConn{Name: "TestStartWorks"}
+	errCh := make(chan error, 1)
+	upCh := make(chan interface{}, 5)
+	downCh := make(chan interface{}, 5)
+	proto := &testProtocol{up: upCh, down: downCh}
+	sess.Protocolator = func(_ net.Conn) protocol.Protocol { return proto }
+
+	go func() {
+		errCh <- sess.start()
+	}()
+
+	c.Check(takeNext(downCh), Equals, "deadline 0")
+	_, ok := takeNext(downCh).(protocol.ConnectMsg)
+	c.Check(ok, Equals, true)
+	upCh <- nil // no error
+	upCh <- protocol.ConnAckMsg{
+		Type:   "connack",
+		Params: protocol.ConnAckParams{(10 * time.Millisecond).String()},
+	}
+	// start is now done.
+	err = <-errCh
+	c.Assert(err, IsNil)
+}