Refactoring websocket client

Author: jscriptcoder

package.json

@@ -6,7 +6,9 @@
     "http-client": "babel-node src/clients/http/http_client.js",
     "axios-client": "babel-node src/clients/http/axios_client.js",
     "fetch-client": "babel-node src/clients/http/fetch_client.js",
-    "superagent-client": "babel-node src/clients/http/superagent_client.js"
+    "superagent-client": "babel-node src/clients/http/superagent_client.js",
+    "socketio-client": "babel-node src/clients/ws/socketio_client.js",
+    "websocket-client": "babel-node src/clients/ws/websocket_client.js"
   },
   "repository": {
     "type": "git",

src/clients/config.js

@@ -6,4 +6,5 @@ export const {
     iters = 10000
 } = argv
 
-export const serverUrl = `http://${host}:${port}/greeting`
+export const httpApi = `http://${host}:${port}/greeting`
+export const wsApi = `ws://${host}:${port}/greeting`

src/clients/http/axios_client.js

@@ -1,5 +1,5 @@
 import axios from 'axios'
-import { host, port, serverUrl, iters } from '../config'
+import { host, port, httpApi, iters } from '../config'
 import PerformanceTimer from '../PerformanceTimer'
 import { randomName } from '../utils'
 
@@ -12,10 +12,10 @@ export async function runTest() {
 
     timer.start()
 
-    // async loop
     let i = iters
     await (async function asyncLoop() {
-        const response = await axios.post(serverUrl, { name: randomName() })
+        const postData = { name: randomName() }
+        const response = await axios.post(httpApi, postData)
         const { greeting } = response.data
 
         if (--i === 0) {

src/clients/http/fetch_client.js

@@ -1,5 +1,5 @@
 import fetch from 'node-fetch'
-import { host, port, serverUrl, iters } from '../config'
+import { host, port, httpApi, iters } from '../config'
 import PerformanceTimer from '../PerformanceTimer'
 import { randomName } from '../utils'
 
@@ -8,8 +8,7 @@ export async function runTest() {
 
     const requestInit = {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ name: randomName() })
+        headers: { 'Content-Type': 'application/json' }
     }
 
     const timer = new PerformanceTimer()
@@ -18,10 +17,10 @@ export async function runTest() {
 
     timer.start()
 
-    // async loop
     let i = iters
     await (async function asyncLoop() {
-        const response = await fetch(serverUrl, requestInit)
+        const body = JSON.stringify({ name: randomName() })
+        const response = await fetch(httpApi, {...requestInit, body})
         const data = await response.json()
         const { greeting } = data
 

src/clients/http/http_client.js

@@ -1,5 +1,5 @@
 import http from 'http'
-import { host, port, serverUrl, iters } from '../config'
+import { host, port, iters } from '../config'
 import PerformanceTimer from '../PerformanceTimer'
 import { Deferred, randomName } from '../utils'
 
@@ -41,8 +41,6 @@ export async function runTest() {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' }
     }
-    
-    const postData = JSON.stringify({ name: randomName() })
 
     const timer = new PerformanceTimer()
 
@@ -52,6 +50,7 @@ export async function runTest() {
 
     let i = iters
     await (async function asyncLoop() {
+        const postData = JSON.stringify({ name: randomName() })
         const data = await request(reqOptions, postData)
         const { greeting } = data
 

src/clients/http/superagent_client.js

@@ -1,5 +1,5 @@
 import superagent from 'superagent'
-import { host, port, serverUrl, iters } from '../config'
+import { host, port, httpApi, iters } from '../config'
 import PerformanceTimer from '../PerformanceTimer'
 import { randomName } from '../utils'
 
@@ -12,12 +12,12 @@ export async function runTest() {
 
     timer.start()
 
-    // async loop
     let i = iters
     await (async function asyncLoop() {
+        const postData = { name: randomName() }
         const response = await superagent
-            .post(serverUrl)
-            .send({ name: randomName() })
+            .post(httpApi)
+            .send(postData)
         const { greeting } = response.body
 
         if (--i === 0) {

src/clients/ws/socketio_client.js

@@ -1,54 +1,48 @@
 #!/usr/bin/env node
 
-const { PerformanceObserver, performance } = require('perf_hooks')
-const io = require('socket.io-client')
-import { randomName } from '../utils'
-
-const host = process.env.HOST || '0.0.0.0'
-const port = process.env.PORT || 5000
-const server = process.env.SERVER || 'unknown'
-const wsApi = `ws://${host}:${port}/greeting`
-
-let iters = 10000
+import io from 'socket.io-client'
+import { host, port, httpApi, iters } from '../config'
+import PerformanceTimer from '../PerformanceTimer'
+import { Deferred, randomName } from '../utils'
 
 async function runTest() {
-    console.log(`SocketIO client <===> ${server} server on ws://${host}:${port}/greeting`)
+    console.log(`SocketIO client connecting to http://${host}:${port}`)
 
-    const socket = io(wsApi, { transports: ['websocket'] })
+    const timer = new PerformanceTimer()
+    const connect = new Deferred()
+    const socket = io(httpApi, { transports: ['websocket'] })
+    
+    socket.on('connect', () => connect.resolve())
+    socket.on('connect_error', err => connect.reject(err))
+
+    try {
+        await connect.promise
 
-    socket.on('connect', () => {
         console.log(`Running test with ${iters} iterations...`)
 
-        function requestGreeting() {
-            socket.send({ name: randomName() })
-        }
-
+        const requestGreeting = () => socket.send({ name: randomName() })
+    
         socket.on('message', data => {
             const { greeting } = data
-
+    
             if (--iters > 0) {
                 requestGreeting()
             } else {
-                performance.mark('END')
-                performance.measure('START to END', 'START', 'END')
-
+                console.log(`Last greeting: ${greeting}`)
+                timer.end()
                 socket.close()
             }
         })
-
-        performance.mark('START')
-
+    
+        timer.start()
+    
         requestGreeting()
-    })
-}
 
-const obs = new PerformanceObserver(items => {
-    console.log('End test')
-    console.log(`Duration: ${items.getEntries()[0].duration}`)
-    performance.clearMarks()
-})
-
-obs.observe({ entryTypes: ['measure'] })
+    } catch(err) {
+        console.error('Error connecting')
+        socket.close()
+    }
+}
 
 if (require.main === module) {
     runTest()

src/clients/ws/stomp.js renamed to src/clients/ws/stomp_client.js

@@ -1,60 +1,70 @@
 #!/usr/bin/env node
 
-const { PerformanceObserver, performance } = require('perf_hooks')
-const WebSocketClient = require('websocket').client
-import { randomName } from '../utils'
+import { client as WebSocketClient} from 'websocket'
+import { host, port, wsApi, iters } from '../config'
+import PerformanceTimer from '../PerformanceTimer'
+import { Deferred, randomName } from '../utils'
 
-const host = process.env.HOST || '0.0.0.0'
-const port = process.env.PORT || 5000
-const server = process.env.SERVER || 'unknown'
-const wsApi = `ws://${host}:${port}/greeting`
+function createRequester(connection) {
+    const requester = {
+        incoming: null,
+        greeting(data) {
+            // new incoming message on the way
+            const incoming = requester.incoming = new Deferred()
+            connection.sendUTF(JSON.stringify(data))
+            return incoming.promise
+        }
+    }
 
-let iters = 10000
+    return requester
+}
 
 async function runTest() {
-    console.log(`websocket client <===> ${server} server on ws://${host}:${port}/greeting`)
+    console.log(`websocket client connecting to ws://${host}:${port}/greeting`)
 
+    const timer = new PerformanceTimer()
+    const connect = new Deferred()
     const client = new WebSocketClient()
 
-    client.on('connect', connection => {
+    client.on('connect', connection => connect.resolve(connection))
+    client.on('connectFailed', err => connect.reject(err))
+
+    client.connect(wsApi)
+
+    try {
+        const connection = await connect.promise
+
         console.log(`Running test with ${iters} iterations...`)
-        
-        function requestGreeting() {
-            connection.sendUTF(JSON.stringify({ name: randomName() }))
-        }
-    
-        connection.on('message', message => {
+
+        const requester = createRequester(connection)
+
+        connection.on('message', message => requester.incoming.resolve(message))
+
+        let i = iters
+        await (async function asyncLoop() {
+            const sendData = { name: randomName() }
+            const message = await requester.greeting(sendData)
             const data = JSON.parse(message.utf8Data)
             const { greeting } = data
 
-            if (--iters > 0) {
-                requestGreeting()
-            } else {
-                performance.mark('END')
-                performance.measure('START to END', 'START', 'END')
-
-                // https://www.iana.org/assignments/websocket/websocket.xhtml#close-code-number
-                connection.close(1000, 'Done testing')
+            if (--i === 0) {
+                console.log(`Last greeting: ${greeting}`)
+                return
             }
-            
-        })
+    
+            await asyncLoop()
+        })()
 
-        performance.mark('START')
+        timer.end()
 
-        requestGreeting()
-    })
+        // https://www.iana.org/assignments/websocket/websocket.xhtml#close-code-number
+        connection.close(1000, 'Done testing')
 
-    client.connect(wsApi)
+    } catch(err) {
+        console.error('Error connecting')
+    }
 }
 
-const obs = new PerformanceObserver(items => {
-    console.log('End test')
-    console.log(`Duration: ${items.getEntries()[0].duration}`)
-    performance.clearMarks()
-})
-
-obs.observe({ entryTypes: ['measure'] })
-
 if (require.main === module) {
     runTest()
 }

src/clients/ws/websocket_client.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env python
 
+import json
 import eventlet
-from eventlet import wsgi, websocket
 import argparse
-import json
+from eventlet import wsgi, websocket
+from src.servers.config import host, port
+from src.servers.utils import random_greeting
 
 @websocket.WebSocketWSGI
 def greeting_handle(ws):
@@ -12,7 +14,7 @@ def greeting_handle(ws):
         if message is None: break
 
         data = json.loads(message)
-        ws.send(json.dumps({ 'greeting': data['name'] }))
+        ws.send(json.dumps({ 'greeting': random_greeting(data['name']) }))
 
 def site(env, start_response):
     if env['PATH_INFO'] == '/greeting':
@@ -21,12 +23,10 @@ def site(env, start_response):
         start_response('200 OK', [('Content-Type', 'text/plain')])
         return ['Eventlet running...']
 
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-l', '--host', default='0.0.0.0')
-    parser.add_argument('-p', '--port', default=5000, type=int)
+def run_test():
+    # print('Server starting at: ' + 'ws://{}:{}'.format(host, port))
+    listener = eventlet.listen((host, port))
+    wsgi.server(listener, site)
 
-    args = parser.parse_args()
-    print('Server starting at: ' + 'ws://{}:{}'.format(args.host, args.port))
-    listener = eventlet.listen((args.host, args.port))
-    wsgi.server(listener, site)
+if __name__ == '__main__':
+    run_test()