jfrog-cli-v2-jf 2.6.0

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/which/which.js

@@ -0,0 +1,135 @@
+module.exports = which
+which.sync = whichSync
+
+var isWindows = process.platform === 'win32' ||
+    process.env.OSTYPE === 'cygwin' ||
+    process.env.OSTYPE === 'msys'
+
+var path = require('path')
+var COLON = isWindows ? ';' : ':'
+var isexe = require('isexe')
+
+function getNotFoundError (cmd) {
+  var er = new Error('not found: ' + cmd)
+  er.code = 'ENOENT'
+
+  return er
+}
+
+function getPathInfo (cmd, opt) {
+  var colon = opt.colon || COLON
+  var pathEnv = opt.path || process.env.PATH || ''
+  var pathExt = ['']
+
+  pathEnv = pathEnv.split(colon)
+
+  var pathExtExe = ''
+  if (isWindows) {
+    pathEnv.unshift(process.cwd())
+    pathExtExe = (opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
+    pathExt = pathExtExe.split(colon)
+
+
+    // Always test the cmd itself first.  isexe will check to make sure
+    // it's found in the pathExt set.
+    if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
+      pathExt.unshift('')
+  }
+
+  // If it has a slash, then we don't bother searching the pathenv.
+  // just check the file itself, and that's it.
+  if (cmd.match(/\//) || isWindows && cmd.match(/\\/))
+    pathEnv = ['']
+
+  return {
+    env: pathEnv,
+    ext: pathExt,
+    extExe: pathExtExe
+  }
+}
+
+function which (cmd, opt, cb) {
+  if (typeof opt === 'function') {
+    cb = opt
+    opt = {}
+  }
+
+  var info = getPathInfo(cmd, opt)
+  var pathEnv = info.env
+  var pathExt = info.ext
+  var pathExtExe = info.extExe
+  var found = []
+
+  ;(function F (i, l) {
+    if (i === l) {
+      if (opt.all && found.length)
+        return cb(null, found)
+      else
+        return cb(getNotFoundError(cmd))
+    }
+
+    var pathPart = pathEnv[i]
+    if (pathPart.charAt(0) === '"' && pathPart.slice(-1) === '"')
+      pathPart = pathPart.slice(1, -1)
+
+    var p = path.join(pathPart, cmd)
+    if (!pathPart && (/^\.[\\\/]/).test(cmd)) {
+      p = cmd.slice(0, 2) + p
+    }
+    ;(function E (ii, ll) {
+      if (ii === ll) return F(i + 1, l)
+      var ext = pathExt[ii]
+      isexe(p + ext, { pathExt: pathExtExe }, function (er, is) {
+        if (!er && is) {
+          if (opt.all)
+            found.push(p + ext)
+          else
+            return cb(null, p + ext)
+        }
+        return E(ii + 1, ll)
+      })
+    })(0, pathExt.length)
+  })(0, pathEnv.length)
+}
+
+function whichSync (cmd, opt) {
+  opt = opt || {}
+
+  var info = getPathInfo(cmd, opt)
+  var pathEnv = info.env
+  var pathExt = info.ext
+  var pathExtExe = info.extExe
+  var found = []
+
+  for (var i = 0, l = pathEnv.length; i < l; i ++) {
+    var pathPart = pathEnv[i]
+    if (pathPart.charAt(0) === '"' && pathPart.slice(-1) === '"')
+      pathPart = pathPart.slice(1, -1)
+
+    var p = path.join(pathPart, cmd)
+    if (!pathPart && /^\.[\\\/]/.test(cmd)) {
+      p = cmd.slice(0, 2) + p
+    }
+    for (var j = 0, ll = pathExt.length; j < ll; j ++) {
+      var cur = p + pathExt[j]
+      var is
+      try {
+        is = isexe.sync(cur, { pathExt: pathExtExe })
+        if (is) {
+          if (opt.all)
+            found.push(cur)
+          else
+            return cur
+        }
+      } catch (ex) {}
+    }
+  }
+
+  if (opt.all && found.length)
+    return found
+
+  if (opt.nothrow)
+    return null
+
+  throw getNotFoundError(cmd)
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/worker-farm/.travis.yml

@@ -0,0 +1,11 @@
+language: node_js
+node_js:
+  - 4
+  - 6
+  - 8
+branches:
+  only:
+    - master
+notifications:
+  email:
+    - rod@vagg.org

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/worker-farm/LICENSE.md

@@ -0,0 +1,13 @@
+The MIT License (MIT)
+=====================
+
+Copyright (c) 2014 LevelUP contributors
+---------------------------------------
+
+*LevelUP contributors listed at <https://github.com/rvagg/node-levelup#contributors>*
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/worker-farm/README.md

@@ -0,0 +1,144 @@
+# Worker Farm [![Build Status](https://secure.travis-ci.org/rvagg/node-worker-farm.png)](http://travis-ci.org/rvagg/node-worker-farm)
+
+[![NPM](https://nodei.co/npm/worker-farm.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/worker-farm/) [![NPM](https://nodei.co/npm-dl/worker-farm.png?months=6&height=3)](https://nodei.co/npm/worker-farm/)
+
+
+Distribute processing tasks to child processes with an über-simple API and baked-in durability & custom concurrency options. *Available in npm as <strong>worker-farm</strong>*.
+
+## Example
+
+Given a file, *child.js*:
+
+```js
+module.exports = function (inp, callback) {
+  callback(null, inp + ' BAR (' + process.pid + ')')
+}
+```
+
+And a main file:
+
+```js
+var workerFarm = require('worker-farm')
+  , workers    = workerFarm(require.resolve('./child'))
+  , ret        = 0
+
+for (var i = 0; i < 10; i++) {
+  workers('#' + i + ' FOO', function (err, outp) {
+    console.log(outp)
+    if (++ret == 10)
+      workerFarm.end(workers)
+  })
+}
+```
+
+We'll get an output something like the following:
+
+```
+#1 FOO BAR (8546)
+#0 FOO BAR (8545)
+#8 FOO BAR (8545)
+#9 FOO BAR (8546)
+#2 FOO BAR (8548)
+#4 FOO BAR (8551)
+#3 FOO BAR (8549)
+#6 FOO BAR (8555)
+#5 FOO BAR (8553)
+#7 FOO BAR (8557)
+```
+
+This example is contained in the *[examples/basic](https://github.com/rvagg/node-worker-farm/tree/master/examples/basic/)* directory.
+
+### Example #1: Estimating π using child workers
+
+You will also find a more complex example in *[examples/pi](https://github.com/rvagg/node-worker-farm/tree/master/examples/pi/)* that estimates the value of **π** by using a Monte Carlo *area-under-the-curve* method and compares the speed of doing it all in-process vs using child workers to complete separate portions.
+
+Running `node examples/pi` will give you something like:
+
+```
+Doing it the slow (single-process) way...
+π ≈ 3.1416269360000006  (0.0000342824102075312 away from actual!)
+took 8341 milliseconds
+Doing it the fast (multi-process) way...
+π ≈ 3.1416233600000036  (0.00003070641021052367 away from actual!)
+took 1985 milliseconds
+```
+
+## Durability
+
+An important feature of Worker Farm is **call durability**. If a child process dies for any reason during the execution of call(s), those calls will be re-queued and taken care of by other child processes. In this way, when you ask for something to be done, unless there is something *seriously* wrong with what you're doing, you should get a result on your callback function.
+
+## My use-case
+
+There are other libraries for managing worker processes available but my use-case was fairly specific: I need to make heavy use of the [node-java](https://github.com/nearinfinity/node-java) library to interact with JVM code. Unfortunately, because the JVM garbage collector is so difficult to interact with, it's prone to killing your Node process when the GC kicks under heavy load. For safety I needed a durable way to make calls so that (1) it wouldn't kill my main process and (2) any calls that weren't successful would be resubmitted for processing.
+
+Worker Farm allows me to spin up multiple JVMs to be controlled by Node, and have a single, uncomplicated API that acts the same way as an in-process API and the calls will be taken care of by a child process even if an error kills a child process while it is working as the call will simply be passed to a new child process.
+
+**But**, don't think that Worker Farm is specific to that use-case, it's designed to be very generic and simple to adapt to anything requiring the use of child Node processes.
+
+## API
+
+Worker Farm exports a main function and an `end()` method. The main function sets up a "farm" of coordinated child-process workers and it can be used to instantiate multiple farms, all operating independently.
+
+### workerFarm([options, ]pathToModule[, exportedMethods])
+
+In its most basic form, you call `workerFarm()` with the path to a module file to be invoked by the child process. You should use an **absolute path** to the module file, the best way to obtain the path is with `require.resolve('./path/to/module')`, this function can be used in exactly the same way as `require('./path/to/module')` but it returns an absolute path.
+
+#### `exportedMethods`
+
+If your module exports a single function on `module.exports` then you should omit the final parameter. However, if you are exporting multiple functions on `module.exports` then you should list them in an Array of Strings:
+
+```js
+var workers = workerFarm(require.resolve('./mod'), [ 'doSomething', 'doSomethingElse' ])
+workers.doSomething(function () {})
+workers.doSomethingElse(function () {})
+```
+
+Listing the available methods will instruct Worker Farm what API to provide you with on the returned object. If you don't list a `exportedMethods` Array then you'll get a single callable function to use; but if you list the available methods then you'll get an object with callable functions by those names.
+
+**It is assumed that each function you call on your child module will take a `callback` function as the last argument.**
+
+#### `options`
+
+If you don't provide an `options` object then the following defaults will be used:
+
+```js
+{
+    maxCallsPerWorker           : Infinity
+  , maxConcurrentWorkers        : require('os').cpus().length
+  , maxConcurrentCallsPerWorker : 10
+  , maxConcurrentCalls          : Infinity
+  , maxCallTime                 : Infinity
+  , maxRetries                  : Infinity
+  , autoStart                   : false
+}
+```
+
+  * **<code>maxCallsPerWorker</code>** allows you to control the lifespan of your child processes. A positive number will indicate that you only want each child to accept that many calls before it is terminated. This may be useful if you need to control memory leaks or similar in child processes.
+
+  * **<code>maxConcurrentWorkers</code>** will set the number of child processes to maintain concurrently. By default it is set to the number of CPUs available on the current system, but it can be any reasonable number, including `1`.
+
+  * **<code>maxConcurrentCallsPerWorker</code>** allows you to control the *concurrency* of individual child processes. Calls are placed into a queue and farmed out to child processes according to the number of calls they are allowed to handle concurrently. It is arbitrarily set to 10 by default so that calls are shared relatively evenly across workers, however if your calls predictably take a similar amount of time then you could set it to `Infinity` and Worker Farm won't queue any calls but spread them evenly across child processes and let them go at it. If your calls aren't I/O bound then it won't matter what value you use here as the individual workers won't be able to execute more than a single call at a time.
+
+  * **<code>maxConcurrentCalls</code>** allows you to control the maximum number of calls in the queue&mdash;either actively being processed or waiting for a worker to be processed. `Infinity` indicates no limit but if you have conditions that may endlessly queue jobs and you need to set a limit then provide a `>0` value and any calls that push the limit will return on their callback with a `MaxConcurrentCallsError` error (check `err.type == 'MaxConcurrentCallsError'`).
+
+  * **<code>maxCallTime</code>** *(use with caution, understand what this does before you use it!)* when `!== Infinity`, will cap a time, in milliseconds, that *any single call* can take to execute in a worker. If this time limit is exceeded by just a single call then the worker running that call will be killed and any calls running on that worker will have their callbacks returned with a `TimeoutError` (check `err.type == 'TimeoutError'`). If you are running with `maxConcurrentCallsPerWorker` value greater than `1` then **all calls currently executing** will fail and will be automatically resubmitted uless you've changed the `maxRetries` option. Use this if you have jobs that may potentially end in infinite loops that you can't programatically end with your child code. Preferably run this with a `maxConcurrentCallsPerWorker` so you don't interrupt other calls when you have a timeout. This timeout operates on a per-call basis but will interrupt a whole worker.
+
+  * **<code>maxRetries</code>** allows you to control the max number of call requeues after worker termination (unexpected or timeout). By default this option is set to `Infinity` which means that each call of each terminated worker will always be auto requeued. When the number of retries exceeds `maxRetries` value, the job callback will be executed with a `ProcessTerminatedError`. Note that if you are running with finite `maxCallTime` and `maxConcurrentCallsPerWorkers` greater than `1` then any `TimeoutError` will increase the retries counter *for each* concurrent call of the terminated worker.
+
+  * **<code>autoStart</code>** when set to `true` will start the workers as early as possible. Use this when your workers have to do expensive initialization. That way they'll be ready when the first request comes through.
+
+### workerFarm.end(farm)
+
+Child processes stay alive waiting for jobs indefinitely and your farm manager will stay alive managing its workers, so if you need it to stop then you have to do so explicitly. If you send your farm API to `workerFarm.end()` then it'll cleanly end your worker processes. Note though that it's a *soft* ending so it'll wait for child processes to finish what they are working on before asking them to die.
+
+Any calls that are queued and not yet being handled by a child process will be discarded. `end()` only waits for those currently in progress.
+
+Once you end a farm, it won't handle any more calls, so don't even try!
+
+## Related
+
+* [farm-cli](https://github.com/Kikobeats/farm-cli) – Launch a farm of workers from CLI.
+
+## License
+
+Worker Farm is Copyright (c) 2014 Rod Vagg [@rvagg](https://twitter.com/rvagg) and licensed under the MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE.md file for more details.

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/worker-farm/examples/basic/child.js

@@ -0,0 +1,5 @@
+'use strict'
+
+module.exports = function (inp, callback) {
+  callback(null, inp + ' BAR (' + process.pid + ')')
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/worker-farm/examples/basic/index.js

@@ -0,0 +1,13 @@
+'use strict'
+
+let workerFarm = require('../../')
+  , workers    = workerFarm(require.resolve('./child'))
+  , ret        = 0
+
+for (let i = 0; i < 10; i++) {
+  workers('#' + i + ' FOO', function (err, outp) {
+    console.log(outp)
+    if (++ret == 10)
+      workerFarm.end(workers)
+  })
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/worker-farm/examples/pi/calc.js

@@ -0,0 +1,22 @@
+'use strict'
+
+/* A simple π estimation function using a Monte Carlo method
+ * For 0 to `points`, take 2 random numbers < 1, square and add them to
+ * find the area under that point in a 1x1 square. If that area is <= 1
+ * then it's *within* a quarter-circle, otherwise it's outside.
+ * Take the number of points <= 1 and multiply it by 4 and you have an
+ * estimate!
+ * Do this across multiple processes and average the results to
+ * increase accuracy.
+ */
+
+module.exports = function (points, callback) {
+  let inside = 0
+    , i = points
+
+  while (i--)
+    if (Math.pow(Math.random(), 2) + Math.pow(Math.random(), 2) <= 1)
+      inside++
+
+  callback(null, (inside / points) * 4)
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/worker-farm/examples/pi/index.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const CHILDREN         = 500
+    , POINTS_PER_CHILD = 1000000
+    , FARM_OPTIONS     = {
+          maxConcurrentWorkers        : require('os').cpus().length
+        , maxCallsPerWorker           : Infinity
+        , maxConcurrentCallsPerWorker : 1
+      }
+
+let workerFarm = require('../../')
+  , calcDirect = require('./calc')
+  , calcWorker = workerFarm(FARM_OPTIONS, require.resolve('./calc'))
+
+  , ret
+  , start
+
+  , tally = function (finish, err, avg) {
+      ret.push(avg)
+      if (ret.length == CHILDREN) {
+        let pi  = ret.reduce(function (a, b) { return a + b }) / ret.length
+          , end = +new Date()
+        console.log('π ≈', pi, '\t(' + Math.abs(pi - Math.PI), 'away from actual!)')
+        console.log('took', end - start, 'milliseconds')
+        if (finish)
+          finish()
+      }
+    }
+
+  , calc = function (method, callback) {
+      ret   = []
+      start = +new Date()
+      for (let i = 0; i < CHILDREN; i++)
+        method(POINTS_PER_CHILD, tally.bind(null, callback))
+    }
+
+console.log('Doing it the slow (single-process) way...')
+calc(calcDirect, function () {
+  console.log('Doing it the fast (multi-process) way...')
+  calc(calcWorker, process.exit)
+})

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/worker-farm/index.d.ts

@@ -0,0 +1,44 @@
+interface Workers {
+  (callback: WorkerCallback): void;
+  (arg1: any, callback: WorkerCallback): void;
+  (arg1: any, arg2: any, callback: WorkerCallback): void;
+  (arg1: any, arg2: any, arg3: any, callback: WorkerCallback): void;
+  (arg1: any, arg2: any, arg3: any, arg4: any, callback: WorkerCallback): void;
+}
+
+type WorkerCallback =
+  | WorkerCallback0
+  | WorkerCallback1
+  | WorkerCallback2
+  | WorkerCallback3
+  | WorkerCallback4;
+
+type WorkerCallback0 = () => void;
+type WorkerCallback1 = (arg1: any) => void;
+type WorkerCallback2 = (arg1: any, arg2: any) => void;
+type WorkerCallback3 = (arg1: any, arg2: any, arg3: any) => void;
+type WorkerCallback4 = (arg1: any, arg2: any, arg3: any, arg4: any) => void;
+
+interface FarmOptions {
+  maxCallsPerWorker?: number
+  maxConcurrentWorkers?: number
+  maxConcurrentCallsPerWorker?: number
+  maxConcurrentCalls?: number
+  maxCallTime?: number
+  maxRetries?: number
+  autoStart?: boolean
+}
+
+interface WorkerFarm {
+  (name: string): Workers;
+  (name: string, exportedMethods: string[]): Workers;
+  (options: FarmOptions, name: string): Workers;
+  (options: FarmOptions, name: string, exportedMethods: string[]): Workers;
+
+  end: (workers: Workers) => void;
+}
+
+declare module "worker-farm" {
+  const workerFarm: WorkerFarm;
+  export = workerFarm;
+}

package/node-v8.11.1-linux-x64/lib/node_modules/npm/node_modules/worker-farm/lib/child/index.js

@@ -0,0 +1,52 @@
+'use strict'
+
+let $module
+
+/*
+  let contextProto = this.context;
+  while (contextProto = Object.getPrototypeOf(contextProto)) {
+    completionGroups.push(Object.getOwnPropertyNames(contextProto));
+  }
+*/
+
+
+function handle (data) {
+  let idx      = data.idx
+    , child    = data.child
+    , method   = data.method
+    , args     = data.args
+    , callback = function () {
+        let _args = Array.prototype.slice.call(arguments)
+        if (_args[0] instanceof Error) {
+          let e = _args[0]
+          _args[0] = {
+              '$error'  : '$error'
+            , 'type'    : e.constructor.name
+            , 'message' : e.message
+            , 'stack'   : e.stack
+          }
+          Object.keys(e).forEach(function(key) {
+            _args[0][key] = e[key]
+          })
+        }
+        process.send({ idx: idx, child: child, args: _args })
+      }
+    , exec
+
+  if (method == null && typeof $module == 'function')
+    exec = $module
+  else if (typeof $module[method] == 'function')
+    exec = $module[method]
+
+  if (!exec)
+    return console.error('NO SUCH METHOD:', method)
+
+  exec.apply(null, args.concat([ callback ]))
+}
+
+
+process.on('message', function (data) {
+  if (!$module) return $module = require(data.module)
+  if (data == 'die') return process.exit(0)
+  handle(data)
+})