Merge lp:~ralsina/ubuntu-push/merge-automatic into lp:ubuntu-push

[Roberto Alsina]

Merge latest changes from automatic

Merge latest changes from automatic (for real this time)

[Roberto Alsina (ralsina)]

review: Approve

[lp:~ralsina/ubuntu-push/merge-automatic]

125. By Roberto Alsina on 2014-08-28

Merge latest changes from automatic
Approved by: Roberto Alsina

=== modified file 'client/session/session.go'
--- client/session/session.go	2014-07-08 10:21:52 +0000
+++ client/session/session.go	2014-08-28 15:08:25 +0000
@@ -53,6 +53,7 @@
 	protocol.BroadcastMsg
 	protocol.NotificationsMsg
 	protocol.ConnBrokenMsg
+	protocol.SetParamsMsg
 }
 
 // parseServerAddrSpec recognizes whether spec is a HTTP URL to get
@@ -130,6 +131,7 @@
 	proto        protocol.Protocol
 	pingInterval time.Duration
 	retrier      util.AutoRedialer
+	cookie       string
 	// status
 	stateP          *uint32
 	ErrCh           chan error
@@ -233,6 +235,18 @@
 	return sess.Connection
 }
 
+func (sess *ClientSession) setCookie(cookie string) {
+	sess.connLock.Lock()
+	defer sess.connLock.Unlock()
+	sess.cookie = cookie
+}
+
+func (sess *ClientSession) getCookie() string {
+	sess.connLock.RLock()
+	defer sess.connLock.RUnlock()
+	return sess.cookie
+}
+
 // getHosts sets deliveryHosts possibly querying a remote endpoint
 func (sess *ClientSession) getHosts() error {
 	if sess.getHost != nil {
@@ -470,6 +484,14 @@
 	return err
 }
 
+// handle "setparams" messages
+func (sess *ClientSession) handleSetParams(setParams *serverMsg) error {
+	if setParams.SetCookie != "" {
+		sess.setCookie(setParams.SetCookie)
+	}
+	return nil
+}
+
 // loop runs the session with the server, emits a stream of events.
 func (sess *ClientSession) loop() error {
 	var err error
@@ -492,6 +514,8 @@
 			err = sess.handleNotifications(&recv)
 		case "connbroken":
 			err = sess.handleConnBroken(&recv)
+		case "setparams":
+			err = sess.handleSetParams(&recv)
 		case "warn":
 			// XXX: current message "warn" should be "connwarn"
 			fallthrough
@@ -533,6 +557,7 @@
 		Type:          "connect",
 		DeviceId:      sess.DeviceId,
 		Authorization: sess.auth,
+		Cookie:        sess.getCookie(),
 		Levels:        levels,
 		Info:          sess.Info,
 	})

