@dra2020/baseclient 1.0.13 → 1.0.14

package/lib/lambda/all.ts

@@ -0,0 +1 @@
+export * from './lambda';

package/lib/lambda/env.ts

@@ -0,0 +1,13 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+
+import * as Lambda from './lambda';
+
+export interface Environment
+{
+  context: Context.IContext,
+  log: LogAbstract.ILog,
+  fsmManager: FSM.FsmManager;
+  lambdaManager: Lambda.Manager;
+}

package/lib/lambda/lambda.ts

@@ -0,0 +1,120 @@
+// Shared libraries
+import * as Util from '../util/all';
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+
+import { Environment } from './env';
+
+import * as Lambda from 'aws-sdk/clients/lambda';
+
+class FsmList extends FSM.Fsm
+{
+  constructor(env: Environment)
+  {
+    super(env);
+  }
+
+  get env(): Environment { return this._env as Environment }
+
+  tick(): void
+  {
+    if (this.ready && this.state === FSM.FSM_STARTING)
+    {
+      this.setState(FSM.FSM_PENDING);
+      this.env.lambdaManager.awslambda.listFunctions({}, (err: any, data: any) => {
+          if (err)
+          {
+            this.env.log.chatter(`listFunctions: failed: ${JSON.stringify(err)}`);
+          }
+          else
+          {
+            this.env.log.chatter(`listFunctions: success: ${JSON.stringify(data)}`);
+          }
+          this.setState(err ? FSM.FSM_ERROR : FSM.FSM_DONE);
+        });
+    }
+  }
+}
+
+export class FsmInvoke extends FSM.Fsm
+{
+  name: string;
+  params: any;
+  result: any;
+
+  constructor(env: Environment, name: string, params: any)
+  {
+    super(env);
+    this.name = name;
+    this.params = Util.shallowAssignImmutable({ context: { production: env.context.xnumber('production') } }, params);
+  }
+
+  get env(): Environment { return this._env as Environment }
+
+  tick(): void
+  {
+    if (this.ready && this.state === FSM.FSM_STARTING)
+    {
+      this.setState(FSM.FSM_PENDING);
+      let awsparam: any = {
+        FunctionName: `${this.name}:${this.env.context.xflag('production') ? 'production' : 'development'}`,
+        InvocationType: 'RequestResponse',
+        LogType: 'None',
+        Payload: JSON.stringify(this.params)
+        };
+      this.env.lambdaManager.awslambda.invoke(awsparam, (err: any, data: any) => {
+          let payload: any = data && data.Payload ? data.Payload : null;
+          try
+          {
+            this.result = (typeof payload === 'string') ? JSON.parse(payload) : payload;
+          }
+          catch (exception)
+          {
+            this.result = payload;
+          }
+          if (err)
+          {
+            this.env.log.chatter(`lambdamanager: invoke ${this.name} error: ${JSON.stringify(err)}`);
+            this.env.log.error({ event: 'lambdamanager: invoke error', detail: JSON.stringify(this.result) });
+            this.setState(FSM.FSM_ERROR);
+          }
+          else if (this.result && this.result.errorMessage)
+          {
+            this.result = { result: 1, message: this.result.errorMessage };
+            this.env.log.chatter(`lambdamanager: invoke failure: ${this.name}`);
+            this.env.log.event(`lambdamanager: invoke failure: ${this.name}`);
+            this.setState(FSM.FSM_ERROR);
+          }
+          else
+          {
+            this.env.log.event(`lambdamanager: invoke success: ${this.name}`);
+            this.setState(FSM.FSM_DONE);
+          }
+        });
+    }
+  }
+}
+
+export class Manager extends FSM.Fsm
+{
+  awslambda: Lambda;
+
+  constructor(env: Environment)
+  {
+    super(env);
+    this.awslambda = new Lambda({ apiVersion: '2015-03-31', region: 'us-west-2' });
+  }
+
+  get env(): Environment { return this._env as Environment }
+
+  invoke(name: string, params?: any): FsmInvoke
+  {
+    return new FsmInvoke(this.env, name, params);
+  }
+}
+
+export function create(env: Environment): Manager
+{
+  return new Manager(env);
+}

package/lib/logabstract/all.ts

@@ -0,0 +1 @@
+export * from './log';

