Merge lp:~pedronis/ubuntu-push/expose-more-acceptance-details into lp:ubuntu-push

[Samuele Pedroni]

refactor acceptance tests to expose more hooking points/details

expose more bits of acceptance tests

[Nicola Larosa (teknico)]

LGTM, except you want "panicked" rather than "paniced".

review: Approve

=== modified file 'server/acceptance/acceptance_test.go'
--- server/acceptance/acceptance_test.go	2014-02-13 19:33:14 +0000
+++ server/acceptance/acceptance_test.go	2014-02-26 20:26:43 +0000
@@ -38,7 +38,7 @@
 }
 
 // Start a server.
-func StartServer(c *C) (<-chan string, func(), string, string) {
+func StartServer(c *C, s *suites.AcceptanceSuite, handle *suites.ServerHandle) {
 	if *serverCmd == "" {
 		c.Skip("executable server not specified")
 	}
@@ -46,10 +46,11 @@
 	cfg := testServerConfig("127.0.0.1:0", "127.0.0.1:0")
 	cfgFilename := suites.WriteConfig(c, tmpDir, "config.json", cfg)
 	logs, killServer := suites.RunAndObserve(c, *serverCmd, cfgFilename)
-	serverHTTPAddr := suites.ExtractListeningAddr(c, logs, suites.HTTPListeningOnPat)
-	serverURL := fmt.Sprintf("http://%s", serverHTTPAddr)
-	serverAddr := suites.ExtractListeningAddr(c, logs, suites.DevListeningOnPat)
-	return logs, killServer, serverAddr, serverURL
+	s.KillGroup["server"] = killServer
+	handle.ServerHTTPAddr = suites.ExtractListeningAddr(c, logs, suites.HTTPListeningOnPat)
+	s.ServerAPIURL = fmt.Sprintf("http://%s", handle.ServerHTTPAddr)
+	handle.ServerAddr = suites.ExtractListeningAddr(c, logs, suites.DevListeningOnPat)
+	handle.ServerEvents = logs
 }
 
 // ping pong/connectivity

=== modified file 'server/acceptance/suites/broadcast.go'
--- server/acceptance/suites/broadcast.go	2014-02-12 15:43:24 +0000
+++ server/acceptance/suites/broadcast.go	2014-02-26 20:26:43 +0000
@@ -37,8 +37,8 @@
 var future = time.Now().Add(9 * time.Hour).Format(time.RFC3339)
 
 func (s *BroadcastAcceptanceSuite) TestBroadcastToConnected(c *C) {
-	events, errCh, stop := s.startClient(c, "DEVB", nil)
-	got, err := s.postRequest("/broadcast", &api.Broadcast{
+	events, errCh, stop := s.StartClient(c, "DEVB", nil)
+	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"n": 42}`),
@@ -47,13 +47,13 @@
 	c.Assert(got, Matches, ".*ok.*")
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`)
 	stop()
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
 func (s *BroadcastAcceptanceSuite) TestBroadcastPending(c *C) {
 	// send broadcast that will be pending
-	got, err := s.postRequest("/broadcast", &api.Broadcast{
+	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"b": 1}`),
@@ -61,11 +61,11 @@
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 
-	events, errCh, stop := s.startClient(c, "DEVB", nil)
+	events, errCh, stop := s.StartClient(c, "DEVB", nil)
 	// gettting pending on connect
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"b":1}]`)
 	stop()
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
@@ -73,7 +73,7 @@
 	// send bunch of broadcasts that will be pending
 	payloadFmt := fmt.Sprintf(`{"b":%%d,"bloat":"%s"}`, strings.Repeat("x", 1024*2))
 	for i := 0; i < 32; i++ {
-		got, err := s.postRequest("/broadcast", &api.Broadcast{
+		got, err := s.PostRequest("/broadcast", &api.Broadcast{
 			Channel:  "system",
 			ExpireOn: future,
 			Data:     json.RawMessage(fmt.Sprintf(payloadFmt, i)),
@@ -82,22 +82,22 @@
 		c.Assert(got, Matches, ".*ok.*")
 	}
 
-	events, errCh, stop := s.startClient(c, "DEVC", nil)
+	events, errCh, stop := s.StartClient(c, "DEVC", nil)
 	// gettting pending on connect
 	c.Check(NextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:30 payloads:\[{"b":0,.*`)
 	c.Check(NextEvent(events, errCh), Matches, `broadcast chan:0 app: topLevel:32 payloads:\[.*`)
 	stop()
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
 func (s *BroadcastAcceptanceSuite) TestBroadcastDistribution2(c *C) {
-	// start 1st clinet
-	events1, errCh1, stop1 := s.startClient(c, "DEV1", nil)
+	// start 1st client
+	events1, errCh1, stop1 := s.StartClient(c, "DEV1", nil)
 	// start 2nd client
-	events2, errCh2, stop2 := s.startClient(c, "DEV2", nil)
+	events2, errCh2, stop2 := s.StartClient(c, "DEV2", nil)
 	// broadcast
-	got, err := s.postRequest("/broadcast", &api.Broadcast{
+	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"n": 42}`),
@@ -108,15 +108,15 @@
 	c.Check(NextEvent(events2, errCh2), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"n":42}]`)
 	stop1()
 	stop2()
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh1), Equals, 0)
 	c.Check(len(errCh2), Equals, 0)
 }
 
 func (s *BroadcastAcceptanceSuite) TestBroadcastFilterByLevel(c *C) {
-	events, errCh, stop := s.startClient(c, "DEVD", nil)
-	got, err := s.postRequest("/broadcast", &api.Broadcast{
+	events, errCh, stop := s.StartClient(c, "DEVD", nil)
+	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"b": 1}`),
@@ -125,10 +125,10 @@
 	c.Assert(got, Matches, ".*ok.*")
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:1 payloads:[{"b":1}]`)
 	stop()
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 	// another broadcast
-	got, err = s.postRequest("/broadcast", &api.Broadcast{
+	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"b": 2}`),
@@ -136,25 +136,25 @@
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 	// reconnect, provide levels, get only later notification
-	events, errCh, stop = s.startClient(c, "DEVD", map[string]int64{
+	events, errCh, stop = s.StartClient(c, "DEVD", map[string]int64{
 		protocol.SystemChannelId: 1,
 	})
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":2}]`)
 	stop()
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
 func (s *BroadcastAcceptanceSuite) TestBroadcastTooAhead(c *C) {
 	// send broadcasts that will be pending
-	got, err := s.postRequest("/broadcast", &api.Broadcast{
+	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"b": 1}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
-	got, err = s.postRequest("/broadcast", &api.Broadcast{
+	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"b": 2}`),
@@ -162,38 +162,38 @@
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 
-	events, errCh, stop := s.startClient(c, "DEVB", map[string]int64{
+	events, errCh, stop := s.StartClient(c, "DEVB", map[string]int64{
 		protocol.SystemChannelId: 10,
 	})
 	// gettting last one pending on connect
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":2}]`)
 	stop()
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
 func (s *BroadcastAcceptanceSuite) TestBroadcastTooAheadOnEmpty(c *C) {
 	// nothing there
-	events, errCh, stop := s.startClient(c, "DEVB", map[string]int64{
+	events, errCh, stop := s.StartClient(c, "DEVB", map[string]int64{
 		protocol.SystemChannelId: 10,
 	})
 	// gettting empty pending on connect
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:0 payloads:null`)
 	stop()
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
 func (s *BroadcastAcceptanceSuite) TestBroadcastWayBehind(c *C) {
 	// send broadcasts that will be pending
-	got, err := s.postRequest("/broadcast", &api.Broadcast{
+	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"b": 1}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
-	got, err = s.postRequest("/broadcast", &api.Broadcast{
+	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"b": 2}`),
@@ -201,26 +201,26 @@
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
 
-	events, errCh, stop := s.startClient(c, "DEVB", map[string]int64{
+	events, errCh, stop := s.StartClient(c, "DEVB", map[string]int64{
 		protocol.SystemChannelId: -10,
 	})
 	// gettting pending on connect
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":1},{"b":2}]`)
 	stop()
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }
 
 func (s *BroadcastAcceptanceSuite) TestBroadcastExpiration(c *C) {
 	// send broadcast that will be pending, and one that will expire
-	got, err := s.postRequest("/broadcast", &api.Broadcast{
+	got, err := s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: future,
 		Data:     json.RawMessage(`{"b": 1}`),
 	})
 	c.Assert(err, IsNil)
 	c.Assert(got, Matches, ".*ok.*")
-	got, err = s.postRequest("/broadcast", &api.Broadcast{
+	got, err = s.PostRequest("/broadcast", &api.Broadcast{
 		Channel:  "system",
 		ExpireOn: time.Now().Add(1 * time.Second).Format(time.RFC3339),
 		Data:     json.RawMessage(`{"b": 2}`),
@@ -231,10 +231,10 @@
 	time.Sleep(2 * time.Second)
 	// second broadcast is expired
 
-	events, errCh, stop := s.startClient(c, "DEVB", nil)
+	events, errCh, stop := s.StartClient(c, "DEVB", nil)
 	// gettting pending on connect
 	c.Check(NextEvent(events, errCh), Equals, `broadcast chan:0 app: topLevel:2 payloads:[{"b":1}]`)
 	stop()
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*EOF`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*EOF`)
 	c.Check(len(errCh), Equals, 0)
 }

=== modified file 'server/acceptance/suites/helpers.go'
--- server/acceptance/suites/helpers.go	2014-02-11 20:36:32 +0000
+++ server/acceptance/suites/helpers.go	2014-02-26 20:26:43 +0000
@@ -92,12 +92,15 @@
 		c.Fatal(err)
 	}
 	bufErr := bufio.NewReaderSize(stderr, 5000)
-	getLineInfo := func() (string, error) {
+	getLineInfo := func(full bool) (string, error) {
 		for {
 			line, err := bufErr.ReadString('\n')
 			if err != nil {
 				return "", err
 			}
+			if full {
+				return strings.TrimRight(line, "\n"), nil
+			}
 			extracted := rxLineInfo.FindStringSubmatch(line)
 			if extracted == nil {
 				return "", fmt.Errorf("unexpected line: %#v", line)
@@ -108,13 +111,19 @@
 	}
 	logs := make(chan string, 10)
 	go func() {
+		paniced := false
 		for {
-			info, err := getLineInfo()
+			info, err := getLineInfo(paniced)
 			if err != nil {
 				logs <- fmt.Sprintf("%s capture: %v", cmdName, err)
 				close(logs)
 				return
 			}
+			if paniced || strings.HasPrefix(info, "ERROR(PANIC") {
+				paniced = true
+				c.Log(info)
+				continue
+			}
 			logs <- info
 		}
 	}()

=== modified file 'server/acceptance/suites/pingpong.go'
--- server/acceptance/suites/pingpong.go	2014-02-11 20:36:32 +0000
+++ server/acceptance/suites/pingpong.go	2014-02-26 20:26:43 +0000
@@ -34,7 +34,7 @@
 func (s *PingPongAcceptanceSuite) TestConnectPingPing(c *C) {
 	errCh := make(chan error, 1)
 	events := make(chan string, 10)
-	sess := testClientSession(s.serverAddr, "DEVA", true)
+	sess := testClientSession(s.ServerAddr, "DEVA", true)
 	err := sess.Dial()
 	c.Assert(err, IsNil)
 	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
@@ -50,8 +50,8 @@
 		errCh <- sess.Run(events)
 	}()
 	connectCli := NextEvent(events, errCh)
-	connectSrv := NextEvent(s.serverEvents, nil)
-	registeredSrv := NextEvent(s.serverEvents, nil)
+	connectSrv := NextEvent(s.ServerEvents, nil)
+	registeredSrv := NextEvent(s.ServerEvents, nil)
 	tconnect := time.Now()
 	c.Assert(connectSrv, Matches, ".*session.* connected .*")
 	c.Assert(registeredSrv, Matches, ".*session.* registered DEVA")
@@ -61,14 +61,14 @@
 	c.Check(elapsedOfPing >= 1.0, Equals, true)
 	c.Check(elapsedOfPing < 1.05, Equals, true)
 	c.Assert(NextEvent(events, errCh), Equals, "Ping")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* ended with: EOF")
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, ".*session.* ended with: EOF")
 	c.Check(len(errCh), Equals, 0)
 }
 
 func (s *PingPongAcceptanceSuite) TestConnectPingNeverPong(c *C) {
 	errCh := make(chan error, 1)
 	events := make(chan string, 10)
-	sess := testClientSession(s.serverAddr, "DEVB", true)
+	sess := testClientSession(s.ServerAddr, "DEVB", true)
 	err := sess.Dial()
 	c.Assert(err, IsNil)
 	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
@@ -85,9 +85,9 @@
 		errCh <- sess.Run(events)
 	}()
 	c.Assert(NextEvent(events, errCh), Matches, "connected .*")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* connected .*")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* registered .*")
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, ".*session.* connected .*")
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, ".*session.* registered .*")
 	c.Assert(NextEvent(events, errCh), Equals, "Ping")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, `.* ended with:.*timeout`)
+	c.Assert(NextEvent(s.ServerEvents, nil), Matches, `.* ended with:.*timeout`)
 	c.Check(len(errCh), Equals, 0)
 }

=== modified file 'server/acceptance/suites/suite.go'
--- server/acceptance/suites/suite.go	2014-02-11 20:36:32 +0000
+++ server/acceptance/suites/suite.go	2014-02-26 20:26:43 +0000
@@ -34,43 +34,79 @@
 	helpers "launchpad.net/ubuntu-push/testing"
 )
 
+// ServerHandle holds the information to attach a client to the test server.
+type ServerHandle struct {
+	ServerAddr     string
+	ServerHTTPAddr string
+	ServerEvents   <-chan string
+}
+
+// Start a client.
+func (h *ServerHandle) StartClient(c *C, devId string, levels map[string]int64) (events <-chan string, errorCh <-chan error, stop func()) {
+	errCh := make(chan error, 1)
+	cliEvents := make(chan string, 10)
+	sess := testClientSession(h.ServerAddr, devId, false)
+	sess.Levels = levels
+	err := sess.Dial()
+	c.Assert(err, IsNil)
+	clientShutdown := make(chan bool, 1) // abused as an atomic flag
+	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
+		// read after ack
+		if op == "read" && len(clientShutdown) > 0 {
+			// exit the sess.Run() goroutine, client will close
+			runtime.Goexit()
+		}
+		return false, 0, nil
+	}
+	sess.Connection = &interceptingConn{sess.Connection, 0, 0, intercept}
+	go func() {
+		errCh <- sess.Run(cliEvents)
+	}()
+	c.Assert(NextEvent(cliEvents, errCh), Matches, "connected .*")
+	c.Assert(NextEvent(h.ServerEvents, nil), Matches, ".*session.* connected .*")
+	c.Assert(NextEvent(h.ServerEvents, nil), Matches, ".*session.* registered "+devId)
+	return cliEvents, errCh, func() { clientShutdown <- true }
+}
+
 // AcceptanceSuite has the basic functionality of the acceptance suites.
 type AcceptanceSuite struct {
 	// hook to start the server(s)
-	StartServer func(c *C) (logs <-chan string, kill func(), serverAddr, apiURL string)
-	// running bits
-	serverKill   func()
-	serverAddr   string
-	serverAPIURL string
-	serverEvents <-chan string
-	httpClient   *http.Client
+	StartServer func(c *C, s *AcceptanceSuite, handle *ServerHandle)
+	// populated by StartServer
+	ServerHandle
+	ServerAPIURL string
+	// KillGroup should be populated by StartServer with functions
+	// to kill the server process
+	KillGroup map[string]func()
+	// other state
+	httpClient *http.Client
 }
 
 // Start a new server for each test.
 func (s *AcceptanceSuite) SetUpTest(c *C) {
-	logs, kill, addr, url := s.StartServer(c)
-	s.serverEvents = logs
-	s.serverKill = kill
-	s.serverAddr = addr
-	s.serverAPIURL = url
+	s.KillGroup = make(map[string]func())
+	s.StartServer(c, s, &s.ServerHandle)
+	c.Assert(s.ServerHandle.ServerEvents, NotNil)
+	c.Assert(s.ServerHandle.ServerAddr, Not(Equals), "")
+	c.Assert(s.ServerAPIURL, Not(Equals), "")
 	s.httpClient = &http.Client{}
 }
 
 func (s *AcceptanceSuite) TearDownTest(c *C) {
-	if s.serverKill != nil {
-		s.serverKill()
+	for _, f := range s.KillGroup {
+		f()
 	}
 }
 
-// Post a request.
-func (s *AcceptanceSuite) postRequest(path string, message interface{}) (string, error) {
+// Post a API request.
+func (s *AcceptanceSuite) PostRequest(path string, message interface{}) (string, error) {
 	packedMessage, err := json.Marshal(message)
 	if err != nil {
 		panic(err)
 	}
 	reader := bytes.NewReader(packedMessage)
 
-	url := s.serverAPIURL + path
+	url := s.ServerAPIURL + path
 	request, _ := http.NewRequest("POST", url, reader)
 	request.ContentLength = int64(reader.Len())
 	request.Header.Set("Content-Type", "application/json")
@@ -141,30 +177,3 @@
 	}
 	return
 }
-
-// Start a client.
-func (s *AcceptanceSuite) startClient(c *C, devId string, levels map[string]int64) (events <-chan string, errorCh <-chan error, stop func()) {
-	errCh := make(chan error, 1)
-	cliEvents := make(chan string, 10)
-	sess := testClientSession(s.serverAddr, devId, false)
-	sess.Levels = levels
-	err := sess.Dial()
-	c.Assert(err, IsNil)
-	clientShutdown := make(chan bool, 1) // abused as an atomic flag
-	intercept := func(ic *interceptingConn, op string, b []byte) (bool, int, error) {
-		// read after ack
-		if op == "read" && len(clientShutdown) > 0 {
-			// exit the sess.Run() goroutine, client will close
-			runtime.Goexit()
-		}
-		return false, 0, nil
-	}
-	sess.Connection = &interceptingConn{sess.Connection, 0, 0, intercept}
-	go func() {
-		errCh <- sess.Run(cliEvents)
-	}()
-	c.Assert(NextEvent(cliEvents, errCh), Matches, "connected .*")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* connected .*")
-	c.Assert(NextEvent(s.serverEvents, nil), Matches, ".*session.* registered "+devId)
-	return cliEvents, errCh, func() { clientShutdown <- true }
-}