@openziti/ziti-sdk-nodejs 0.7.0 → 0.9.1

package/.github/workflows/build.yml

@@ -30,7 +30,7 @@ jobs:
     strategy:
       matrix:
         config:
-          # - { name: "Win", os: windows-latest, cc: "cl",    cxx: "cl" }
+          # - { os: windows-latest, cc: "cl",    cxx: "cl", node: '16' }
           - { os: ubuntu-18.04,   cc: "gcc",   cxx: "g++", node: '12' }
           - { os: ubuntu-18.04,   cc: "gcc",   cxx: "g++", node: '13' }
           - { os: ubuntu-18.04,   cc: "gcc",   cxx: "g++", node: '14' }
@@ -197,19 +197,12 @@ jobs:
       run: |
         npm run build:cleanup
 
-    - name: Publish Binary to S3 (Mac)
+    - name: Publish Binary to S3 (for all OS's, Node versions, and architectures)
       run: |
         ./node_modules/.bin/node-pre-gyp package unpublish publish
         sleep 5
       if: |
-        steps.extract_branch.outputs.branch == 'main' && matrix.config.os == 'macOS-latest'
-
-    - name: Publish Binary to S3 (Linux)
-      run: |
-        ./node_modules/.bin/node-pre-gyp package unpublish publish
-        sleep 5
-      if: |
-        steps.extract_branch.outputs.branch == 'main' && matrix.config.os == 'ubuntu-18.04' && matrix.config.node != '14'
+        steps.extract_branch.outputs.branch == 'main' 
 
     - name: Install Binary
       run: |
@@ -228,4 +221,4 @@ jobs:
         token: ${{ secrets.NPM_TOKEN }}
         access: public
       if: |
-        matrix.config.os == 'ubuntu-18.04' && matrix.config.node == '14' && steps.extract_branch.outputs.branch == 'main'
+        matrix.config.os == 'ubuntu-18.04' && matrix.config.node == '16' && matrix.architecture == 'x64' && steps.extract_branch.outputs.branch == 'main'

package/binding.gyp

@@ -36,6 +36,7 @@
         "./src/Ziti_https_request_data.c",
         "./src/Ziti_https_request_end.c",
         "./src/ziti_init.c",
+        "./src/ziti_listen.c",
         "./src/ziti_service_available.c",
         "./src/ziti_shutdown.c",
         "./src/ziti_write.c",
@@ -105,18 +106,19 @@
             "GCC_ENABLE_PASCAL_STRINGS": "NO",        # No -mpascal-strings
             "GCC_THREADSAFE_STATICS": "NO",           # -fno-threadsafe-statics
             "PREBINDING": "NO",                       # No -Wl,-prebind
-            "MACOSX_DEPLOYMENT_TARGET": "10.15",      # -mmacosx-version-min=10.14
+            "MACOSX_DEPLOYMENT_TARGET": "12",         # -mmacosx-version-min=10.14
             "USE_HEADERMAP": "NO",
             "OTHER_CFLAGS": [
               "-fno-strict-aliasing",
               "-g",
               "-fno-pie",
               "-DSOURCE_PATH_SIZE=3",
-              "-DZITI_OS=macos"
+              "-DZITI_OS=macos",
+              "-DCXXFLAGS=-mmacosx-version-min=11",
             ],
             "OTHER_LDFLAGS": [
               "-g",
-              "-mmacosx-version-min=10.15",
+              "-mmacosx-version-min=11",
             ],
             "WARNING_CFLAGS": [
               "-Wall",

package/lib/close.js

@@ -0,0 +1,29 @@
+/*
+Copyright Netfoundry, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+
+/**
+ * close()   
+ * 
+ * @param {*} conn 
+ */
+const close = ( conn,  ) => {
+
+  ziti.ziti_close( conn );
+
+};
+
+exports.close = close;

package/lib/express-listener.js

@@ -0,0 +1,253 @@
+/*
+Copyright Netfoundry, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const zitiListen = require('./listen').listen;
+const EventEmitter = require('events');
+const { ZitiSocket } = require('./ziti-socket');
+
+
+const normalizedArgsSymbol = Symbol('normalizedArgs');
+
+
+var _serversIndex = 1;
+var _servers = new Map();
+
+/**
+ * on_listen()   
+ * 
+ * @param {*} status 
+ */
+Server.prototype.on_listen = ( status ) => {
+
+};
+  
+/**
+ * on_listen_client()   
+ * 
+ * @param {*} obj 
+ */
+ Server.prototype.on_listen_client = ( obj ) => {
+  
+};
+  
+/**
+ * on_client_write()   
+ * 
+ * @param {*} obj 
+ */
+ Server.prototype.on_client_write = ( obj ) => {
+    
+};
+
+/**
+ * on_listen_client_connect()   
+ * 
+ * @param {*} obj 
+ */
+ Server.prototype.on_listen_client_connect = ( obj ) => {
+  
+    let self = _servers.get(obj.js_arb_data);
+
+    const socket = new ZitiSocket({ client: obj.client });
+
+    self._socket = socket;
+        
+    self.emit('connection', socket);
+};
+
+/**
+ * on_listen_client_data()   
+ * 
+ * @param {*} obj 
+ */
+ Server.prototype.on_listen_client_data = ( obj ) => {
+    
+    let self    = _servers.get(obj.js_arb_data);
+    let socket  = self._socket;
+
+    socket.captureData(obj.app_data);
+};
+  
+
+/**
+ * 
+ * @param {*} args 
+ * @returns 
+ */
+function normalizeArgs(args) {
+    let arr;
+  
+    if (args.length === 0) {
+      arr = [{}, null];
+      arr[normalizedArgsSymbol] = true;
+      return arr;
+    }
+  
+    const arg0 = args[0];
+    let options = {};
+    if (typeof arg0 === 'object' && arg0 !== null) {
+      // (options[...][, cb])
+      options = arg0;
+    } else {
+      // ([port][, host][...][, cb])
+      options.port = arg0;
+      if (args.length > 1 && typeof args[1] === 'string') {
+        options.host = args[1];
+      }
+    }
+  
+    const cb = args[args.length - 1];
+    if (typeof cb !== 'function')
+      arr = [options, null];
+    else
+      arr = [options, cb];
+  
+    arr[normalizedArgsSymbol] = true;
+    return arr;
+}
+  
+function Server(serviceName, options, connectionListener) {
+
+    if (!(this instanceof Server))
+      return new Server(options, connectionListener);
+  
+    EventEmitter.call(this);
+  
+    if (typeof options === 'function') {
+      connectionListener = options;
+      options = {};
+      this.on('connection', connectionListener);
+    } else if (options == null || typeof options === 'object') {
+      options = { ...options };
+  
+      if (typeof connectionListener === 'function') {
+        this.on('connection', connectionListener);
+      }
+    } else {
+      throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
+    }
+    if (typeof options.keepAliveInitialDelay !== 'undefined') {
+      validateNumber(
+        options.keepAliveInitialDelay, 'options.keepAliveInitialDelay'
+      );
+  
+      if (options.keepAliveInitialDelay < 0) {
+        options.keepAliveInitialDelay = 0;
+      }
+    }
+
+    this._serviceName = serviceName;
+
+    this._connections = 0;
+  
+    // this[async_id_symbol] = -1;
+    this._handle = null;
+    this._usingWorkers = false;
+    this._workers = [];
+    this._unref = false;
+  
+    this.allowHalfOpen = options.allowHalfOpen || false;
+    this.pauseOnConnect = !!options.pauseOnConnect;
+    this.noDelay = Boolean(options.noDelay);
+    this.keepAlive = Boolean(options.keepAlive);
+    this.keepAliveInitialDelay = ~~(options.keepAliveInitialDelay / 1000);
+}
+Object.setPrototypeOf(Server.prototype, EventEmitter.prototype);
+Object.setPrototypeOf(Server, EventEmitter);
+  
+
+Server.prototype.listen = function( serviceName, ...args ) {
+
+    let normalized = normalizeArgs(args);
+    normalized = normalizeArgs(normalized[0]);
+
+    // let options = normalized[0];             // we currently ignore options (a.k.a. `port`)
+    let cb = normalized[1];
+    if (cb === null) { cb = this.on_listen; }   // Use our on_listen cb is necessary, else use cb from teh calling app
+
+    let index = _serversIndex++;
+    _servers.set(index, this);
+
+    zitiListen( serviceName, index, cb, this.on_listen_client, this.on_listen_client_connect, this.on_listen_client_data );
+};
+
+Server.prototype.address = function() {
+    if (this._handle && this._handle.getsockname) {
+      const out = {};
+      const err = this._handle.getsockname(out);
+      if (err) {
+        throw errnoException(err, 'address');
+      }
+      return out;
+    } else if (this._pipeName) {
+      return this._pipeName;
+    }
+    return null;
+};
+  
+Server.prototype.close = function(cb) {
+    if (typeof cb === 'function') {
+      if (!this._handle) {
+        this.once('close', function close() {
+          cb(new ERR_SERVER_NOT_RUNNING());
+        });
+      } else {
+        this.once('close', cb);
+      }
+    }
+  
+    if (this._handle) {
+      this._handle.close();
+      this._handle = null;
+    }
+  
+    if (this._usingWorkers) {
+      let left = this._workers.length;
+      const onWorkerClose = () => {
+        if (--left !== 0) return;
+  
+        this._connections = 0;
+        this._emitCloseIfDrained();
+      };
+  
+      // Increment connections to be sure that, even if all sockets will be closed
+      // during polling of workers, `close` event will be emitted only once.
+      this._connections++;
+  
+      // Poll workers
+      for (let n = 0; n < this._workers.length; n++)
+        this._workers[n].close(onWorkerClose);
+    } else {
+      this._emitCloseIfDrained();
+    }
+  
+    return this;
+};
+  
+Object.defineProperty(Server.prototype, 'listening', {
+    __proto__: null,
+    get: function() {
+      return !!this._handle;
+    },
+    configurable: true,
+    enumerable: true
+});
+  
+
+module.exports = {
+    Server,
+};
+  

package/lib/express.js

@@ -0,0 +1,58 @@
+/*
+Copyright Netfoundry, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const expressListener = require('./express-listener');
+const { Server } = require('_http_server'); // from NodeJS internals
+
+
+
+/**
+ * express()   
+ * 
+ * @param {*} express 
+ * @param {*} serviceName 
+ */
+const express = ( express, serviceName ) => {
+
+  var wrappedExpressApp = express();
+
+  /**
+   * Listen for connections.
+   *
+   * A node `http.Server` is returned, with this
+   * application (which is a `Function`) as its
+   * callback. 
+   *
+   * @return {http.Server}
+   * @public
+   */  
+  wrappedExpressApp.listen = function() {
+
+    Object.setPrototypeOf(Server.prototype, expressListener.Server.prototype);
+    Object.setPrototypeOf(Server, expressListener.Server);
+    var server = new Server(this);
+
+    expressListener.Server.call( server, serviceName, { } );
+
+    return server.listen(serviceName, arguments);
+
+  };
+
+  return wrappedExpressApp;
+
+};
+
+exports.express = express;

package/lib/index.js

@@ -1,5 +1,5 @@
 /*
-Copyright 2019-2020 Netfoundry, Inc.
+Copyright Netfoundry, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

package/lib/init.js

@@ -0,0 +1,39 @@
+/*
+Copyright Netfoundry, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+
+/**
+ * init()   
+ * 
+ * @param {*} identityPath 
+ * @returns 
+ */
+const init = ( identityPath ) => {
+
+  return new Promise((resolve, reject) => {
+
+      let rc = ziti.ziti_init( identityPath, ( result ) => {
+          return resolve( result );
+      });
+
+      if (rc < 0) {
+        return reject(`ziti.init() failed with return code ${rc}`);
+      }
+      
+  });
+};
+
+exports.init = init;

package/lib/listen.js

@@ -0,0 +1,30 @@
+/*
+Copyright Netfoundry, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+
+/**
+ * listen()   
+ * 
+ * @param {*} identityPath 
+ * @returns 
+ */
+const listen = ( serviceName, js_arb_data, on_listen, on_listen_client, on_client_connect, on_client_data ) => {
+
+  ziti.ziti_listen( serviceName, js_arb_data, on_listen, on_listen_client, on_client_connect, on_client_data );
+
+};
+
+exports.listen = listen;

package/lib/write.js

@@ -0,0 +1,48 @@
+/*
+Copyright Netfoundry, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+
+/**
+ * on_write()   
+ * 
+ */
+const on_write = ( status ) => {
+
+};
+
+
+/**
+ * write()   
+ * 
+ * @param {*} conn 
+ * @param {*} buf 
+ * @param {*} on_write callback 
+ */
+const write = ( conn, buf, on_write_cb ) => {
+
+  let cb;
+
+  if (typeof on_write_cb === 'undefined') {
+    cb = on_write;
+  } else {
+    cb = on_write_cb;
+  }
+
+  ziti.ziti_write( conn, buf, cb );
+
+};
+
+exports.write = write;

package/lib/ziti-socket.js

@@ -0,0 +1,119 @@
+/*
+Copyright Netfoundry, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+const EventEmitter = require('events');
+const stream = require('node:stream');
+const zitiWrite = require('./write').write;
+
+
+
+class ZitiSocket extends EventEmitter {
+
+    constructor(opts) {
+
+        super();
+
+        if (typeof opts !== 'undefined') {
+            if (typeof opts.client !== 'undefined') {
+                this.client = opts.client;
+            }
+        }
+
+        this._writableState = new stream.Writable.WritableState({}, this, true);
+         
+        /**
+         * This stream is where we'll put any data returned from Ziti (see on_listen_client_data cb)
+         */
+        let self = this;
+        this.readableZitiStream = new ReadableStream({
+            start(controller) {
+                self.readableZitiStreamController = controller;
+            }
+        });
+    }
+
+
+    /**
+     * 
+     */
+    captureData(data) {
+
+        if ((typeof data !== 'undefined') && (data.byteLength > 0)) {
+
+            this.readableZitiStreamController.enqueue(data);
+            this.emit('data', data);
+
+        } else {
+
+            this.emit('close');
+
+        }
+    }
+     
+
+    /**
+     * Implements the writeable stream method `_write` by pushing the data onto the underlying Ziti connection.
+    */
+    async write(chunk, encoding, cb) {
+
+        let buffer;
+
+        if (typeof chunk === 'string' || chunk instanceof String) {
+            buffer = Buffer.from(chunk, 'utf8');
+        } else if (Buffer.isBuffer(chunk)) {
+            buffer = chunk;
+        } else if (chunk instanceof Uint8Array) {
+            buffer = Buffer.from(chunk, 'utf8');
+        } else {
+            throw new Error('chunk type of [' + typeof chunk + '] is not a supported type');
+        }
+
+        if (buffer.length > 0) {
+            zitiWrite(this.client, buffer);
+        }
+        if (cb) {
+            cb();
+        }
+    }
+
+    /**
+     *
+     */
+    _read() { /* NOP */ }
+    read()  { /* NOP */ }
+    destroy() { /* NOP */ } 
+    cork() { /* NOP */ }
+    uncork() { /* NOP */ }
+    pause() { /* NOP */ }
+    resume() { /* NOP */ }
+    destroy() { /* NOP */ }
+    end(data, encoding, callback) { /* NOP */ }
+    _final(cb) { cb(); }
+    setTimeout() { /* NOP */ }
+    setNoDelay() { /* NOP */ }
+    unshift(head) { /* NOP */ }
+}
+
+Object.defineProperty(ZitiSocket.prototype, 'writable', {
+    get() {
+      return (
+        true
+      );
+    }
+});
+
+
+exports.ZitiSocket = ZitiSocket;

