@dra2020/baseclient 1.0.11 → 1.0.14

package/lib/memsqs/client.ts

@@ -0,0 +1,268 @@
+// Node libraries
+import * as http from 'http';
+import * as url from 'url';
+
+// Project libraries
+import * as Util from '../util/all';
+import * as JS from '../jsonstream/all';
+
+// Local libraries
+import * as Q from './queue';
+
+export type SQSCallback = (err: any, result: Q.QMessages) => void;
+
+const MaxRetries = 10;
+
+class SQSRequest
+{
+  httpoptions: any;
+  data: any;
+  cb: SQSCallback;
+  jsonread: JS.JSONStreamReader;
+  jsonwrite: JS.JSONStreamWriter;
+  json: any;
+  request: any;
+  response: any;
+  statusCode: number;
+  nRetries: number;
+
+  constructor(httpoptions: any, data: any, cb: SQSCallback)
+  {
+    this.httpoptions = httpoptions;
+    this.data = data;
+    this.cb = cb;
+    this.nRetries = 0;
+    this.doRequest();
+  }
+
+  doRequest(): void
+  {
+    this.json = null;
+    this.jsonread = null;
+    this.response = null;
+    this.statusCode = 0;
+    this.request = http.request(this.httpoptions, (res: any) => {
+        this.response = res;
+        this.statusCode = res.statusCode;
+        this.jsonread = new JS.JSONStreamReader();
+        this.jsonread.on('end', (json: any) => {
+            this.json = json;
+            if (this.statusCode == 200)
+            {
+              if (this.json.error)
+                console.log(`memsqs:client: reporting server error ${this.json.error}`);
+              this.cb(this.json.error, this.json.result);
+            }
+            else
+            {
+              console.log(`memsqs:client: reporting statusCode error ${this.statusCode}`);
+              this.onError(`error status: ${this.statusCode}`);
+            }
+          });
+        this.jsonread.on('error', (err: any) => {
+            // gateway errors return HTML, not JSON
+            if (this.statusCode != 502 && this.statusCode != 504)
+            {
+              console.log(`memsqs:client: reporting jsonread error ${JSON.stringify(err)}`);
+              this.onError(err);
+            }
+            else
+            {
+              console.log(`memsqs:client: reporting statusCode error ${this.statusCode}`);
+              this.onRequestError(`error status: ${this.statusCode}`);
+            }
+          });
+
+        this.jsonread.start(res);
+
+        res.on('error', (err: any) => {
+            console.log(`memsqs:client: reporting response error ${JSON.stringify(err)}`);
+            this.onError((err && err.message) ? err.message : err);
+          });
+      });
+
+    this.request.on('error', (err: any) => {
+        // Immediately fail ECONNREFUSED rather than retrying (server not available, probably restarting)
+        if (err && err.code && err.code === 'ECONNREFUSED')
+        {
+          console.log('memsqs:client: immediately fail on ECONNREFUSED');
+          this.onError((err && err.message) ? err.message : err);
+        }
+        else
+          this.onRequestError((err && err.message) ? err.message : err);
+      });
+
+    this.request.setHeader('Content-Type', 'application/json; charset=UTF-8');
+    this.jsonwrite = new JS.JSONStreamWriter();
+    this.jsonwrite.on('error', (err: any) => {
+        console.log(`memsqs:client: encountered request error writing response ${JSON.stringify(err)}`);
+        this.onRequestError(err);
+      });
+    this.jsonwrite.start(this.data, this.request);
+  }
+
+  onRequestError(err: any): void
+  {
+    if (this.nRetries >= MaxRetries)
+    {
+      console.log(`memsqs:client: giving up after ${this.nRetries} with error ${JSON.stringify(err)}`);
+      this.onError(err);
+    }
+    else
+    {
+      this.nRetries++;
+      this.doRequest();
+    }
+  }
+
+  onError(err: any): void
+  {
+    if (this.cb)
+    {
+      console.log(`memsqs:client: reporting error to callback: ${JSON.stringify(err)}`);
+      this.cb(err, null);
+      this.cb = null;
+    }
+  }
+}
+
+interface AgentEntry
+{
+  agent: any;
+  inUse: boolean;
+}
+
+class AgentPool
+{
+  agents: AgentEntry[];
+
+  constructor()
+  {
+    this.agents = [];
+  }
+
+  alloc(): any
+  {
+    for (let i: number = 0; i < this.agents.length; i++)
+      if (! this.agents[i].inUse)
+      {
+        this.agents[i].inUse = true;
+        return this.agents[i].agent;
+      }
+
+    let ae: AgentEntry = { agent: new http.Agent( { keepAlive: true, maxSockets: 1 } ), inUse: true };
+    this.agents.push(ae);
+    return ae.agent;
+  }
+
+  free(agent: any): void
+  {
+    for (let i: number = 0; i < this.agents.length; i++)
+      if (this.agents[i].agent === agent)
+      {
+        if (! this.agents[i].inUse)
+          throw 'Duplicate free of agent';
+        this.agents[i].inUse = false;
+        return;
+      }
+
+    throw 'Freeing unallocated agent';
+  }
+}
+
+export class SQSClient
+{
+  private targeturl?: any;
+  private httpoptions?: any;
+  private agentPool?: AgentPool;
+
+  constructor(urlstring: string = Q.DefaultServerUrl)
+    {
+      this.targeturl = new url.URL(urlstring);
+      this.httpoptions = {
+        protocol: this.targeturl.protocol,
+        host: this.targeturl.hostname,
+        port: this.targeturl.port ? this.targeturl.port : Q.DefaultPort,
+        agent: null,
+        method: 'POST',
+        path: '/',
+        };
+      this.agentPool = new AgentPool();
+    }
+
+  setOptions(queueid: string, options: Q.QQueueOptions, cb: SQSCallback): void
+    {
+      // Use separate agent for each outstanding call
+      let httpoptions: any = Util.shallowAssignImmutable(this.httpoptions, { agent: this.agentPool.alloc() });
+
+      new SQSRequest(httpoptions,
+        {
+          queueid: queueid,
+          api: 'setoptions',
+          data: options
+        },
+        (err: any, result: Q.QMessages) => { this.agentPool.free(httpoptions.agent); cb(err, result); });
+
+    }
+
+  claim(queueid: string, owner: string, groupid: string, cb: SQSCallback): void
+    {
+      // Use separate agent for each outstanding call
+      let httpoptions: any = Util.shallowAssignImmutable(this.httpoptions, { agent: this.agentPool.alloc() });
+
+      new SQSRequest(httpoptions,
+        {
+          queueid: queueid,
+          api: 'claim',
+          data: { owner: owner, groupid: groupid }
+        },
+        (err: any, result: Q.QMessages) => { this.agentPool.free(httpoptions.agent); cb(err, result); });
+    }
+
+  send(queueid: string, m: Q.QMessage, cb: SQSCallback): void
+    {
+      // Use separate agent for each outstanding call
+      let httpoptions: any = Util.shallowAssignImmutable(this.httpoptions, { agent: this.agentPool.alloc() });
+
+      new SQSRequest(httpoptions,
+        {
+          queueid: queueid,
+          api: 'send',
+          data: m
+        },
+        (err: any, result: Q.QMessages) => {
+            this.agentPool.free(httpoptions.agent);
+            if (err)
+              result = [ m ];
+            cb(err, result);
+          });
+    }
+
+  remove(queueid: string, m: Q.QMessage, cb: SQSCallback): void
+    {
+      // Use separate agent for each outstanding call
+      let httpoptions: any = Util.shallowAssignImmutable(this.httpoptions, { agent: this.agentPool.alloc() });
+
+      new SQSRequest(httpoptions,
+        {
+          queueid: queueid,
+          api: 'remove',
+          data: m
+        },
+        (err: any, result: Q.QMessages) => { this.agentPool.free(httpoptions.agent); cb(err, result); });
+    }
+
+  receive(queueid: string, owner: string, cb: SQSCallback): void
+    {
+      // Use separate agent for each outstanding call
+      let httpoptions: any = Util.shallowAssignImmutable(this.httpoptions, { agent: this.agentPool.alloc() });
+
+      new SQSRequest(httpoptions,
+        {
+          queueid: queueid,
+          api: 'receive',
+          owner: owner,
+        },
+        (err: any, result: Q.QMessages) => { this.agentPool.free(httpoptions.agent); cb(err, result); });
+    }
+}