=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-07-08 10:21:52 +0000
+++ client/session/session_test.go	2014-08-28 15:08:25 +0000
@@ -680,19 +680,20 @@
 ****************************************************************/
 
 func (s *msgSuite) TestHandleBroadcastWorks(c *C) {
-	msg := serverMsg{"broadcast",
-		protocol.BroadcastMsg{
-			Type:     "broadcast",
-			AppId:    "--ignored--",
-			ChanId:   "0",
-			TopLevel: 2,
-			Payloads: []json.RawMessage{
-				json.RawMessage(`{"img1/m1":[101,"tubular"]}`),
-				json.RawMessage("false"), // shouldn't happen but robust
-				json.RawMessage(`{"img1/m1":[102,"tubular"]}`),
-			},
-		}, protocol.NotificationsMsg{}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleBroadcast(&msg) }()
+	msg := new(serverMsg)
+	msg.Type = "broadcast"
+	msg.BroadcastMsg = protocol.BroadcastMsg{
+		Type:     "broadcast",
+		AppId:    "--ignored--",
+		ChanId:   "0",
+		TopLevel: 2,
+		Payloads: []json.RawMessage{
+			json.RawMessage(`{"img1/m1":[101,"tubular"]}`),
+			json.RawMessage("false"), // shouldn't happen but robust
+			json.RawMessage(`{"img1/m1":[102,"tubular"]}`),
+		},
+	}
+	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, Equals, nil)
@@ -715,15 +716,16 @@
 }
 
 func (s *msgSuite) TestHandleBroadcastBadAckWrite(c *C) {
-	msg := serverMsg{"broadcast",
-		protocol.BroadcastMsg{
-			Type:     "broadcast",
-			AppId:    "APP",
-			ChanId:   "0",
-			TopLevel: 2,
-			Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
-		}, protocol.NotificationsMsg{}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleBroadcast(&msg) }()
+	msg := new(serverMsg)
+	msg.Type = "broadcast"
+	msg.BroadcastMsg = protocol.BroadcastMsg{
+		Type:     "broadcast",
+		AppId:    "APP",
+		ChanId:   "0",
+		TopLevel: 2,
+		Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
+	}
+	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	failure := errors.New("ACK ACK ACK")
 	s.upCh <- failure
@@ -732,15 +734,16 @@
 }
 
 func (s *msgSuite) TestHandleBroadcastWrongChannel(c *C) {
-	msg := serverMsg{"broadcast",
-		protocol.BroadcastMsg{
-			Type:     "broadcast",
-			AppId:    "APP",
-			ChanId:   "something awful",
-			TopLevel: 2,
-			Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
-		}, protocol.NotificationsMsg{}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleBroadcast(&msg) }()
+	msg := new(serverMsg)
+	msg.Type = "brodacast"
+	msg.BroadcastMsg = protocol.BroadcastMsg{
+		Type:     "broadcast",
+		AppId:    "APP",
+		ChanId:   "something awful",
+		TopLevel: 2,
+		Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
+	}
+	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, IsNil)
@@ -749,15 +752,16 @@
 
 func (s *msgSuite) TestHandleBroadcastBrokenSeenState(c *C) {
 	s.sess.SeenState = &brokenSeenState{}
-	msg := serverMsg{"broadcast",
-		protocol.BroadcastMsg{
-			Type:     "broadcast",
-			AppId:    "--ignored--",
-			ChanId:   "0",
-			TopLevel: 2,
-			Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
-		}, protocol.NotificationsMsg{}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleBroadcast(&msg) }()
+	msg := new(serverMsg)
+	msg.Type = "broadcast"
+	msg.BroadcastMsg = protocol.BroadcastMsg{
+		Type:     "broadcast",
+		AppId:    "--ignored--",
+		ChanId:   "0",
+		TopLevel: 2,
+		Payloads: []json.RawMessage{json.RawMessage(`{"b":1}`)},
+	}
+	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
 	s.upCh <- nil // ack ok
 	// start returns with error
 	c.Check(<-s.errCh, Not(Equals), nil)
@@ -772,9 +776,8 @@
 func (s *msgSuite) TestHandleBroadcastClearsDelay(c *C) {
 	s.sess.setShouldDelay()
 
-	msg := serverMsg{"broadcast", protocol.BroadcastMsg{},
-		protocol.NotificationsMsg{}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleBroadcast(&msg) }()
+	msg := &serverMsg{Type: "broadcast"}
+	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, IsNil)
@@ -785,9 +788,8 @@
 func (s *msgSuite) TestHandleBroadcastDoesNotClearDelayOnError(c *C) {
 	s.sess.setShouldDelay()
 
-	msg := serverMsg{"broadcast", protocol.BroadcastMsg{},
-		protocol.NotificationsMsg{}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleBroadcast(&msg) }()
+	msg := &serverMsg{Type: "broadcast"}
+	go func() { s.errCh <- s.sess.handleBroadcast(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- errors.New("bcast")
 	c.Check(<-s.errCh, NotNil)
@@ -835,12 +837,12 @@
 		MsgId:   "b",
 		Payload: json.RawMessage(`{"m": 2}`),
 	}
-	msg := serverMsg{"notifications",
-		protocol.BroadcastMsg{},
-		protocol.NotificationsMsg{
-			Notifications: []protocol.Notification{n1, n2},
-		}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleNotifications(&msg) }()
+	msg := new(serverMsg)
+	msg.Type = "notifications"
+	msg.NotificationsMsg = protocol.NotificationsMsg{
+		Notifications: []protocol.Notification{n1, n2},
+	}
+	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, Equals, nil)
@@ -881,12 +883,12 @@
 		MsgId:   "b",
 		Payload: json.RawMessage(`{"m": 2}`),
 	}
-	msg := serverMsg{"notifications",
-		protocol.BroadcastMsg{},
-		protocol.NotificationsMsg{
-			Notifications: []protocol.Notification{n1, n2},
-		}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleNotifications(&msg) }()
+	msg := new(serverMsg)
+	msg.Type = "notifications"
+	msg.NotificationsMsg = protocol.NotificationsMsg{
+		Notifications: []protocol.Notification{n1, n2},
+	}
+	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, Equals, nil)
@@ -916,12 +918,12 @@
 		MsgId:   "b",
 		Payload: json.RawMessage(`{"m": 2}`),
 	}
