Improve design

Author: bigmontz

packages/testkit-backend/src/backend.js

@@ -7,15 +7,15 @@ export default class Backend {
     this._controller = newController()
 
     this._controller.on('response', ({ contextId, response }) => {
-      this._socketServer.writeResponse(contextId, response.name, response.data)
+      this._socketServer.writeResponse(contextId, response)
     })
 
     this._socketServer.on('contextOpen', ({ contextId }) => this._controller.onContextOpen(contextId))
     this._socketServer.on('contextClose', ({ contextId }) => this._controller.onContextClose(contextId))
 
     this._socketServer.on('request', ({ contextId, request }) => { 
       try {
-        this._controller.handle(contextId, request.name, request.data )
+        this._controller.handle(contextId, request)
       } catch (e) {
         this._socketServer.writeBackendError(contextId, e)
       }
@@ -33,4 +33,3 @@ export default class Backend {
   }
 
 }
-

packages/testkit-backend/src/controller.js

@@ -18,7 +18,7 @@ export default class Controller extends EventEmitter {
     throw new Error('not implemented')
   }
 
-  handle(contextId, name, data) {
+  handle(contextId, request) {
     throw new Error('not implemented')
   }
-}
+}

packages/testkit-backend/src/node.controller.js

@@ -20,7 +20,7 @@ export default class NodeController extends Controller {
   }
 
 
-  handle(contextId, name, data) {
+  handle(contextId, { name, data }) {
     if (!this._contexts.has(contextId)) {
       throw new Error(`Context ${contextId} does not exist`)
     } else if (!(name in this._requestHandlers)) {
@@ -64,4 +64,4 @@ export default class NodeController extends Controller {
     this._writeBackendError(contextId, e)
   }
 
-}
+}

packages/testkit-backend/src/protocol.js

@@ -1,16 +1,31 @@
-
+import readline from 'readline'
 import EventEmitter from 'events'
 
 export default class Protocol extends EventEmitter {
-  constructor () {
+  constructor (stream) {
     super()
-    console.log('Backend connected')
     this._inRequest = false
     this._request = ''
+    this._stream = stream
+    this._readlineInterface = null
+  }
+
+  start() {
+    if (!this._readlineInterface) {
+      this._readlineInterface = readline.createInterface(this._stream, null)
+      this._readlineInterface.on('line', this._processLine.bind(this))
+    }
+  }
+
+  stop () {
+    if (this._readlineInterface) {
+      this._readlineInterface.off('line', this._processLine.bind(this))
+      this._readlineInterface = null
+    }
   }
 
   // Called whenever a new line is received.
-  processLine (line) {
+  _processLine (line) {
     switch (line) {
       case '#request begin':
         if (this._inRequest) {
@@ -26,28 +41,28 @@ export default class Protocol extends EventEmitter {
           this._emitRequest()
         } catch (e) {
           console.log('error', e)
-          this.emit('error', e)
+          this._emitError(e)
         }
         this._request = ''
         this._inRequest = false
         break
       default:
         if (!this._inRequest) {
-          throw new Error('Line while not in request')
+          this._emitError(new Error('Line while not in request'))
         }
         this._request += line
         break
     }
   }
 
-  serializeResponse (name, data) {
-    console.log('> writing response', name, data)
-    let response = {
-      name: name,
-      data: data
-    }
-    response = this._stringify(response)
-    return  ['#response begin', response, '#response end'].join('\n') + '\n'
+  _emitError(e) {
+    this.emit('error', e)
+  }
+
+  serializeResponse (response) {
+    console.log('> writing response', response)
+    const responseStr = this._stringify(response)
+    return  ['#response begin', responseStr, '#response end'].join('\n') + '\n'
   }
 
   _emitRequest () {
@@ -62,4 +77,4 @@ export default class Protocol extends EventEmitter {
       typeof value === 'bigint' ? `${value}n` : value
     )
   }
-}
+}

packages/testkit-backend/src/socket.server.js

@@ -1,5 +1,3 @@
-
-import readline from 'readline'
 import { EventEmitter } from 'events'
 import net from 'net'
 import { randomBytes } from 'crypto'
@@ -10,7 +8,7 @@ function generateRandomId () {
 }
 
 export default class SocketServer extends EventEmitter {
-  constructor(port, newProtocol = () => new Protocol(), newId = generateRandomId ) {
+  constructor(port, newProtocol = stream => new Protocol(stream), newId = generateRandomId ) {
     super()
     this._newProtocol = newProtocol
     this._server = null
@@ -21,28 +19,7 @@ export default class SocketServer extends EventEmitter {
 
   start () {
     if (!this._server) {
-      this._server = net.createServer(connection => {
-        const contextId = this._newId()
-        console.log(`[${contextId}] Creating connection`)
-        const protocol = this._newProtocol()
-
-        this._clients.set(contextId, {
-          protocol,
-          connection
-        })
-
-        this.emit('contextOpen', { contextId })
-        protocol.on('request', request => this.emit('request', { contextId, request }) )
-        protocol.on('error', e => this.writeBackendError(contextId, e))
-        
-        connection.on('end', () =>  { 
-          this._clients.delete(contextId)
-          this.emit('contextClose', { contextId })
-        })
-
-        const iface = readline.createInterface(connection, null)
-        iface.on('line', protocol.processLine.bind(protocol))
-      })
+      this._server = net.createServer(this._handleConnection.bind(this))
 
       this._server.listen(this._port, () => {
         console.log('Listening')
@@ -52,24 +29,50 @@ export default class SocketServer extends EventEmitter {
     }
   }
 
-  writeResponse (contextId, name, data) {
+  _handleConnection(connection) {
+    console.log('Backend connected')
+        
+    const contextId = this._newId()
+    const protocol = this._newProtocol(connection)
+
+    this._clients.set(contextId, {
+      protocol,
+      connection
+    })
+
+    this.emit('contextOpen', { contextId })
+    protocol.on('request', request => this.emit('request', { contextId, request }) )
+    protocol.on('error', e => this.writeBackendError(contextId, e))
+    
+    connection.on('end', () =>  { 
+      if (this._clients.has(contextId)) {
+        this._clients.get(contextId).protocol.stop()
+      }
+      this._clients.delete(contextId)
+      this.emit('contextClose', { contextId })
+    })
+
+    protocol.start()
+  }
+
+  writeResponse (contextId, response) {
     if (this._clients.has(contextId)) {
       const { protocol, connection } = this._clients.get(contextId)
-      const chunk = protocol.serializeResponse(name, data)
+      const chunk = protocol.serializeResponse(response)
       connection.write(chunk, 'utf8', () => {})
-      
     }
   }
 
   writeBackendError (contextId, error) {
-    this.writeResponse(contextId, 'BackendError', { msg: error})
+    this.writeResponse(contextId, { name: 'BackendError', data:  { msg: error } })
   }
 
   stop () {
     if (this._server) {
       this._server.close()
+      this._server = null
+      this._clients.forEach(client => client.protocol.stop())
       this._clients = new Map()
     }
   }
-
 }