package/lib/memsqs/loopback.ts

@@ -0,0 +1,64 @@
+// Local libraries
+import * as Q from './queue';
+import * as C from './client';
+
+type MessageList = { [queueid: string]: Q.QMessage[] };
+type ReceiveList = { [queueid: string]: C.SQSCallback };
+
+let messageList: MessageList = {};
+let receiveList: ReceiveList = {};
+
+export class SQSClientLoopback
+{
+  constructor(urlstring: string = Q.DefaultServerUrl)
+  {
+    console.log('memsqs: running in loopback mode');
+  }
+
+  setOptions(queueid: string, options: Q.QQueueOptions, cb: C.SQSCallback): void
+  {
+    cb(null, null);
+  }
+
+  claim(queueid: string, owner: string, groupid: string, cb: C.SQSCallback): void
+  {
+    cb(null, null);
+  }
+
+  send(queueid: string, m: Q.QMessage, cb: C.SQSCallback): void
+  {
+    let q = messageList[queueid];
+    if (q === undefined)
+      q = [], messageList[queueid] = q;
+    q.push(m);
+    cb(null, null);
+    this.doReceive();
+  }
+
+  remove(queueid: string, m: Q.QMessage, cb: C.SQSCallback): void
+  {
+    // We just remove during receive so this is no-op
+    cb(null, null);
+  }
+
+  receive(queueid: string, owner: string, cb: C.SQSCallback): void
+  {
+    receiveList[queueid] = cb;
+    this.doReceive();
+  }
+
+  doReceive(): void
+  {
+    for (let queueid in receiveList) if (messageList.hasOwnProperty(queueid))
+    {
+      let q = messageList[queueid];
+      let cb = receiveList[queueid];
+      if (cb !== undefined)
+      {
+        delete messageList[queueid];
+        delete receiveList[queueid];
+        cb(null, q);
+      }
+    }
+  }
+}

