@openziti/ziti-sdk-nodejs 0.6.0

package/src/ziti_write.c

@@ -0,0 +1,223 @@
+/*
+Copyright 2019-2020 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.
+*/
+
+#include "ziti-nodejs.h"
+#include <string.h>
+
+
+// An item that will be generated here and passed into the JavaScript write callback
+typedef struct WriteItem {
+  ziti_connection conn;
+  ssize_t status;
+} WriteItem;
+
+
+/**
+ * This function is responsible for calling the JavaScript 'write' callback function 
+ * that was specified when the ziti_write(...) was called from JavaScript.
+ */
+static void CallJs_on_write(napi_env env, napi_value js_cb, void* context, void* data) {
+  napi_status status;
+
+  // This parameter is not used.
+  (void) context;
+
+  // Retrieve the WriteItem created by the worker thread.
+  WriteItem* item = (WriteItem*)data;
+
+  // env and js_cb may both be NULL if Node.js is in its cleanup phase, and
+  // items are left over from earlier thread-safe calls from the worker thread.
+  // When env is NULL, we simply skip over the call into Javascript and free the
+  // items.
+  if (env != NULL) {
+
+    napi_value undefined;
+
+    // const obj = {}
+    napi_value js_write_item, js_conn, js_status;
+    status = napi_create_object(env, &js_write_item);
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_create_object");
+    }
+
+    // obj.conn = conn
+    ZITI_NODEJS_LOG(DEBUG, "conn=%p", item->conn);
+    status = napi_create_int64(env, (int64_t)item->conn, &js_conn);
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_create_int64");
+    }
+    status = napi_set_named_property(env, js_write_item, "conn", js_conn);
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_set_named_property");
+    }
+
+    // obj.status = status
+    ZITI_NODEJS_LOG(DEBUG, "status=%zo", item->status);
+    status = napi_create_int64(env, (int64_t)item->status, &js_status);
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_create_int64");
+    }
+    status = napi_set_named_property(env, js_write_item, "status", js_status);
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_set_named_property");
+    }
+
+    // Retrieve the JavaScript `undefined` value so we can use it as the `this`
+    // value of the JavaScript function call.
+    status = napi_get_undefined(env, &undefined);
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_get_undefined (5)");
+    }
+
+    // Call the JavaScript function and pass it the WriteItem
+    status = napi_call_function(
+        env,
+        undefined,
+        js_cb,
+        1,
+        &js_write_item,
+        NULL);
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_call_function");
+    }
+
+    free(item);
+  }
+}
+
+
+/**
+ * 
+ */
+static void on_write(ziti_connection conn, ssize_t status, void *ctx) {
+
+  ConnAddonData* addon_data = (ConnAddonData*) ziti_conn_data(conn);
+
+  WriteItem* item = memset(malloc(sizeof(*item)), 0, sizeof(*item));
+  item->conn = conn;
+  item->status = status;
+
+  // Initiate the call into the JavaScript callback. 
+  // The call into JavaScript will not have happened 
+  // when this function returns, but it will be queued.
+  napi_status nstatus = napi_call_threadsafe_function(
+      addon_data->tsfn_on_write,
+      item,
+      napi_tsfn_blocking);
+  if (nstatus != napi_ok) {
+    ZITI_NODEJS_LOG(ERROR, "Unable to napi_call_threadsafe_function");
+  }
+}
+
+
+/**
+ * 
+ */
+napi_value _ziti_write(napi_env env, const napi_callback_info info) {
+  napi_status status;
+  size_t argc = 3;
+  napi_value args[3];
+  status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to parse arguments");
+  }
+
+  if (argc < 3) {
+    napi_throw_error(env, "EINVAL", "Too few arguments");
+    return NULL;
+  }
+
+  // Obtain ziti_connection
+  int64_t js_conn;
+  status = napi_get_value_int64(env, args[0], &js_conn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to get Conn");
+  }
+  ziti_connection conn = (ziti_connection)js_conn;
+
+  ConnAddonData* addon_data = (ConnAddonData*) ziti_conn_data(conn);
+
+  // Obtain data to write (we expect a Buffer)
+  void*  buffer;
+  size_t bufferLength;
+  status = napi_get_buffer_info(env, args[1], &buffer, &bufferLength);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to get Buffer info");
+  }
+
+  // Since the underlying Buffer's lifetime is not guaranteed if it's managed by the VM, we will copy the chunk into our heap
+  void* chunk = memset(malloc(bufferLength), 0, bufferLength);
+  memcpy(chunk, buffer, bufferLength);
+
+  // Obtain ptr to JS 'write' callback function
+  napi_value js_write_cb = args[2];
+  napi_value work_name;
+
+  // Create a string to describe this asynchronous operation.
+  status = napi_create_string_utf8(
+    env,
+    "N-API on_write",
+    NAPI_AUTO_LENGTH,
+    &work_name);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to napi_create_string_utf8");
+  }
+
+  // Convert the callback retrieved from JavaScript into a thread-safe function (tsfn) 
+  // which we can call from a worker thread.
+  status = napi_create_threadsafe_function(
+      env,
+      js_write_cb,
+      NULL,
+      work_name,
+      0,
+      1,
+      NULL,
+      NULL,
+      NULL,
+      CallJs_on_write,
+      &(addon_data->tsfn_on_write));
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to napi_create_threadsafe_function");
+  }
+
+  // Now, call the C-SDK to actually write the data over to the service
+  ziti_write(conn, chunk, bufferLength, on_write, NULL);
+
+  return NULL;
+}
+
+
+
+/**
+ * 
+ */
+void expose_ziti_write(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_value fn;
+
+  status = napi_create_function(env, NULL, 0, _ziti_write, NULL, &fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to wrap native function '_ziti_write");
+  }
+
+  status = napi_set_named_property(env, exports, "ziti_write", fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to populate exports for 'ziti_write");
+  }
+
+}
+