-	msg := serverMsg{"notifications",
-		protocol.BroadcastMsg{},
-		protocol.NotificationsMsg{
-			Notifications: []protocol.Notification{n1, n2},
-		}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleNotifications(&msg) }()
+	msg := new(serverMsg)
+	msg.Type = "notifications"
+	msg.NotificationsMsg = protocol.NotificationsMsg{
+		Notifications: []protocol.Notification{n1, n2},
+	}
+	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, Equals, nil)
@@ -941,7 +943,7 @@
 	c.Check(ac.ops, HasLen, 3)
 
 	// second time they get ignored
-	go func() { s.errCh <- s.sess.handleNotifications(&msg) }()
+	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	s.upCh <- nil // ack ok
 	c.Check(<-s.errCh, Equals, nil)
@@ -956,12 +958,12 @@
 		MsgId:   "a",
 		Payload: json.RawMessage(`{"m": 1}`),
 	}
-	msg := serverMsg{"notifications",
-		protocol.BroadcastMsg{},
-		protocol.NotificationsMsg{
-			Notifications: []protocol.Notification{n1},
-		}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleNotifications(&msg) }()
+	msg := new(serverMsg)
+	msg.Type = "notifications"
+	msg.NotificationsMsg = protocol.NotificationsMsg{
+		Notifications: []protocol.Notification{n1},
+	}
+	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
 	failure := errors.New("ACK ACK ACK")
 	s.upCh <- failure
@@ -979,12 +981,12 @@
 		MsgId:   "a",
 		Payload: json.RawMessage(`{"m": 1}`),
 	}
-	msg := serverMsg{"notifications",
-		protocol.BroadcastMsg{},
-		protocol.NotificationsMsg{
-			Notifications: []protocol.Notification{n1},
-		}, protocol.ConnBrokenMsg{}}
-	go func() { s.errCh <- s.sess.handleNotifications(&msg) }()
+	msg := new(serverMsg)
+	msg.Type = "notifications"
+	msg.NotificationsMsg = protocol.NotificationsMsg{
+		Notifications: []protocol.Notification{n1},
+	}
+	go func() { s.errCh <- s.sess.handleNotifications(msg) }()
 	s.upCh <- nil // ack ok
 	// start returns with error
 	c.Check(<-s.errCh, Not(Equals), nil)