package/lib/logabstract/log.ts

@@ -0,0 +1,55 @@
+import * as Util from '../util/all';
+import * as FSM from '../fsm/all';
+
+export interface ILog
+{
+  dump: () => FSM.Fsm;
+  stamp: (o: any) => void;
+  log: (o: any, verbosity?: number) => void;
+  event: (o: any, verbosity?: number) => void;
+  error: (o: any) => void;
+  value: (o: any, verbosity?: number) => void;
+  chatter: (s: string) => void;
+  chatters: () => string[];
+}
+
+export class Timer
+{
+  ilog: ILog;
+  o: any;
+  verbosity: number;
+  elapsed: Util.Elapsed;
+
+  constructor(ilog: ILog, kind: string, o: any, verbosity: number = 0)
+  {
+    this.ilog = ilog;
+    if (typeof o === 'string') o = { event: o };
+    this.o = o;
+    this.o.kind = kind;
+    this.verbosity = verbosity;
+    this.elapsed = new Util.Elapsed();
+  }
+
+  log(): void
+  {
+    this.elapsed.end();
+    this.o.ms = this.elapsed.ms();
+    this.ilog.log(this.o, this.verbosity);
+  }
+}
+
+export class AsyncTimer extends Timer
+{
+  constructor(ilog: ILog, o: any, verbosity: number = 0)
+  {
+    super(ilog, 'async', o, verbosity);
+  }
+}
+
+export class SyncTimer extends Timer
+{
+  constructor(ilog: ILog, o: any, verbosity: number = 0)
+  {
+    super(ilog, 'sync', o, verbosity);
+  }
+}

package/lib/logclient/all.ts

@@ -0,0 +1 @@
+export * from './log';

package/lib/logclient/log.ts

@@ -0,0 +1,105 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as Util from '../util/all';
+import * as FSM from '../fsm/all';
+
+export interface LogEnvironment
+{
+  context: Context.IContext;
+}
+
+class LogManager implements LogAbstract.ILog
+{
+  env: LogEnvironment;
+  count: number;
+
+  constructor(env: LogEnvironment)
+  {
+    this.env = env;
+    this.count = 0;
+  }
+
+  dump(): FSM.Fsm { return null; }
+
+  print(o: any): void
+  {
+    let sa: string[] = [];
+
+    if (o._count !== undefined)
+      sa.push(String(o._count));
+    if (o.kind === 'error')
+    {
+      sa.push('error');
+      sa.push(o.event);
+    }
+    else if (o.kind !== 'value')
+    {
+      sa.push('info');
+      sa.push(o.event);
+    }
+    else
+    {
+      sa.push('value');
+      sa.push(o.event);
+      sa.push(String(o.value));
+    }
+    if (o.detail !== undefined)
+      sa.push(o.detail);
+    console.log(sa.join(': '));
+  }
+
+  stamp(o: any): void
+  {
+    this.log(o);
+  }
+
+  log(o: any, verbosity: number = 0): void
+  {
+    // Show some restraint
+    if (verbosity > this.env.context.xnumber('verbosity'))
+      return;
+
+    // Inject some standard properties
+    o._time = Util.Now();
+    o._count = this.count++;
+    if (o.kind === undefined)
+      o.kind = 'misc';
+    this.print(o);
+  }
+
+
+  event(o: any, verbosity: number = 0): void
+  {
+    if (typeof o === 'string') o = { event: o };
+    o.kind = 'event';
+    this.log(o, verbosity);
+  }
+
+  error(o: any): void
+  {
+    if (typeof o === 'string') o = { event: o };
+    o.kind = 'error';
+    this.log(o);
+  }
+
+  value(o: any, verbosity: number = 0): void
+  {
+    o.kind = 'value';
+    this.log(o, verbosity);
+  }
+
+  chatter(s: string): void
+  {
+    console.log(s);
+  }
+
+  chatters(): string[]
+  {
+    return null;
+  }
+}
+
+export function create(env: LogEnvironment): LogAbstract.ILog
+{
+  return new LogManager(env);
+}

package/lib/logserver/all.ts

@@ -0,0 +1,5 @@
+export * from './log';
+export * from './logkey';
+export * from './logblob';
+export * from './logaccum';
+export * from './logconcat';