fix wasm regular http import, typos

Author: tysonrm

forkrun.c

@@ -1,31 +1,30 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
 #include <sys/types.h>
+#include <unistd.h>
 
 #define BUFSIZE 256
 
-char* envvar_cmd = "FORKRUN_CMD";
-char* envvar_arg = "FORKRUN_ARG";
+char *envvar_cmd = "FORKRUN_CMD";
+char *envvar_arg = "FORKRUN_ARG";
 char cmd[BUFSIZE];
 char arg[BUFSIZE];
 
-int main (void) {
-    pid_t pid;    
-    
-    if ((pid = fork()) == 0) {
-        snprintf(cmd, BUFSIZE, "%s", getenv(envvar_cmd));
-        snprintf(arg, BUFSIZE, "%s", getenv(envvar_arg));
-        char* const argv[] = { cmd, arg, NULL };
+int main(void) {
+  pid_t pid;
+  if ((pid = fork()) == 0) {
+    snprintf(cmd, BUFSIZE, "%s", getenv(envvar_cmd));
+    snprintf(arg, BUFSIZE, "%s", getenv(envvar_arg));
+    char *const argv[] = {cmd, arg, NULL};
 
-        if (execv(cmd, argv) < 0) {
-            perror("execv error");
-        }
-    } else if (pid < 0) {
-        perror("fork error");
-    } else {
-        return EXIT_SUCCESS;
+    if (execv(cmd, argv) < 0) {
+      perror("execv error");
     }
+  } else if (pid < 0) {
+    perror("fork error");
+  } else {
+    return EXIT_SUCCESS;
+  }
 
-    return EXIT_FAILURE;
+  return EXIT_FAILURE;
 }

src/adapters/datasources/datasource-mongodb.js

@@ -15,9 +15,10 @@ const url = process.env.MONGODB_URL || 'mongodb://localhost:27017'
 const configRoot = require('../../config').hostConfig
 const dsOptions = configRoot.adapters.datasources.DataSourceMongoDb.options || {
   runOffline: true,
-  numConns: 2,
+  numConns: 2
 }
 const cacheSize = configRoot.adapters.cacheSize || 3000
+let connPool
 
 /**
  * @type {Map<string,MongoClient>}
@@ -35,55 +36,64 @@ const mongoOpts = {
  * even when the database is offline.
  */
 export class DataSourceMongoDb extends DataSource {
-  constructor(map, name, namespace, options = {}) {
+  constructor (map, name, namespace, options = {}) {
     super(map, name, namespace, options)
     this.cacheSize = cacheSize
     this.mongoOpts = mongoOpts
     this.runOffline = dsOptions.runOffline
     this.url = url
   }
 
-  connect(client) {
-    return async function () {
-      let timeout = false
-      const timerId = setTimeout(() => {
-        timeout = true
-      }, 500)
-      await client.connect()
-      clearTimeout(timerId)
-      if (timeout) throw new Error('mongo conn timeout')
-    }
-  }
-
-  async connectionPool() {
+  /**
+   *
+   * @returns {Promise<import('mongodb').Db>}
+   */
+  async connectionPool () {
     return new Promise((resolve, reject) => {
       if (this.db) return resolve(this.db)
       MongoClient.connect(
         this.url,
         {
           ...this.mongoOpts,
           poolSize: dsOptions.numConns || 2,
+          connectTimeoutMS: 500
         },
-        (err, database) => {
+        (err, db) => {
           if (err) return reject(err)
-          resolve((this.db = database.db(this.namespace)))
+          this.db = db(this.namespace)
+          resolve(this.db)
         }
       )
     })
   }
 
-  async connection() {
+  connect (client) {
+    return async function () {
+      let timeout = false
+      const timerId = setTimeout(() => {
+        timeout = true
+      }, 500)
+      await client.connect()
+      clearTimeout(timerId)
+      if (timeout) throw new Error('mongo conn timeout')
+    }
+  }
+
+  async connection () {
     try {
       while (connections.length < (dsOptions.numConns || 1)) {
-        const client = new MongoClient(this.url, this.mongoOpts)
+        const client = new MongoClient(this.url, {
+          ...this.mongoOpts,
+          connectTimeoutMS: 500
+        })
         const thresholds = {
           default: {
             errorRate: 1,
             callVolume: 1,
             intervalMs: 10000,
             testDelay: 300000,
-            //fallbackFn: () => client.emit('connectionClosed')
-          },
+            fallbackFn: () => console.log('circuit open')
+          }
         }
         const breaker = CircuitBreaker(
           'mongodb.connect',
@@ -104,17 +114,18 @@ export class DataSourceMongoDb extends DataSource {
     }
   }
 
-  async collection() {
+  async collection () {
     try {
       return (await this.connection()).db(this.namespace).collection(this.name)
+      // return (await this.connectionPool()).collection(this.name)
     } catch {}
   }
 
-  async find(id) {
+  async find (id) {
     try {
       return (await this.collection()).findOne({ _id: id })
     } catch (error) {
-      console.error({ fn: this.findDb.name, error })
+      console.error({ fn: this.find.name, error })
     }
   }
 
@@ -128,7 +139,7 @@ export class DataSourceMongoDb extends DataSource {
    * @param {*} id
    * @param {*} data
    */
-  async save(id, data) {
+  async save (id, data) {
     try {
       const col = await this.collection()
       col.replaceOne({ _id: id }, { ...data, _id: id }, { upsert: true })
@@ -150,19 +161,19 @@ export class DataSourceMongoDb extends DataSource {
    * @param {number} highWaterMark num of docs per batch write
    * @returns
    */
-  createWriteStream(filter = {}, highWaterMark = HIGHWATERMARK) {
+  createWriteStream (filter = {}, highWaterMark = HIGHWATERMARK) {
     try {
       let objects = []
       const ctx = this
 
-      async function upsert() {
+      async function upsert () {
         const operations = objects.map(obj => {
           return {
             replaceOne: {
               filter: { ...filter, _id: obj.id },
               replacement: { ...obj, _id: obj.id },
-              upsert: true,
-            },
+              upsert: true
+            }
           }
         })
 
@@ -181,17 +192,17 @@ export class DataSourceMongoDb extends DataSource {
       const writable = new Writable({
         objectMode: true,
 
-        async write(chunk, _encoding, next) {
+        async write (chunk, _encoding, next) {
           objects.push(chunk)
           // if true time to flush buffer and write to db
           if (objects.length >= highWaterMark) await upsert()
           next()
         },
 
-        end(chunk, _, done) {
+        end (chunk, _, done) {
           objects.push(chunk)
           done()
-        },
+        }
       })
 
       writable.on('finish', async () => await upsert())
@@ -209,7 +220,7 @@ export class DataSourceMongoDb extends DataSource {
    *
    * @returns {Promise<import('mongodb').AbstractCursor>}
    */
-  async mongoFind({ filter, sort, limit, aggregate, skip } = {}) {
+  async mongoFind ({ filter, sort, limit, aggregate, skip } = {}) {
     console.log({ fn: this.mongoFind.name, filter })
     let cursor = (await this.collection()).find(filter)
     if (sort) cursor = cursor.sort(sort)
@@ -219,7 +230,7 @@ export class DataSourceMongoDb extends DataSource {
     return cursor
   }
 
-  processOptions(param) {
+  processOptions (param) {
     const { options = {}, query = {} } = param
     return { ...options, ...processQuery(query) }
   }
@@ -229,7 +240,7 @@ export class DataSourceMongoDb extends DataSource {
    * @override
    * @param {import('../../domain/datasource').listOptions} param
    */
-  async list(param) {
+  async list (param) {
     try {
       const options = this.processOptions(param)
       console.log({ options })
@@ -248,19 +259,19 @@ export class DataSourceMongoDb extends DataSource {
    *
    * @override
    */
-  async count() {
+  async count () {
     return {
       total: await this.countDb(),
       cached: this.getCacheSize(),
-      bytes: this.getCacheSizeBytes(),
+      bytes: this.getCacheSizeBytes()
     }
   }
 
   /**
    * @override
    * @returns
    */
-  async countDb() {
+  async countDb () {
     return (await this.collection()).countDocuments()
   }
 
@@ -271,7 +282,7 @@ export class DataSourceMongoDb extends DataSource {
    * @override
    * @param {*} id
    */
-  async delete(id) {
+  async delete (id) {
     try {
       await (await this.collection()).deleteOne({ _id: id })
     } catch (error) {

src/adapters/webassembly/repo-client.js

@@ -13,7 +13,7 @@ export const RepoClient = {
    * @param {import('../../../webpack/remote-entries-type').remoteEntry} entry
    * @returns {Buffer|String|Uint16Array}
    */
-  octoGet(entry) {
+  octoGet (entry) {
     console.info('github url', entry.url)
     const owner = entry.owner
     const repo = entry.repo
@@ -26,7 +26,7 @@ export const RepoClient = {
           owner,
           repo,
           filedir,
-          branch,
+          branch
         })
         .then(function (rest) {
           const file = rest.data.find(datum => /\.wasm$/.test(datum.name))
@@ -36,7 +36,7 @@ export const RepoClient = {
           return octokit.request('GET /repos/{owner}/{repo}/git/blobs/{sha}', {
             owner,
             repo,
-            sha,
+            sha
           })
         })
         .then(function (rest) {
@@ -49,7 +49,7 @@ export const RepoClient = {
                 buf.buffer,
                 buf.byteOffset,
                 buf.length / Uint16Array.BYTES_PER_ELEMENT
-              ),
+              )
           })
         })
         .catch(err => reject(err))
@@ -61,7 +61,7 @@ export const RepoClient = {
    * @param {*} params
    * @returns
    */
-  httpGet(params) {
+  httpGet (params) {
     return new Promise(function (resolve, reject) {
       var req = require(params.protocol.slice(
         0,
@@ -76,11 +76,10 @@ export const RepoClient = {
         })
         res.on('end', function () {
           try {
-            body = Buffer.concat(body).toString()
+            resolve(Buffer.concat(body))
           } catch (e) {
             reject(e)
           }
-          resolve(body)
         })
       })
       req.on('error', function (err) {
@@ -95,9 +94,9 @@ export const RepoClient = {
    * @param {import('../../../webpack/remote-entries-type').remoteEntry} entry
    * @returns
    */
-  async fetch(entry) {
+  async fetch (entry) {
     if (/^https:\/\/api.github.com.*/i.test(entry.url))
       return this.octoGet(entry)
-    return this.httpGet(entry.url)
-  },
+    return this.httpGet(new URL(entry.url))
+  }
 }