@@ -1003,26 +1005,24 @@
 ****************************************************************/
 
 func (s *msgSuite) TestHandleConnBrokenUnkwown(c *C) {
-	msg := serverMsg{"connbroken",
-		protocol.BroadcastMsg{}, protocol.NotificationsMsg{},
-		protocol.ConnBrokenMsg{
-			Reason: "REASON",
-		},
+	msg := new(serverMsg)
+	msg.Type = "connbroken"
+	msg.ConnBrokenMsg = protocol.ConnBrokenMsg{
+		Reason: "REASON",
 	}
-	go func() { s.errCh <- s.sess.handleConnBroken(&msg) }()
+	go func() { s.errCh <- s.sess.handleConnBroken(msg) }()
 	c.Check(<-s.errCh, ErrorMatches, "server broke connection: REASON")
 	c.Check(s.sess.State(), Equals, Error)
 }
 
 func (s *msgSuite) TestHandleConnBrokenHostMismatch(c *C) {
-	msg := serverMsg{"connbroken",
-		protocol.BroadcastMsg{}, protocol.NotificationsMsg{},
-		protocol.ConnBrokenMsg{
-			Reason: protocol.BrokenHostMismatch,
-		},
+	msg := new(serverMsg)
+	msg.Type = "connbroken"
+	msg.ConnBrokenMsg = protocol.ConnBrokenMsg{
+		Reason: protocol.BrokenHostMismatch,
 	}
 	s.sess.deliveryHosts = []string{"foo:443", "bar:443"}
-	go func() { s.errCh <- s.sess.handleConnBroken(&msg) }()
+	go func() { s.errCh <- s.sess.handleConnBroken(msg) }()
 	c.Check(<-s.errCh, ErrorMatches, "server broke connection: host-mismatch")
 	c.Check(s.sess.State(), Equals, Error)
 	// hosts were reset
@@ -1113,6 +1113,20 @@
 	c.Check(<-s.errCh, Equals, failure)
 }
 
+func (s *loopSuite) TestLoopSetParams(c *C) {
+	c.Check(s.sess.State(), Equals, Running)
+	setParams := protocol.SetParamsMsg{
+		Type:      "setparams",
+		SetCookie: "COOKIE",
+	}
+	c.Check(takeNext(s.downCh), Equals, "deadline 1ms")
+	s.upCh <- setParams
+	failure := errors.New("fail")
+	s.upCh <- failure
+	c.Assert(<-s.errCh, Equals, failure)
+	c.Check(s.sess.getCookie(), Equals, "COOKIE")
+}
+
 func (s *loopSuite) TestLoopConnBroken(c *C) {
 	c.Check(s.sess.State(), Equals, Running)
 	broken := protocol.ConnBrokenMsg{
@@ -1302,6 +1316,7 @@
 	sess, err := NewSession("", conf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.Connection = &testConn{Name: "TestStartWorks"}
+	sess.setCookie("COOKIE")
 	errCh := make(chan error, 1)
 	upCh := make(chan interface{}, 5)
 	downCh := make(chan interface{}, 5)
@@ -1317,6 +1332,7 @@
 	c.Check(ok, Equals, true)
 	c.Check(msg.DeviceId, Equals, "wah")
 	c.Check(msg.Authorization, Equals, "")
+	c.Check(msg.Cookie, Equals, "COOKIE")
 	c.Check(msg.Info, DeepEquals, info)
 	upCh <- nil // no error
 	upCh <- protocol.ConnAckMsg{

=== modified file 'debian/changelog'
--- debian/changelog	2014-08-27 18:47:25 +0000
+++ debian/changelog	2014-08-28 15:08:25 +0000
@@ -1,3 +1,10 @@
+ubuntu-push (0.63.1) UNRELEASED; urgency=medium
+
+  [ Samuele Pedroni ]
+  * Support taking a cookie from the server and sending it back on connect (feature was incomplete).
+
+ -- Roberto Alsina <ralsina@yoga>  Thu, 28 Aug 2014 12:07:01 -0300
+
 ubuntu-push (0.63+14.10.20140827-0ubuntu1) utopic; urgency=medium
 
   [ Samuele Pedroni ]

=== modified file 'protocol/messages.go'
--- protocol/messages.go	2014-05-15 16:36:45 +0000
+++ protocol/messages.go	2014-08-28 15:08:25 +0000
@@ -32,6 +32,7 @@
 	ClientVer     string
 	DeviceId      string
 	Authorization string
+	Cookie        string
 	Info          map[string]interface{} `json:",omitempty"` // platform etc...
 	// maps channel ids (hex encoded UUIDs) to known client channel levels
 	Levels map[string]int64
@@ -103,6 +104,19 @@
 	WarnUnauthorized = "unauthorized"
 )
 
+// SETPARAMS message
+type SetParamsMsg struct {
+	Type      string `json:"T"`
+	SetCookie string
+}
+
+func (m *SetParamsMsg) Split() bool {
+	return true
+}
+func (m *SetParamsMsg) OnewayContinue() bool {
+	return true
+}
+
 // PING/PONG messages
 type PingPongMsg struct {
 	Type string `json:"T"`

=== modified file 'protocol/messages_test.go'
--- protocol/messages_test.go	2014-05-15 16:36:45 +0000
+++ protocol/messages_test.go	2014-08-28 15:08:25 +0000
@@ -118,6 +118,12 @@
 	c.Check(m.OnewayContinue(), Equals, true)
 }
 
+func (s *messagesSuite) TestSetParamsMsg(c *C) {
+	m := &SetParamsMsg{}
+	c.Check(m.Split(), Equals, true)
+	c.Check(m.OnewayContinue(), Equals, true)
+}
+
 func (s *messagesSuite) TestExtractPayloads(c *C) {
 	c.Check(ExtractPayloads(nil), IsNil)
 	p1 := json.RawMessage(`{"a":1}`)