package/lib/ziti.js

@@ -1,5 +1,5 @@
 /*
-Copyright 2019-2020 Netfoundry, Inc.
+Copyright Netfoundry, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,14 +18,13 @@ var binding;
 
 function importAll (r) {
   r.keys().forEach(key => {
-    console.log('importAll() addon key is: ', key);
     binding = r(key); // Load the addon
   });
 }
 
 if (typeof require.context == 'function') {
 
-    importAll( require.context("../build/", true, /\.node$/) );
+  importAll( require.context("../build/", true, /\.node$/) );
 
 } else {
 
@@ -37,4 +36,15 @@ if (typeof require.context == 'function') {
     
 }
 
-var ziti = module.exports = exports = binding;
+ziti = module.exports = exports = binding;
+
+
+
+/**
+ *  Attach the external, app-facing, API to the 'ziti' object
+ */
+exports.close     = require('./close').close;
+exports.express   = require('./express').express;
+exports.init      = require('./init').init;
+exports.listen    = require('./listen').listen;
+exports.write     = require('./write').write;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openziti/ziti-sdk-nodejs",
   "description": "A NodeJS-based SDK for delivering secure applications over a Ziti Network",
-  "version": "0.7.0",
+  "version": "0.9.1",
   "main": "./lib/ziti",
   "scripts": {
     "build": "npm run build:init; npm run build:c-sdk; npm install --build-from-source --clang=1",