package/lib/memsqs/orderedlist.ts

@@ -0,0 +1,74 @@
+export interface OrderedListEntry<T>
+{
+  prev: OrderedListEntry<T>;
+  next: OrderedListEntry<T>;
+  value: T;
+}
+
+export type OrderedListIndex<T> = { [key: string]: OrderedListEntry<T> };
+
+export class OrderedList<T>
+{
+  head: OrderedListEntry<T>;
+  tail: OrderedListEntry<T>;
+  index: OrderedListIndex<T>;
+
+  constructor()
+    {
+      this.clear();
+    }
+
+  isempty(): boolean
+    {
+      return this.head == null;
+    }
+
+  clear(): void
+    {
+      this.head = null;
+      this.tail = null;
+      this.index = {};
+    }
+
+  insert(key: string, value: T): string
+    {
+      if (this.index[key] !== undefined)
+        return `memsqs: send: message uid ${key} already exists`;
+
+      let e: OrderedListEntry<T> = { prev: this.tail, next: null, value: value };
+      if (this.tail)
+        this.tail.next = e;
+      this.tail = e;
+      if (this.head === null)
+        this.head = e;
+      this.index[key] = e;
+      return null;
+    }
+
+  remove(key: string): string
+    {
+      let e = this.index[key];
+      if (e === undefined)
+        return `memsqs: remove: message uid ${key} does not exist`;
+
+      if (e === this.tail)
+        this.tail = e.prev;
+      else
+        e.next.prev = e.prev;
+
+      if (e === this.head)
+        this.head = e.next;
+      else
+        e.prev.next = e.next;
+
+      delete this.index[key];
+
+      return null;
+    }
+
+  forEach(cb: (value: T) => boolean): void
+    {
+      for (let p = this.head; p && cb(p.value); p = p.next)
+        continue;
+    }
+}