Implement simplified metacom server

Refs: #152
PR-URL: #161

Author: tshemsedinov

lib/client.js

@@ -50,13 +50,15 @@ class Client {
     res.end();
   }
 
-  error(status, err) {
+  error(status, err, callId = err) {
     const { req: { url }, res, connection } = this;
     const reason = http.STATUS_CODES[status];
+    if (typeof err === 'number') err = undefined;
     const error = err ? err.stack : reason;
     const msg = status === 403 ? err.message : `${url} - ${error} - ${status}`;
     application.logger.error(msg);
-    const result = JSON.stringify({ result: 'error', reason });
+    const packet = { callback: callId, error: { message: reason } };
+    const result = JSON.stringify(packet);
     if (connection) {
       connection.send(result);
       return;
@@ -66,36 +68,45 @@ class Client {
     res.end(result);
   }
 
-  async rpc(method, args) {
+  message(data) {
+    const packet = JSON.parse(data);
+    const [callType, methodName] = Object.keys(packet);
+    const callId = packet[callType];
+    const args = packet[methodName];
+    this.rpc(callId, methodName, args);
+  }
+
+  async rpc(callId, method, args) {
     const { res, connection } = this;
     const { semaphore } = application.server;
     try {
       await semaphore.enter();
     } catch {
-      this.error(504);
+      this.error(504, callId);
       return;
     }
     try {
       const session = await application.auth.restore(this);
       const proc = application.runMethod(method, session);
       if (!proc) {
-        this.error(404);
+        this.error(404, callId);
         return;
       }
       if (!session && proc.access !== 'public') {
-        this.error(403, new Error(`Forbidden: /api/${method}`));
+        this.error(403, new Error(`Forbidden: /api/${method}`), callId);
         return;
       }
       const result = await proc.method(args);
       if (!session && proc.access === 'public') {
         const session = application.auth.start(this, result.userId);
         result.token = session.token;
       }
-      const data = JSON.stringify(result);
+      const packet = { callback: callId, result };
+      const data = JSON.stringify(packet);
       if (connection) connection.send(data);
       else res.end(data);
     } catch (err) {
-      this.error(500, err);
+      this.error(500, err, callId);
     } finally {
       semaphore.leave();
     }

lib/server.js

@@ -9,7 +9,6 @@ const Client = require('./client.js');
 
 const SHUTDOWN_TIMEOUT = 5000;
 const LONG_RESPONSE = 30000;
-const METHOD_OFFSET = '/api/'.length;
 
 const clients = new Map();
 
@@ -51,15 +50,13 @@ const listener = (req, res) => {
   });
 
   application.logger.log(`${method}\t${url}`);
-  if (url.startsWith('/api/')) {
+  if (url === '/api') {
     if (method !== 'POST') {
       client.error(403, new Error(`Forbidden: ${url}`));
       return;
     }
-    receiveBody(req).then(body => {
-      const method = url.substring(METHOD_OFFSET);
-      const args = JSON.parse(body);
-      client.rpc(method, args);
+    receiveBody(req).then(data => {
+      client.message(data);
     });
   } else {
     if (url === '/' && !req.connection.encrypted) {
@@ -84,9 +81,8 @@ class Server {
     this.ws = new WebSocket.Server({ server: this.instance });
     this.ws.on('connection', (connection, req) => {
       const client = new Client(req, null, connection);
-      connection.on('message', message => {
-        const { method, args } = JSON.parse(message);
-        client.rpc(method, args);
+      connection.on('message', data => {
+        client.message(data);
       });
     });
     this.instance.listen(port, host);