package/tests/enroll-test.js

@@ -0,0 +1,38 @@
+
+var binary = require('@mapbox/node-pre-gyp');
+var path = require('path')
+var binding_path = binary.find(path.resolve(path.join(__dirname,'../package.json')), {debug: true});
+// var binding_path = binary.find(path.resolve(path.join(__dirname,'../package.json')));
+var ziti = require(binding_path);
+require('assert').equal(ziti.ziti_hello(),"ziti");
+
+
+
+const ziti_enroll = async (jwt_path) => {
+    return new Promise((resolve, reject) => {
+        let rc = ziti.ziti_enroll(jwt_path, (data) => {
+            if (data.identity) {
+                resolve(data);
+            } else {
+                reject(data);
+            }
+        });
+    });
+};
+
+
+(async () => {
+
+    let jwt_path = process.argv[2];
+
+    let data = await ziti_enroll(jwt_path).catch((data) => {
+        console.log('NF_enroll failed with error code (%o)', data.len);
+    });
+
+    if (data && data.identity) {
+        console.log("data.identity is:\n\n%s", data.identity);
+    }
+
+    process.exit(0);
+
+})();

package/tests/hello.js

@@ -0,0 +1,12 @@
+
+const binary = require('@mapbox/node-pre-gyp');
+const path = require('path')
+// const binding_path = binary.find(path.resolve(path.join(__dirname,'../package.json')), {debug: true});
+const binding_path = binary.find(path.resolve(path.join(__dirname,'../package.json')));
+console.log("binding_path is: ", binding_path);
+const ziti = require(binding_path);
+console.log("ziti native addon is: \n", ziti);
+const result = ziti.ziti_hello();
+console.log("ziti_hello() result is: ", result);
+require('assert').equal(result,"ziti");
+console.log("SUCCESS");

package/tests/https-test.js

@@ -0,0 +1,206 @@
+
+var binary = require('@mapbox/node-pre-gyp');
+var path = require('path')
+// var binding_path = binary.find(path.resolve(path.join(__dirname,'../package.json')), {debug: true});
+var binding_path = binary.find(path.resolve(path.join(__dirname,'../package.json')));
+var ziti = require(binding_path);
+require('assert').equal(ziti.ziti_hello(),"ziti");
+
+
+
+const Ziti_http_request = async (url, method, headers) => {
+    return new Promise((resolve, reject) => {
+        try {
+
+            console.log('headers (%o)', headers);
+
+            let req = ziti.Ziti_http_request(
+                url,
+                method,
+                headers,
+                // on_req callback
+                (obj) => {
+                    console.log('----------- Now inside Ziti_http_request on_req callback ----------, obj is: \n%o', obj);
+                },
+                // on_resp callback
+                (obj) => {
+                    console.log('----------- Now inside Ziti_http_request on_resp callback ----------, obj is: \n%o', obj);
+                    // resolve(obj);
+                },
+                // on_resp_data callback
+                (obj) => {
+                    console.log('----------- Now inside Ziti_http_request on_resp_data callback ----------, obj is: \n%o', obj);
+                    console.log('----------- obj.body is: \n%o', obj.body.toString());
+                },
+            );
+
+            console.log('inside JS Ziti_http_request(), req is (%o)', req);
+            resolve(req);
+
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+
+const Ziti_http_request_data = async (req, buffer) => {
+    return new Promise((resolve, reject) => {
+        ziti.Ziti_http_request_data(
+            req,
+            buffer,
+            // on_req_data callback
+            (obj) => {
+                console.log('----------- Now inside Ziti_http_request_data on_req_data callback ----------, obj is: \n%o', obj);
+                resolve(obj);
+            }
+        );
+    });
+}
+
+const NF_init = async () => {
+    return new Promise((resolve) => {
+        ziti.ziti_init(process.argv[2], () => {
+            resolve();
+        });
+    });
+};
+
+let ctr = 0;
+const spin = () => {
+    setTimeout( () => {
+        ctr++;
+        console.log("1-sec wait, ctr=%d", ctr); 
+        if (ctr < 60) {
+            spin();
+        } else {
+            process.exit(0);
+        }
+    }, 1000);
+}
+
+// let chunkctr = 0;
+let chunkBody = process.argv[5];
+
+// const sendChunk = (req) => {
+//     setTimeout( (req) => {
+//         chunkctr++;
+//         console.log("chunkctr=%d", chunkctr); 
+//         if (chunkctr < 10) {
+            
+//             buffer = Buffer.from(chunkBody + "-" + chunkctr);
+
+//             console.log("sending chunk %d", chunkctr);
+
+//             Ziti_http_request_data(req, buffer);
+
+//             sendChunk(req);
+
+//         } else {
+//             console.log("======== calling Ziti_http_request_end");
+//             ziti.Ziti_http_request_end( req );
+//         }
+//     }, 500, req);
+// }
+
+const sendChunk = (req) => {
+    setTimeout( (req) => {
+        buffer = Buffer.from(chunkBody);
+        console.log("sending chunk");
+        Ziti_http_request_data(req, buffer);
+    }, 500, req);
+}
+
+
+
+(async () => {
+
+    let url = process.argv[3];
+    let method = process.argv[4];
+    let body = process.argv[5];
+    let buffer;
+    let results;
+    let headersArray = [
+        "Content-Length:1",
+        "Transfer-Encoding:chunked",
+    ];
+
+
+    await NF_init();
+
+    if (typeof body !== 'undefined') {
+
+        buffer = Buffer.from("1");
+
+        console.log("Sending 'body' of: %o", buffer);
+
+        let req = await Ziti_http_request(url, method, headersArray).catch((err) => {
+            console.log('Ziti_http_request failed with error (%o)', err);
+            process.exit(-1);
+        });
+
+        console.log("Ziti_http_request results is:\n\n%o", req);
+   
+    
+        for (let i = 0; i < 10; i++) {
+            console.log("queueing chunk %d", i);
+
+            results = await Ziti_http_request_data(req, buffer).catch((err) => {
+                console.log('Ziti_http_request_data failed with error (%o)', err);
+                process.exit(-1);
+            });
+    
+        }
+
+        console.log('========================================================================================================');
+        console.log('======================================== Ziti_http_request_end called ==================================');
+        ziti.Ziti_http_request_end( req );
+        console.log('========================================================================================================');
+
+    } else {
+
+        console.log("No 'body' will be sent");
+
+
+        let req = await Ziti_http_request(url, method, []).catch((err) => {
+            console.log('Ziti_http_request failed with error (%o)', err);
+            process.exit(-1);
+        });
+
+        console.log('inside JS main(), req is (%o)', req);
+
+
+        // setTimeout( async () => {
+        
+        for (let i=0; i<3; i++ ) {
+
+            let req2 = await Ziti_http_request(url, method, []).catch((err) => {
+                console.log('Ziti_http_request failed with error (%o)', err);
+                process.exit(-1);
+            });
+    
+            console.log('inside JS main() setTimeout(), req is (%o)', req2);
+
+        }
+
+        // }, 100);
+    
+        // let req2 = await Ziti_http_request(url, method, []).catch((err) => {
+        //     console.log('Ziti_http_request failed with error (%o)', err);
+        //     process.exit(-1);
+        // });
+
+        // console.log("Ziti_http_request results is:\n\n%o", req2);
+
+        // console.log('========================================================================================================');
+        // console.log('======================================== Ziti_http_request_end called ==================================');
+        // ziti.Ziti_http_request_end( req );
+        // console.log('========================================================================================================');
+
+
+    }
+
+
+    spin();
+
+})();

package/tests/mattermost-test.js

@@ -0,0 +1,124 @@
+
+var binary = require('@mapbox/node-pre-gyp');
+var path = require('path')
+var binding_path = binary.find(path.resolve(path.join(__dirname,'../package.json')));
+var ziti = require(binding_path);
+require('assert').equal(ziti.ziti_hello(),"ziti");
+
+
+
+function NF_dial(service) {
+    console.log('----------- inside NF_dial() ---------- service is: ', service);
+    return new Promise((resolve, reject) => {
+        ziti.ziti_dial(
+        service,
+        false, // NOT a wabsocket
+        (conn) => {
+          console.log('----------- Now inside NF_dial connect callback ----------, conn is: ' + conn);
+          resolve(conn);
+        },
+        (data) => {
+          console.log('----------- Now inside NF_dial data callback ----------, data is: [===\n%s\n===]', data);
+        },
+      );
+    });
+  }
+
+const rand = max => Math.floor(Math.random() * max);
+const delay = (ms, value) => new Promise(resolve => setTimeout(resolve, ms, value));
+
+const NF_init = async () => {
+    return new Promise((resolve) => {
+        ziti.ziti_init(process.argv[2], () => {
+            resolve();
+        });
+    });
+};
+
+const NF_service_available = (service) => {
+    return new Promise((resolve) => {
+        ziti.ziti_service_available(service, (status) => {
+            resolve(status);
+        });
+    });
+};
+
+const NF_write = (conn, data) => {
+    return new Promise((resolve) => {
+        ziti.ziti_write(conn, data, () => {
+            resolve();
+        });
+    });
+};
+
+let ctr = 0;
+const spin = () => {
+    setTimeout( () => {
+        ctr++;
+        console.log("1-sec wait, ctr=%d", ctr); 
+        if (ctr < 5) {
+            spin();
+        } else {
+            process.exit(0);
+        }
+    }, 1000);
+}
+
+
+function NF_write_callback(item) {
+    if (item.status < 0) {
+        // console.log("NF_write_callback(): request performed on conn '%o' failed to submit status '%o'", item.conn, item.status);
+    }
+    else {
+        // console.log("NF_write_callback(): request performed on conn '%o' successful: '%o' bytes sent", item.conn, item.status);
+    }
+}
+
+function NF_dial_connect_callback(conn) {
+
+    console.log("NF_dial_connect_callback(): received connection '%o'; now initiating Write to service", conn);
+
+    let data = 
+        "GET / " +
+        "HTTP/1.1\r\n" +
+        "Accept: */*\r\n" +
+        "Connection: keep-alive\r\n" +
+        "Host: mattermost.ziti.netfoundry.io\r\n" +
+        "User-Agent: curl/7.54.0\r\n" +
+        "\r\n";
+
+    ziti.ziti_write(
+        conn, 
+        data, 
+        NF_write_callback
+    );
+}
+
+function NF_dial_data_callback(data) {
+    console.log("NF_dial_data_callback(): received the following data: \n\n", data);
+}
+
+(async () => {
+
+    await NF_init();
+
+    let status = await NF_service_available('mattermost.ziti.netfoundry.io');
+
+    let conn = await NF_dial('mattermost.ziti.netfoundry.io');
+
+    let data = 
+        "GET / " +
+        "HTTP/1.1\r\n" +
+        "Accept: */*\r\n" +
+        "Connection: keep-alive\r\n" +
+        "Host: mattermost.ziti.netfoundry.io\r\n" +
+        "User-Agent: curl/7.54.0\r\n" +
+        "\r\n";
+
+    let buffer = Buffer.from(data);
+
+    await NF_write(conn, buffer);
+
+    spin();
+
+})();