add proprtype

after a few try, I think it can work this way :

 * everything is in one store: xoApi, session, even component states. try to use boolean when possible to simplify usage in components
 * components states should rarely be used : let components be stateless, a pure function of their props
 * use connect on high level component to give them access to part of the store and the actions. A component should not have access to the full store and action.
 * use event to get data back from child components ( if they can't dispatch action themselves)
 * redux-thunk allow to dispatch multiple action in cascade (even async one) , like want to save->saving ->saved (or errored)
 * use imutable object, this will allow faster performance in the long run

.babelrc

@@ -0,0 +1,12 @@
+{
+  "comments": false,
+  "compact": true,
+  "plugins": [
+    "transform-runtime"
+  ],
+  "presets": [
+    "es2015",
+    "stage-0",
+    "react"
+  ]
+}

.bowerrc

@@ -0,0 +1,3 @@
+{
+  "directory": "dist/bower_components"
+}

.editorconfig

@@ -3,12 +3,63 @@
 # Julien Fontanet's configuration
 # https://gist.github.com/julien-f/8096213
 
+# Top-most EditorConfig file.
 root = true
 
+# Common config.
 [*]
 charset = utf-8
 end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespaces = true
+
+# CoffeeScript
+#
+# https://github.com/polarmobile/coffeescript-style-guide/blob/master/README.md
+[*.{,lit}coffee]
+indent_size = 2
+indent_style = space
+
+# Markdown
+[*.{md,mdwn,mdown,markdown}]
+indent_size = 4
+indent_style = space
+
+# Package.json
+#
+# This indentation style is the one used by npm.
+[/package.json]
+indent_size = 2
+indent_style = space
+
+# Jade
+[*.jade]
+indent_size = 2
+indent_style = space
+
+# JavaScript
+#
+# Two spaces seems to be the standard most common style, at least in
+# Node.js (http://nodeguide.com/style.html#tabs-vs-spaces).
+[*.js]
+indent_size = 2
+indent_style = space
+
+# Less
+[*.less]
+indent_size = 2
+indent_style = space
+
+# Sass
+#
+# Style used for http://libsass.com
+[*.s[ac]ss]
+indent_size = 2
+indent_style = space
+
+# YAML
+#
+# Only spaces are allowed.
+[*.yaml]
 indent_size = 2
 indent_style = space
-insert_final_newline = true
-trim_trailing_whitespace = true

.env.example

@@ -1,2 +0,0 @@
-# xo_fs_nfs=nfs://ip:/folder
-# xo_fs_smb=smb://login:pass@domain\\ip\folder

.eslintrc.js

@@ -1,56 +0,0 @@
-module.exports = {
-  extends: [
-    'plugin:eslint-comments/recommended',
-
-    'standard',
-    'standard-jsx',
-    'prettier',
-    'prettier/standard',
-    'prettier/react',
-  ],
-  globals: {
-    __DEV__: true,
-    $Dict: true,
-    $Diff: true,
-    $ElementType: true,
-    $Exact: true,
-    $Keys: true,
-    $PropertyType: true,
-    $Shape: true,
-  },
-
-  overrides: [
-    {
-      files: ['cli.js', '*-cli.js', '**/*cli*/**/*.js'],
-      rules: {
-        'no-console': 'off',
-      },
-    },
-  ],
-
-  parser: 'babel-eslint',
-  parserOptions: {
-    ecmaFeatures: {
-      legacyDecorators: true,
-    },
-  },
-  rules: {
-    // disabled because XAPI objects are using camel case
-    camelcase: ['off'],
-
-    'react/jsx-handler-names': 'off',
-
-    // disabled because not always relevant, we might reconsider in the future
-    //
-    // enabled by https://github.com/standard/eslint-config-standard/commit/319b177750899d4525eb1210686f6aca96190b2f
-    //
-    // example: https://github.com/vatesfr/xen-orchestra/blob/31ed3767c67044ca445658eb6b560718972402f2/packages/xen-api/src/index.js#L156-L157
-    'lines-between-class-members': 'off',
-
-    'no-console': ['error', { allow: ['warn', 'error'] }],
-    'no-var': 'error',
-    'node/no-extraneous-import': 'error',
-    'node/no-extraneous-require': 'error',
-    'prefer-const': 'error',
-  },
-}

.flowconfig

@@ -1,16 +0,0 @@
-[ignore]
-<PROJECT_ROOT>/node_modules/.*
-
-[include]
-
-[libs]
-
-[lints]
-
-[options]
-esproposal.decorators=ignore
-esproposal.optional_chaining=enable
-include_warnings=true
-module.use_strict=true
-
-[strict]

.gitignore

@@ -1,33 +1,9 @@
-/_book/
-/coverage/
-/node_modules/
-/lerna-debug.log
-/lerna-debug.log.*
-
-/@xen-orchestra/*/dist/
-/@xen-orchestra/*/node_modules/
-/packages/*/dist/
-/packages/*/node_modules/
-
-/packages/vhd-cli/src/commands/index.js
-
-/packages/xen-api/examples/node_modules/
-/packages/xen-api/plot.dat
-
-/packages/xo-server/.xo-server.*
-/packages/xo-server/src/api/index.js
-/packages/xo-server/src/xapi/mixins/index.js
-/packages/xo-server/src/xo-mixins/index.js
-
-/packages/xo-server-auth-ldap/ldap.cache.conf
-
-/packages/xo-web/src/common/intl/locales/index.js
-/packages/xo-web/src/common/themes/index.js
+/.nyc_output/
+/bower_components/
+/dist/
 
 npm-debug.log
 npm-debug.log.*
-pnpm-debug.log
-pnpm-debug.log.*
-yarn-error.log
-yarn-error.log.*
-.env
+
+!node_modules/*
+node_modules/*/

.mocha.js

@@ -0,0 +1,5 @@
+Error.stackTraceLimit = 100
+
+try { require('trace') } catch (_) {}
+try { require('clarify') } catch (_) {}
+try { require('source-map-support/register') } catch (_) {}

.mocha.opts

@@ -0,0 +1 @@
+--require ./.mocha.js

.prettierrc.js

@@ -1,6 +0,0 @@
-module.exports = {
-  arrowParens: 'avoid',
-  jsxSingleQuote: true,
-  semi: false,
-  singleQuote: true,
-}

.travis.yml

@@ -1,23 +1,10 @@
 language: node_js
 node_js:
-  - 12
+  - 'stable'
+  - '4'
+  - '0.12'
+  - '0.10'
 
 # Use containers.
 # http://docs.travis-ci.com/user/workers/container-based-infrastructure/
 sudo: false
-addons:
-  apt:
-    packages:
-      - qemu-utils
-      - blktap-utils
-      - vmdk-stream-converter
-
-before_install:
-  - curl -o- -L https://yarnpkg.com/install.sh | bash
-  - export PATH="$HOME/.yarn/bin:$PATH"
-
-cache:
-  yarn: true
-
-script:
-  - yarn run travis-tests

@vates/coalesce-calls/README.md

@@ -1,46 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/coalesce-calls
-
-[![Package Version](https://badgen.net/npm/v/@vates/coalesce-calls)](https://npmjs.org/package/@vates/coalesce-calls) ![License](https://badgen.net/npm/license/@vates/coalesce-calls) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/coalesce-calls)](https://bundlephobia.com/result?p=@vates/coalesce-calls) [![Node compatibility](https://badgen.net/npm/node/@vates/coalesce-calls)](https://npmjs.org/package/@vates/coalesce-calls)
-
-> Wraps an async function so that concurrent calls will be coalesced
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/coalesce-calls):
-
-```
-> npm install --save @vates/coalesce-calls
-```
-
-## Usage
-
-```js
-import { coalesceCalls } from 'coalesce-calls'
-
-const connect = coalesceCalls(async function () {
-  // async operation
-})
-
-connect()
-
-// the previous promise result will be returned if the operation is not
-// complete yet
-connect()
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/coalesce-calls/USAGE.md

@@ -1,13 +0,0 @@
-```js
-import { coalesceCalls } from '@vates/coalesce-calls'
-
-const connect = coalesceCalls(async function () {
-  // async operation
-})
-
-connect()
-
-// the previous promise result will be returned if the operation is not
-// complete yet
-connect()
-```

@vates/coalesce-calls/index.js

@@ -1,14 +0,0 @@
-exports.coalesceCalls = function (fn) {
-  let promise
-  const clean = () => {
-    promise = undefined
-  }
-  return function () {
-    if (promise !== undefined) {
-      return promise
-    }
-    promise = fn.apply(this, arguments)
-    promise.then(clean, clean)
-    return promise
-  }
-}

@vates/coalesce-calls/index.spec.js

@@ -1,33 +0,0 @@
-/* eslint-env jest */
-
-const { coalesceCalls } = require('./')
-
-const pDefer = () => {
-  const r = {}
-  r.promise = new Promise((resolve, reject) => {
-    r.reject = reject
-    r.resolve = resolve
-  })
-  return r
-}
-
-describe('coalesceCalls', () => {
-  it('decorates an async function', async () => {
-    const fn = coalesceCalls(promise => promise)
-
-    const defer1 = pDefer()
-    const promise1 = fn(defer1.promise)
-    const defer2 = pDefer()
-    const promise2 = fn(defer2.promise)
-
-    defer1.resolve('foo')
-    expect(await promise1).toBe('foo')
-    expect(await promise2).toBe('foo')
-
-    const defer3 = pDefer()
-    const promise3 = fn(defer3.promise)
-
-    defer3.resolve('bar')
-    expect(await promise3).toBe('bar')
-  })
-})

@vates/coalesce-calls/package.json

@@ -1,38 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/coalesce-calls",
-  "description": "Wraps an async function so that concurrent calls will be coalesced",
-  "keywords": [
-    "async",
-    "calls",
-    "coalesce",
-    "decorate",
-    "decorator",
-    "merge",
-    "promise",
-    "wrap",
-    "wrapper"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/coalesce-calls",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/coalesce-calls",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "files": [
-    "index.js"
-  ],
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "0.1.0",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/decorate-with/README.md

@@ -1,45 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/decorate-with
-
-[![Package Version](https://badgen.net/npm/v/@vates/decorate-with)](https://npmjs.org/package/@vates/decorate-with) ![License](https://badgen.net/npm/license/@vates/decorate-with) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/decorate-with)](https://bundlephobia.com/result?p=@vates/decorate-with) [![Node compatibility](https://badgen.net/npm/node/@vates/decorate-with)](https://npmjs.org/package/@vates/decorate-with)
-
-> Creates a decorator from a function wrapper
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/decorate-with):
-
-```
-> npm install --save @vates/decorate-with
-```
-
-## Usage
-
-For instance, allows using Lodash's functions as decorators:
-
-```js
-import { decorateWith } from '@vates/decorate-with'
-
-class Foo {
-  @decorateWith(lodash.debounce, 150)
-  bar() {
-    // body
-  }
-}
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/decorate-with/USAGE.md

@@ -1,12 +0,0 @@
-For instance, allows using Lodash's functions as decorators:
-
-```js
-import { decorateWith } from '@vates/decorate-with'
-
-class Foo {
-  @decorateWith(lodash.debounce, 150)
-  bar() {
-    // body
-  }
-}
-```

@vates/decorate-with/index.js

@@ -1,4 +0,0 @@
-exports.decorateWith = (fn, ...args) => (target, name, descriptor) => ({
-  ...descriptor,
-  value: fn(descriptor.value, ...args),
-})

@vates/decorate-with/package.json

@@ -1,30 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/decorate-with",
-  "description": "Creates a decorator from a function wrapper",
-  "keywords": [
-    "apply",
-    "decorator",
-    "factory",
-    "wrapper"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/decorate-with",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/decorate-with",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "ISC",
-  "version": "0.0.1",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/parse-duration/README.md

@@ -1,47 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/parse-duration
-
-[![Package Version](https://badgen.net/npm/v/@vates/parse-duration)](https://npmjs.org/package/@vates/parse-duration) ![License](https://badgen.net/npm/license/@vates/parse-duration) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/parse-duration)](https://bundlephobia.com/result?p=@vates/parse-duration) [![Node compatibility](https://badgen.net/npm/node/@vates/parse-duration)](https://npmjs.org/package/@vates/parse-duration)
-
-> Small wrapper around ms to parse a duration
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/parse-duration):
-
-```
-> npm install --save @vates/parse-duration
-```
-
-## Usage
-
-`ms` without magic: always parse a duration and throws if invalid.
-
-```js
-import { parseDuration } from '@vates/parse-duration'
-
-parseDuration('2 days')
-// 172800000
-
-parseDuration(172800000)
-// 172800000
-
-parseDuration(undefined)
-// throws TypeError('not a valid duration: undefined')
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[AGPL-3.0-or-later](https://spdx.org/licenses/AGPL-3.0-or-later) © [Vates SAS](https://vates.fr)

@vates/parse-duration/USAGE.md

@@ -1,14 +0,0 @@
-`ms` without magic: always parse a duration and throws if invalid.
-
-```js
-import { parseDuration } from '@vates/parse-duration'
-
-parseDuration('2 days')
-// 172800000
-
-parseDuration(172800000)
-// 172800000
-
-parseDuration(undefined)
-// throws TypeError('not a valid duration: undefined')
-```

@vates/parse-duration/index.js

@@ -1,12 +0,0 @@
-const ms = require('ms')
-
-exports.parseDuration = value => {
-  if (typeof value === 'number') {
-    return value
-  }
-  const duration = ms(value)
-  if (duration === undefined) {
-    throw new TypeError(`not a valid duration: ${duration}`)
-  }
-  return duration
-}

@vates/parse-duration/package.json

@@ -1,32 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/parse-duration",
-  "description": "Small wrapper around ms to parse a duration",
-  "keywords": [
-    "duration",
-    "ms",
-    "parse"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/parse-duration",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/parse-duration",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "license": "AGPL-3.0-or-later",
-  "version": "0.1.0",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "dependencies": {
-    "ms": "^2.1.2"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  }
-}

@vates/read-chunk/README.md

@@ -1,46 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @vates/read-chunk
-
-[![Package Version](https://badgen.net/npm/v/@vates/read-chunk)](https://npmjs.org/package/@vates/read-chunk) ![License](https://badgen.net/npm/license/@vates/read-chunk) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@vates/read-chunk)](https://bundlephobia.com/result?p=@vates/read-chunk) [![Node compatibility](https://badgen.net/npm/node/@vates/read-chunk)](https://npmjs.org/package/@vates/read-chunk)
-
-> Read a chunk of a Node stream
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@vates/read-chunk):
-
-```
-> npm install --save @vates/read-chunk
-```
-
-## Usage
-
-- returns the next available chunk of data
-- like `stream.read()`, a number of bytes can be specified
-- returns `null` if the stream has ended
-
-```js
-import { readChunk } from '@vates/read-chunk'
-;(async () => {
-  let chunk
-  while ((chunk = await readChunk(stream, 1024)) !== null) {
-    // do something with chunk
-  }
-})()
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@vates/read-chunk/USAGE.md

@@ -1,13 +0,0 @@
-- returns the next available chunk of data
-- like `stream.read()`, a number of bytes can be specified
-- returns `null` if the stream has ended
-
-```js
-import { readChunk } from '@vates/read-chunk'
-;(async () => {
-  let chunk
-  while ((chunk = await readChunk(stream, 1024)) !== null) {
-    // do something with chunk
-  }
-})()
-```

@vates/read-chunk/index.js

@@ -1,27 +0,0 @@
-exports.readChunk = (stream, size) =>
-  new Promise((resolve, reject) => {
-    function onEnd() {
-      resolve(null)
-      removeListeners()
-    }
-    function onError(error) {
-      reject(error)
-      removeListeners()
-    }
-    function onReadable() {
-      const data = stream.read(size)
-      if (data !== null) {
-        resolve(data)
-        removeListeners()
-      }
-    }
-    function removeListeners() {
-      stream.removeListener('end', onEnd)
-      stream.removeListener('error', onError)
-      stream.removeListener('readable', onReadable)
-    }
-    stream.on('end', onEnd)
-    stream.on('error', onError)
-    stream.on('readable', onReadable)
-    onReadable()
-  })

@vates/read-chunk/package.json

@@ -1,33 +0,0 @@
-{
-  "private": false,
-  "name": "@vates/read-chunk",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@vates/read-chunk",
-  "description": "Read a chunk of a Node stream",
-  "license": "ISC",
-  "keywords": [
-    "async",
-    "chunk",
-    "data",
-    "node",
-    "promise",
-    "read",
-    "stream"
-  ],
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@vates/read-chunk",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "version": "0.1.1",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  }
-}

@xen-orchestra/async-map/.babelrc.js

@@ -1,3 +0,0 @@
-module.exports = require('../../@xen-orchestra/babel-config')(
-  require('./package.json')
-)

@xen-orchestra/async-map/.npmignore

@@ -1,24 +0,0 @@
-/benchmark/
-/benchmarks/
-*.bench.js
-*.bench.js.map
-
-/examples/
-example.js
-example.js.map
-*.example.js
-*.example.js.map
-
-/fixture/
-/fixtures/
-*.fixture.js
-*.fixture.js.map
-*.fixtures.js
-*.fixtures.js.map
-
-/test/
-/tests/
-*.spec.js
-*.spec.js.map
-
-__snapshots__/

@xen-orchestra/async-map/README.md

@@ -1,38 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/async-map
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/async-map)](https://npmjs.org/package/@xen-orchestra/async-map) ![License](https://badgen.net/npm/license/@xen-orchestra/async-map) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/async-map)](https://bundlephobia.com/result?p=@xen-orchestra/async-map) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/async-map)](https://npmjs.org/package/@xen-orchestra/async-map)
-
-> Similar to Promise.all + lodash.map but wait for all promises to be settled
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/async-map):
-
-```
-> npm install --save @xen-orchestra/async-map
-```
-
-## Usage
-
-```js
-import asyncMap from '@xen-orchestra/async-map'
-
-const array = await asyncMap(collection, iteratee)
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@xen-orchestra/async-map/USAGE.md

@@ -1,5 +0,0 @@
-```js
-import asyncMap from '@xen-orchestra/async-map'
-
-const array = await asyncMap(collection, iteratee)
-```

@xen-orchestra/async-map/package.json

@@ -1,53 +0,0 @@
-{
-  "private": false,
-  "name": "@xen-orchestra/async-map",
-  "version": "0.0.0",
-  "license": "ISC",
-  "description": "Similar to Promise.all + lodash.map but wait for all promises to be settled",
-  "keywords": [],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/async-map",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@xen-orchestra/async-map",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "preferGlobal": false,
-  "main": "dist/",
-  "bin": {},
-  "files": [
-    "dist/"
-  ],
-  "browserslist": [
-    ">2%"
-  ],
-  "engines": {
-    "node": ">=6"
-  },
-  "dependencies": {
-    "lodash": "^4.17.4"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.0.0",
-    "@babel/core": "^7.0.0",
-    "@babel/preset-env": "^7.0.0",
-    "@babel/preset-flow": "^7.0.0",
-    "babel-plugin-lodash": "^3.3.2",
-    "cross-env": "^7.0.2",
-    "rimraf": "^3.0.0"
-  },
-  "scripts": {
-    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
-    "clean": "rimraf dist/",
-    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
-    "prebuild": "yarn run clean",
-    "predev": "yarn run prebuild",
-    "prepare": "yarn run build",
-    "prepublishOnly": "yarn run build",
-    "postversion": "npm publish"
-  }
-}

@xen-orchestra/async-map/src/index.js

@@ -1,43 +0,0 @@
-// type MaybePromise<T> = Promise<T> | T
-//
-// declare export function asyncMap<T1, T2>(
-//   collection: MaybePromise<T1[]>,
-//   (T1, number) => MaybePromise<T2>
-// ): Promise<T2[]>
-// declare export function asyncMap<K, V1, V2>(
-//   collection: MaybePromise<{ [K]: V1 }>,
-//   (V1, K) => MaybePromise<V2>
-// ): Promise<V2[]>
-
-import map from 'lodash/map'
-
-// Similar to map() + Promise.all() but wait for all promises to
-// settle before rejecting (with the first error)
-const asyncMap = (collection, iteratee) => {
-  let then
-  if (collection != null && typeof (then = collection.then) === 'function') {
-    return then.call(collection, collection => asyncMap(collection, iteratee))
-  }
-
-  let errorContainer
-  const onError = error => {
-    if (errorContainer === undefined) {
-      errorContainer = { error }
-    }
-  }
-
-  return Promise.all(
-    map(collection, (item, key, collection) =>
-      new Promise(resolve => {
-        resolve(iteratee(item, key, collection))
-      }).catch(onError)
-    )
-  ).then(values => {
-    if (errorContainer !== undefined) {
-      throw errorContainer.error
-    }
-    return values
-  })
-}
-
-export { asyncMap as default }

@xen-orchestra/audit-core/.babelrc.js

@@ -1,3 +0,0 @@
-module.exports = require('../../@xen-orchestra/babel-config')(
-  require('./package.json')
-)

@xen-orchestra/audit-core/.npmignore

@@ -1,24 +0,0 @@
-/benchmark/
-/benchmarks/
-*.bench.js
-*.bench.js.map
-
-/examples/
-example.js
-example.js.map
-*.example.js
-*.example.js.map
-
-/fixture/
-/fixtures/
-*.fixture.js
-*.fixture.js.map
-*.fixtures.js
-*.fixtures.js.map
-
-/test/
-/tests/
-*.spec.js
-*.spec.js.map
-
-__snapshots__/

@xen-orchestra/audit-core/README.md

@@ -1,28 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/audit-core
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/audit-core)](https://npmjs.org/package/@xen-orchestra/audit-core) ![License](https://badgen.net/npm/license/@xen-orchestra/audit-core) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/audit-core)](https://bundlephobia.com/result?p=@xen-orchestra/audit-core) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/audit-core)](https://npmjs.org/package/@xen-orchestra/audit-core)
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/audit-core):
-
-```
-> npm install --save @xen-orchestra/audit-core
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[AGPL-3.0-or-later](https://spdx.org/licenses/AGPL-3.0-or-later) © [Vates SAS](https://vates.fr)

@xen-orchestra/audit-core/package.json

@@ -1,44 +0,0 @@
-{
-  "name": "@xen-orchestra/audit-core",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/audit-core",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@xen-orchestra/audit-core",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "version": "0.1.1",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "main": "dist/",
-  "scripts": {
-    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
-    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
-    "postversion": "npm publish --access public",
-    "prebuild": "rimraf dist/",
-    "predev": "yarn run prebuild",
-    "prepublishOnly": "yarn run build"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.7.4",
-    "@babel/core": "^7.7.4",
-    "@babel/plugin-proposal-decorators": "^7.8.0",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.8.0",
-    "@babel/preset-env": "^7.7.4",
-    "cross": "^1.0.0",
-    "rimraf": "^3.0.0"
-  },
-  "dependencies": {
-    "core-js": "^3.6.4",
-    "golike-defer": "^0.4.1",
-    "lodash": "^4.17.15",
-    "object-hash": "^2.0.1"
-  },
-  "private": false,
-  "license": "AGPL-3.0-or-later",
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  }
-}

@xen-orchestra/audit-core/src/index.js

@@ -1,142 +0,0 @@
-// see https://github.com/babel/babel/issues/8450
-import 'core-js/features/symbol/async-iterator'
-
-import assert from 'assert'
-import defer from 'golike-defer'
-import hash from 'object-hash'
-
-export class Storage {
-  constructor() {
-    this._lock = Promise.resolve()
-  }
-
-  async acquireLock() {
-    const lock = this._lock
-    let releaseLock
-    this._lock = new Promise(resolve => {
-      releaseLock = resolve
-    })
-    await lock
-    return releaseLock
-  }
-}
-
-// Format: $<algorithm>$<salt>$<encrypted>
-//
-// http://man7.org/linux/man-pages/man3/crypt.3.html#NOTES
-const ID_TO_ALGORITHM = {
-  '5': 'sha256',
-}
-
-export class AlteredRecordError extends Error {
-  constructor(id, nValid, record) {
-    super('altered record')
-
-    this.id = id
-    this.nValid = nValid
-    this.record = record
-  }
-}
-
-export class MissingRecordError extends Error {
-  constructor(id, nValid) {
-    super('missing record')
-
-    this.id = id
-    this.nValid = nValid
-  }
-}
-
-export const NULL_ID = 'nullId'
-
-const HASH_ALGORITHM_ID = '5'
-const createHash = (data, algorithmId = HASH_ALGORITHM_ID) =>
-  `$${algorithmId}$$${hash(data, {
-    algorithm: ID_TO_ALGORITHM[algorithmId],
-    excludeKeys: key => key === 'id',
-  })}`
-
-export class AuditCore {
-  constructor(storage) {
-    assert.notStrictEqual(storage, undefined)
-    this._storage = storage
-  }
-
-  @defer
-  async add($defer, subject, event, data) {
-    const time = Date.now()
-    const storage = this._storage
-    $defer(await storage.acquireLock())
-
-    // delete "undefined" properties and normalize data with JSON.stringify
-    const record = JSON.parse(
-      JSON.stringify({
-        data,
-        event,
-        previousId: (await storage.getLastId()) ?? NULL_ID,
-        subject,
-        time,
-      })
-    )
-    record.id = createHash(record)
-    await storage.put(record)
-    await storage.setLastId(record.id)
-    return record
-  }
-
-  async checkIntegrity(oldest, newest) {
-    const storage = this._storage
-
-    // handle separated chains case
-    if (newest !== (await storage.getLastId())) {
-      let isNewestAccessible = false
-      for await (const { id } of this.getFrom()) {
-        if (id === newest) {
-          isNewestAccessible = true
-          break
-        }
-      }
-      if (!isNewestAccessible) {
-        throw new MissingRecordError(newest, 0)
-      }
-    }
-
-    let nValid = 0
-    while (newest !== oldest) {
-      const record = await storage.get(newest)
-      if (record === undefined) {
-        throw new MissingRecordError(newest, nValid)
-      }
-      if (
-        newest !== createHash(record, newest.slice(1, newest.indexOf('$', 1)))
-      ) {
-        throw new AlteredRecordError(newest, nValid, record)
-      }
-      newest = record.previousId
-      nValid++
-    }
-    return nValid
-  }
-
-  async *getFrom(newest) {
-    const storage = this._storage
-
-    let id = newest ?? (await storage.getLastId())
-    if (id === undefined) {
-      return
-    }
-
-    let record
-    while ((record = await storage.get(id)) !== undefined) {
-      yield record
-      id = record.previousId
-    }
-  }
-
-  async deleteFrom(newest) {
-    assert.notStrictEqual(newest, undefined)
-    for await (const { id } of this.getFrom(newest)) {
-      await this._storage.del(id)
-    }
-  }
-}

@xen-orchestra/audit-core/src/index.spec.js

@@ -1,126 +0,0 @@
-/* eslint-env jest */
-
-import {
-  AlteredRecordError,
-  AuditCore,
-  MissingRecordError,
-  NULL_ID,
-  Storage,
-} from '.'
-
-const asyncIteratorToArray = async asyncIterator => {
-  const array = []
-  for await (const entry of asyncIterator) {
-    array.push(entry)
-  }
-  return array
-}
-
-class DB extends Storage {
-  constructor() {
-    super()
-
-    this._db = new Map()
-    this._lastId = undefined
-  }
-
-  async put(record) {
-    this._db.set(record.id, record)
-  }
-
-  async setLastId(id) {
-    this._lastId = id
-  }
-
-  async getLastId() {
-    return this._lastId
-  }
-
-  async del(id) {
-    this._db.delete(id)
-  }
-
-  async get(id) {
-    return this._db.get(id)
-  }
-
-  _clear() {
-    return this._db.clear()
-  }
-}
-
-const DATA = [
-  [
-    {
-      name: 'subject0',
-    },
-    'event0',
-    {},
-  ],
-  [
-    {
-      name: 'subject1',
-    },
-    'event1',
-    {},
-  ],
-  [
-    {
-      name: 'subject2',
-    },
-    'event2',
-    {},
-  ],
-]
-
-const db = new DB()
-const auditCore = new AuditCore(db)
-const storeAuditRecords = async () => {
-  await Promise.all(DATA.map(data => auditCore.add(...data)))
-  const records = await asyncIteratorToArray(auditCore.getFrom())
-  expect(records.length).toBe(DATA.length)
-  return records
-}
-
-describe('auditCore', () => {
-  afterEach(() => db._clear())
-
-  it('detects that a record is missing', async () => {
-    const [newestRecord, deletedRecord] = await storeAuditRecords()
-
-    const nValidRecords = await auditCore.checkIntegrity(
-      NULL_ID,
-      newestRecord.id
-    )
-    expect(nValidRecords).toBe(DATA.length)
-
-    await db.del(deletedRecord.id)
-    await expect(
-      auditCore.checkIntegrity(NULL_ID, newestRecord.id)
-    ).rejects.toEqual(new MissingRecordError(deletedRecord.id, 1))
-  })
-
-  it('detects that a record has been altered', async () => {
-    const [newestRecord, alteredRecord] = await storeAuditRecords()
-
-    alteredRecord.event = ''
-    await db.put(alteredRecord)
-
-    await expect(
-      auditCore.checkIntegrity(NULL_ID, newestRecord.id)
-    ).rejects.toEqual(
-      new AlteredRecordError(alteredRecord.id, 1, alteredRecord)
-    )
-  })
-
-  it('confirms interval integrity after deletion of records outside of the interval', async () => {
-    const [thirdRecord, secondRecord, firstRecord] = await storeAuditRecords()
-
-    await auditCore.deleteFrom(secondRecord.id)
-
-    expect(await db.get(firstRecord.id)).toBe(undefined)
-    expect(await db.get(secondRecord.id)).toBe(undefined)
-
-    await auditCore.checkIntegrity(secondRecord.id, thirdRecord.id)
-  })
-})

@xen-orchestra/audit-core/src/specification.ts

@@ -1,25 +0,0 @@
-class Storage {
-  acquire: () => Promise<() => undefined>
-  del: (id: string) => Promise<void>
-  get: (id: string) => Promise<Record | void>
-  getLastId: () => Promise<string | void>
-  put: (record: Record) => Promise<void>
-  setLastId: (id: string) => Promise<void>
-}
-
-interface Record {
-  data: object
-  event: string
-  id: string
-  previousId: string
-  subject: object
-  time: number
-}
-
-export class AuditCore {
-  constructor(storage: Storage) {}
-  public add(subject: any, event: string, data: any): Promise<Record> {}
-  public checkIntegrity(oldest: string, newest: string): Promise<number> {}
-  public getFrom(newest?: string): AsyncIterator {}
-  public deleteFrom(newest: string): Promise<void> {}
-}

@xen-orchestra/babel-config/README.md

@@ -1,18 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/babel-config
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[AGPL-3.0-or-later](https://spdx.org/licenses/AGPL-3.0-or-later) © [Vates SAS](https://vates.fr)

@xen-orchestra/babel-config/index.js

@@ -1,78 +0,0 @@
-'use strict'
-
-const PLUGINS_RE = /^(?:@babel\/|babel-)plugin-.+$/
-const PRESETS_RE = /^@babel\/preset-.+$/
-
-const NODE_ENV = process.env.NODE_ENV || 'development'
-const __PROD__ = NODE_ENV === 'production'
-const __TEST__ = NODE_ENV === 'test'
-
-const configs = {
-  '@babel/plugin-proposal-decorators': {
-    legacy: true,
-  },
-  '@babel/plugin-proposal-pipeline-operator': {
-    proposal: 'minimal',
-  },
-  '@babel/preset-env'(pkg) {
-    return {
-      debug: !__TEST__,
-
-      // disabled until https://github.com/babel/babel/issues/8323 is resolved
-      // loose: true,
-
-      shippedProposals: true,
-      targets: (() => {
-        let node = (pkg.engines || {}).node
-        if (node !== undefined) {
-          const trimChars = '^=>~'
-          while (trimChars.includes(node[0])) {
-            node = node.slice(1)
-          }
-        }
-        return { browsers: pkg.browserslist, node }
-      })(),
-    }
-  },
-}
-
-const getConfig = (key, ...args) => {
-  const config = configs[key]
-  return config === undefined
-    ? {}
-    : typeof config === 'function'
-    ? config(...args)
-    : config
-}
-
-// some plugins must be used in a specific order
-const pluginsOrder = [
-  '@babel/plugin-proposal-decorators',
-  '@babel/plugin-proposal-class-properties',
-]
-
-module.exports = function (pkg, plugins, presets) {
-  plugins === undefined && (plugins = {})
-  presets === undefined && (presets = {})
-
-  Object.keys(pkg.devDependencies || {}).forEach(name => {
-    if (!(name in presets) && PLUGINS_RE.test(name)) {
-      plugins[name] = getConfig(name, pkg)
-    } else if (!(name in presets) && PRESETS_RE.test(name)) {
-      presets[name] = getConfig(name, pkg)
-    }
-  })
-
-  return {
-    comments: !__PROD__,
-    ignore: __TEST__ ? undefined : [/\.spec\.js$/],
-    plugins: Object.keys(plugins)
-      .map(plugin => [plugin, plugins[plugin]])
-      .sort(([a], [b]) => {
-        const oA = pluginsOrder.indexOf(a)
-        const oB = pluginsOrder.indexOf(b)
-        return oA !== -1 && oB !== -1 ? oA - oB : a < b ? -1 : 1
-      }),
-    presets: Object.keys(presets).map(preset => [preset, presets[preset]]),
-  }
-}

@xen-orchestra/babel-config/package.json

@@ -1,20 +0,0 @@
-{
-  "private": true,
-  "name": "@xen-orchestra/babel-config",
-  "version": "0.0.0",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/babel-config",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@xen-orchestra/babel-config",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "engines": {
-    "node": ">=6"
-  },
-  "license": "AGPL-3.0-or-later",
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  }
-}

@xen-orchestra/backups-cli/README.md

@@ -1,28 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/backups-cli
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/backups-cli)](https://npmjs.org/package/@xen-orchestra/backups-cli) ![License](https://badgen.net/npm/license/@xen-orchestra/backups-cli) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/backups-cli)](https://bundlephobia.com/result?p=@xen-orchestra/backups-cli) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/backups-cli)](https://npmjs.org/package/@xen-orchestra/backups-cli)
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/backups-cli):
-
-```
-> npm install --global @xen-orchestra/backups-cli
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[AGPL-3.0-or-later](https://spdx.org/licenses/AGPL-3.0-or-later) © [Vates SAS](https://vates.fr)

@xen-orchestra/backups-cli/_asyncMap.js

@@ -1,7 +0,0 @@
-const curryRight = require('lodash/curryRight')
-
-module.exports = curryRight((iterable, fn) =>
-  Promise.all(
-    Array.isArray(iterable) ? iterable.map(fn) : Array.from(iterable, fn)
-  )
-)

@xen-orchestra/backups-cli/_composeCommands.js

@@ -1,32 +0,0 @@
-const getopts = require('getopts')
-
-const { version } = require('./package.json')
-
-module.exports = commands =>
-  async function (args, prefix) {
-    const opts = getopts(args, {
-      alias: {
-        help: 'h',
-      },
-      boolean: ['help'],
-      stopEarly: true,
-    })
-
-    const commandName = opts.help || args.length === 0 ? 'help' : args[0]
-    const command = commands[commandName]
-    if (command === undefined) {
-      process.stdout.write(`Usage:
-
-${Object.keys(commands)
-  .filter(command => command !== 'help')
-  .map(command => `    ${prefix} ${command} ${commands[command].usage || ''}`)
-  .join('\n\n')}
-
-xo-backups v${version}
-`)
-      process.exitCode = commandName === 'help' ? 0 : 1
-      return
-    }
-
-    return command.main(args.slice(1), prefix + ' ' + commandName)
-  }

@xen-orchestra/backups-cli/_fs.js

@@ -1,58 +0,0 @@
-const { dirname } = require('path')
-
-const fs = require('promise-toolbox/promisifyAll')(require('fs'))
-module.exports = fs
-
-fs.mktree = async function mkdirp(path) {
-  try {
-    await fs.mkdir(path)
-  } catch (error) {
-    const { code } = error
-    if (code === 'EEXIST') {
-      await fs.readdir(path)
-      return
-    }
-    if (code === 'ENOENT') {
-      await mkdirp(dirname(path))
-      return mkdirp(path)
-    }
-    throw error
-  }
-}
-
-// - easier:
-//   - single param for direct use in `Array#map`
-//   - files are prefixed with directory path
-// - safer: returns empty array if path is missing or not a directory
-fs.readdir2 = path =>
-  fs.readdir(path).then(
-    entries => {
-      entries.forEach((entry, i) => {
-        entries[i] = `${path}/${entry}`
-      })
-
-      return entries
-    },
-    error => {
-      const { code } = error
-      if (code === 'ENOENT') {
-        // do nothing
-      } else if (code === 'ENOTDIR') {
-        console.warn('WARN: readdir(%s)', path, error)
-      } else {
-        throw error
-      }
-      return []
-    }
-  )
-
-fs.symlink2 = async (target, path) => {
-  try {
-    await fs.symlink(target, path)
-  } catch (error) {
-    if (error.code === 'EEXIST' && (await fs.readlink(path)) === target) {
-      return
-    }
-    throw error
-  }
-}

@xen-orchestra/backups-cli/commands/clean-vms.js

@@ -1,318 +0,0 @@
-#!/usr/bin/env node
-
-// assigned when options are parsed by the main function
-let force
-
-// -----------------------------------------------------------------------------
-
-const assert = require('assert')
-const flatten = require('lodash/flatten')
-const getopts = require('getopts')
-const lockfile = require('proper-lockfile')
-const pipe = require('promise-toolbox/pipe')
-const { default: Vhd } = require('vhd-lib')
-const { dirname, resolve } = require('path')
-const { DISK_TYPE_DIFFERENCING } = require('vhd-lib/dist/_constants')
-const { isValidXva } = require('@xen-orchestra/backups/isValidXva')
-
-const asyncMap = require('../_asyncMap')
-const fs = require('../_fs')
-
-const handler = require('@xen-orchestra/fs').getHandler({ url: 'file://' })
-
-// -----------------------------------------------------------------------------
-
-// chain is an array of VHDs from child to parent
-//
-// the whole chain will be merged into parent, parent will be renamed to child
-// and all the others will deleted
-async function mergeVhdChain(chain) {
-  assert(chain.length >= 2)
-
-  const child = chain[0]
-  const parent = chain[chain.length - 1]
-  const children = chain.slice(0, -1).reverse()
-
-  console.warn('Unused parents of VHD', child)
-  chain
-    .slice(1)
-    .reverse()
-    .forEach(parent => {
-      console.warn('  ', parent)
-    })
-  force && console.warn('  merging…')
-  console.warn('')
-  if (force) {
-    // `mergeVhd` does not work with a stream, either
-    // - make it accept a stream
-    // - or create synthetic VHD which is not a stream
-    return console.warn('TODO: implement merge')
-    // await mergeVhd(
-    //   handler,
-    //   parent,
-    //   handler,
-    //   children.length === 1
-    //     ? child
-    //     : await createSyntheticStream(handler, children)
-    // )
-  }
-
-  await Promise.all([
-    force && fs.rename(parent, child),
-    asyncMap(children.slice(0, -1), child => {
-      console.warn('Unused VHD', child)
-      force && console.warn('  deleting…')
-      console.warn('')
-      return force && handler.unlink(child)
-    }),
-  ])
-}
-
-const listVhds = pipe([
-  vmDir => vmDir + '/vdis',
-  fs.readdir2,
-  asyncMap(fs.readdir2),
-  flatten,
-  asyncMap(fs.readdir2),
-  flatten,
-  _ => _.filter(_ => _.endsWith('.vhd')),
-])
-
-async function handleVm(vmDir) {
-  const vhds = new Set()
-  const vhdParents = { __proto__: null }
-  const vhdChildren = { __proto__: null }
-
-  // remove broken VHDs
-  await asyncMap(await listVhds(vmDir), async path => {
-    try {
-      const vhd = new Vhd(handler, path)
-      await vhd.readHeaderAndFooter()
-      vhds.add(path)
-      if (vhd.footer.diskType === DISK_TYPE_DIFFERENCING) {
-        const parent = resolve(dirname(path), vhd.header.parentUnicodeName)
-        vhdParents[path] = parent
-        if (parent in vhdChildren) {
-          const error = new Error(
-            'this script does not support multiple VHD children'
-          )
-          error.parent = parent
-          error.child1 = vhdChildren[parent]
-          error.child2 = path
-          throw error // should we throw?
-        }
-        vhdChildren[parent] = path
-      }
-    } catch (error) {
-      console.warn('Error while checking VHD', path)
-      console.warn('  ', error)
-      if (error != null && error.code === 'ERR_ASSERTION') {
-        force && console.warn('  deleting…')
-        console.warn('')
-        force && (await handler.unlink(path))
-      }
-    }
-  })
-
-  // remove VHDs with missing ancestors
-  {
-    const deletions = []
-
-    // return true if the VHD has been deleted or is missing
-    const deleteIfOrphan = vhd => {
-      const parent = vhdParents[vhd]
-      if (parent === undefined) {
-        return
-      }
-
-      // no longer needs to be checked
-      delete vhdParents[vhd]
-
-      deleteIfOrphan(parent)
-
-      if (!vhds.has(parent)) {
-        vhds.delete(vhd)
-
-        console.warn('Error while checking VHD', vhd)
-        console.warn('  missing parent', parent)
-        force && console.warn('  deleting…')
-        console.warn('')
-        force && deletions.push(handler.unlink(vhd))
-      }
-    }
-
-    // > A property that is deleted before it has been visited will not be
-    // > visited later.
-    // >
-    // > -- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in#Deleted_added_or_modified_properties
-    for (const child in vhdParents) {
-      deleteIfOrphan(child)
-    }
-
-    await Promise.all(deletions)
-  }
-
-  const [jsons, xvas, xvaSums] = await fs
-    .readdir2(vmDir)
-    .then(entries => [
-      entries.filter(_ => _.endsWith('.json')),
-      new Set(entries.filter(_ => _.endsWith('.xva'))),
-      entries.filter(_ => _.endsWith('.xva.cheksum')),
-    ])
-
-  await asyncMap(xvas, async path => {
-    // check is not good enough to delete the file, the best we can do is report
-    // it
-    if (!(await isValidXva(path))) {
-      console.warn('Potential broken XVA', path)
-      console.warn('')
-    }
-  })
-
-  const unusedVhds = new Set(vhds)
-  const unusedXvas = new Set(xvas)
-
-  // compile the list of unused XVAs and VHDs, and remove backup metadata which
-  // reference a missing XVA/VHD
-  await asyncMap(jsons, async json => {
-    const metadata = JSON.parse(await fs.readFile(json))
-    const { mode } = metadata
-    if (mode === 'full') {
-      const linkedXva = resolve(vmDir, metadata.xva)
-
-      if (xvas.has(linkedXva)) {
-        unusedXvas.delete(linkedXva)
-      } else {
-        console.warn('Error while checking backup', json)
-        console.warn('  missing file', linkedXva)
-        force && console.warn('  deleting…')
-        console.warn('')
-        force && (await handler.unlink(json))
-      }
-    } else if (mode === 'delta') {
-      const linkedVhds = (() => {
-        const { vhds } = metadata
-        return Object.keys(vhds).map(key => resolve(vmDir, vhds[key]))
-      })()
-
-      // FIXME: find better approach by keeping as much of the backup as
-      // possible (existing disks) even if one disk is missing
-      if (linkedVhds.every(_ => vhds.has(_))) {
-        linkedVhds.forEach(_ => unusedVhds.delete(_))
-      } else {
-        console.warn('Error while checking backup', json)
-        const missingVhds = linkedVhds.filter(_ => !vhds.has(_))
-        console.warn(
-          '  %i/%i missing VHDs',
-          missingVhds.length,
-          linkedVhds.length
-        )
-        missingVhds.forEach(vhd => {
-          console.warn('  ', vhd)
-        })
-        force && console.warn('  deleting…')
-        console.warn('')
-        force && (await handler.unlink(json))
-      }
-    }
-  })
-
-  // TODO: parallelize by vm/job/vdi
-  const unusedVhdsDeletion = []
-  {
-    // VHD chains (as list from child to ancestor) to merge indexed by last
-    // ancestor
-    const vhdChainsToMerge = { __proto__: null }
-
-    const toCheck = new Set(unusedVhds)
-
-    const getUsedChildChainOrDelete = vhd => {
-      if (vhd in vhdChainsToMerge) {
-        const chain = vhdChainsToMerge[vhd]
-        delete vhdChainsToMerge[vhd]
-        return chain
-      }
-
-      if (!unusedVhds.has(vhd)) {
-        return [vhd]
-      }
-
-      // no longer needs to be checked
-      toCheck.delete(vhd)
-
-      const child = vhdChildren[vhd]
-      if (child !== undefined) {
-        const chain = getUsedChildChainOrDelete(child)
-        if (chain !== undefined) {
-          chain.push(vhd)
-          return chain
-        }
-      }
-
-      console.warn('Unused VHD', vhd)
-      force && console.warn('  deleting…')
-      console.warn('')
-      force && unusedVhdsDeletion.push(handler.unlink(vhd))
-    }
-
-    toCheck.forEach(vhd => {
-      vhdChainsToMerge[vhd] = getUsedChildChainOrDelete(vhd)
-    })
-
-    Object.keys(vhdChainsToMerge).forEach(key => {
-      const chain = vhdChainsToMerge[key]
-      if (chain !== undefined) {
-        unusedVhdsDeletion.push(mergeVhdChain(chain))
-      }
-    })
-  }
-
-  await Promise.all([
-    unusedVhdsDeletion,
-    asyncMap(unusedXvas, path => {
-      console.warn('Unused XVA', path)
-      force && console.warn('  deleting…')
-      console.warn('')
-      return force && handler.unlink(path)
-    }),
-    asyncMap(xvaSums, path => {
-      // no need to handle checksums for XVAs deleted by the script, they will be handled by `unlink()`
-      if (!xvas.has(path.slice(0, -'.checksum'.length))) {
-        console.warn('Unused XVA checksum', path)
-        force && console.warn('  deleting…')
-        console.warn('')
-        return force && handler.unlink(path)
-      }
-    }),
-  ])
-}
-
-// -----------------------------------------------------------------------------
-
-module.exports = async function main(args) {
-  const opts = getopts(args, {
-    alias: {
-      force: 'f',
-    },
-    boolean: ['force'],
-    default: {
-      force: false,
-    },
-  })
-
-  ;({ force } = opts)
-  await asyncMap(opts._, async vmDir => {
-    vmDir = resolve(vmDir)
-
-    // TODO: implement this in `xo-server`, not easy because not compatible with
-    // `@xen-orchestra/fs`.
-    const release = await lockfile.lock(vmDir)
-    try {
-      await handleVm(vmDir)
-    } catch (error) {
-      console.error('handleVm', vmDir, error)
-    } finally {
-      await release()
-    }
-  })
-}

@xen-orchestra/backups-cli/commands/create-symlink-index.js

@@ -1,28 +0,0 @@
-const filenamify = require('filenamify')
-const get = require('lodash/get')
-const { dirname, join, relative } = require('path')
-
-const asyncMap = require('../_asyncMap')
-const { mktree, readdir2, readFile, symlink2 } = require('../_fs')
-
-module.exports = async function createSymlinkIndex([backupDir, fieldPath]) {
-  const indexDir = join(backupDir, 'indexes', filenamify(fieldPath))
-  await mktree(indexDir)
-
-  await asyncMap(await readdir2(backupDir), async vmDir =>
-    asyncMap(
-      (await readdir2(vmDir)).filter(_ => _.endsWith('.json')),
-      async json => {
-        const metadata = JSON.parse(await readFile(json))
-        const value = get(metadata, fieldPath)
-        if (value !== undefined) {
-          const target = relative(indexDir, dirname(json))
-          const path = join(indexDir, filenamify(String(value)))
-          await symlink2(target, path).catch(error => {
-            console.warn('symlink(%s, %s)', target, path, error)
-          })
-        }
-      }
-    )
-  )
-}

@xen-orchestra/backups-cli/index.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-
-require('./_composeCommands')({
-  'clean-vms': {
-    get main() {
-      return require('./commands/clean-vms')
-    },
-    usage: '[--force] xo-vm-backups/*',
-  },
-  'create-symlink-index': {
-    get main() {
-      return require('./commands/create-symlink-index')
-    },
-    usage: 'xo-vm-backups <field path>',
-  },
-})(process.argv.slice(2), 'xo-backups').catch(error => {
-  console.error('main', error)
-  process.exitCode = 1
-})

@xen-orchestra/backups-cli/package.json

@@ -1,41 +0,0 @@
-{
-  "private": false,
-  "bin": {
-    "xo-backups": "index.js"
-  },
-  "preferGlobal": true,
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "dependencies": {
-    "@xen-orchestra/backups": "^0.1.1",
-    "@xen-orchestra/fs": "^0.10.4",
-    "filenamify": "^4.1.0",
-    "getopts": "^2.2.5",
-    "lodash": "^4.17.15",
-    "promise-toolbox": "^0.15.0",
-    "proper-lockfile": "^4.1.1",
-    "vhd-lib": "^0.7.2"
-  },
-  "engines": {
-    "node": ">=7.10.1"
-  },
-  "files": [
-    "commands",
-    "*.js"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/backups-cli",
-  "name": "@xen-orchestra/backups-cli",
-  "repository": {
-    "directory": "@xen-orchestra/backups-cli",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  },
-  "version": "0.0.0",
-  "license": "AGPL-3.0-or-later",
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  }
-}

@xen-orchestra/backups/README.md

@@ -1,28 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/backups
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/backups)](https://npmjs.org/package/@xen-orchestra/backups) ![License](https://badgen.net/npm/license/@xen-orchestra/backups) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/backups)](https://bundlephobia.com/result?p=@xen-orchestra/backups) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/backups)](https://npmjs.org/package/@xen-orchestra/backups)
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/backups):
-
-```
-> npm install --save @xen-orchestra/backups
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[AGPL-3.0-or-later](https://spdx.org/licenses/AGPL-3.0-or-later) © [Vates SAS](https://vates.fr)

@xen-orchestra/backups/extractIdsFromSimplePattern.js

@@ -1,30 +0,0 @@
-function extractIdsFromSimplePattern(pattern) {
-  if (pattern === undefined) {
-    return []
-  }
-
-  if (pattern !== null && typeof pattern === 'object') {
-    let keys = Object.keys(pattern)
-
-    if (keys.length === 1 && keys[0] === 'id') {
-      pattern = pattern.id
-      if (typeof pattern === 'string') {
-        return [pattern]
-      }
-      if (pattern !== null && typeof pattern === 'object') {
-        keys = Object.keys(pattern)
-        if (
-          keys.length === 1 &&
-          keys[0] === '__or' &&
-          Array.isArray((pattern = pattern.__or)) &&
-          pattern.every(_ => typeof _ === 'string')
-        ) {
-          return pattern
-        }
-      }
-    }
-  }
-
-  throw new Error('invalid pattern')
-}
-exports.extractIdsFromSimplePattern = extractIdsFromSimplePattern

@xen-orchestra/backups/filenameDate.js

@@ -1,6 +0,0 @@
-const { utcFormat, utcParse } = require('d3-time-format')
-
-// Format a date in ISO 8601 in a safe way to be used in filenames
-// (even on Windows).
-exports.formatFilenameDate = utcFormat('%Y%m%dT%H%M%SZ')
-exports.parseFilenameDate = utcParse('%Y%m%dT%H%M%SZ')

@xen-orchestra/backups/getOldEntries.js

@@ -1,7 +0,0 @@
-// returns all entries but the last retention-th
-exports.getOldEntries = (retention, entries) =>
-  entries === undefined
-    ? []
-    : retention > 0
-    ? entries.slice(0, -retention)
-    : entries

@xen-orchestra/backups/isValidXva.js

@@ -1,65 +0,0 @@
-const assert = require('assert')
-const fs = require('fs-extra')
-
-const isGzipFile = async fd => {
-  // https://tools.ietf.org/html/rfc1952.html#page-5
-  const magicNumber = Buffer.allocUnsafe(2)
-  assert.strictEqual(
-    (await fs.read(fd, magicNumber, 0, magicNumber.length, 0)).bytesRead,
-    magicNumber.length
-  )
-  return magicNumber[0] === 31 && magicNumber[1] === 139
-}
-
-// TODO: better check?
-//
-// our heuristic is not good enough, there has been some false positives
-// (detected as invalid by us but valid by `tar` and imported with success),
-// either THOUGH THEY MAY HAVE BEEN COMPRESSED FILES:
-// - these files were normal but the check is incorrect
-// - these files were invalid but without data loss
-// - these files were invalid but with silent data loss
-//
-// maybe reading the end of the file looking for a file named
-// /^Ref:\d+/\d+\.checksum$/ and then validating the tar structure from it
-//
-// https://github.com/npm/node-tar/issues/234#issuecomment-538190295
-const isValidTar = async (size, fd) => {
-  if (size <= 1024 || size % 512 !== 0) {
-    return false
-  }
-
-  const buf = Buffer.allocUnsafe(1024)
-  assert.strictEqual(
-    (await fs.read(fd, buf, 0, buf.length, size - buf.length)).bytesRead,
-    buf.length
-  )
-  return buf.every(_ => _ === 0)
-}
-
-// TODO: find an heuristic for compressed files
-const isValidXva = async path => {
-  try {
-    const fd = await fs.open(path, 'r')
-    try {
-      const { size } = await fs.fstat(fd)
-      if (size < 20) {
-        // neither a valid gzip not tar
-        return false
-      }
-
-      return (await isGzipFile(fd))
-        ? true // gzip files cannot be validated at this time
-        : await isValidTar(size, fd)
-    } finally {
-      fs.close(fd).catch(noop)
-    }
-  } catch (error) {
-    // never throw, log and report as valid to avoid side effects
-    console.error('isValidXva', path, error)
-    return true
-  }
-}
-exports.isValidXva = isValidXva
-
-const noop = Function.prototype

@xen-orchestra/backups/package.json

@@ -1,27 +0,0 @@
-{
-  "private": false,
-  "name": "@xen-orchestra/backups",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/backups",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@xen-orchestra/backups",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "version": "0.1.1",
-  "engines": {
-    "node": ">=8.10"
-  },
-  "scripts": {
-    "postversion": "npm publish --access public"
-  },
-  "dependencies": {
-    "d3-time-format": "^2.2.3",
-    "fs-extra": "^9.0.0"
-  },
-  "license": "AGPL-3.0-or-later",
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  }
-}

@xen-orchestra/backups/watchStreamSize.js

@@ -1,11 +0,0 @@
-exports.watchStreamSize = stream => {
-  const container = { size: 0 }
-  const isPaused = stream.isPaused()
-  stream.on('data', data => {
-    container.size += data.length
-  })
-  if (isPaused) {
-    stream.pause()
-  }
-  return container
-}

@xen-orchestra/cr-seed-cli/README.md

@@ -1,28 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/cr-seed-cli
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/cr-seed-cli)](https://npmjs.org/package/@xen-orchestra/cr-seed-cli) ![License](https://badgen.net/npm/license/@xen-orchestra/cr-seed-cli) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/cr-seed-cli)](https://bundlephobia.com/result?p=@xen-orchestra/cr-seed-cli) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/cr-seed-cli)](https://npmjs.org/package/@xen-orchestra/cr-seed-cli)
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/cr-seed-cli):
-
-```
-> npm install --global @xen-orchestra/cr-seed-cli
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[AGPL-3.0-or-later](https://spdx.org/licenses/AGPL-3.0-or-later) © [Vates SAS](https://vates.fr)

@xen-orchestra/cr-seed-cli/index.js

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-
-const defer = require('golike-defer').default
-const { NULL_REF, Xapi } = require('xen-api')
-
-const pkg = require('./package.json')
-
-Xapi.prototype.getVmDisks = async function (vm) {
-  const disks = { __proto__: null }
-  await Promise.all([
-    ...vm.VBDs.map(async vbdRef => {
-      const vbd = await this.getRecord('VBD', vbdRef)
-      let vdiRef
-      if (vbd.type === 'Disk' && (vdiRef = vbd.VDI) !== NULL_REF) {
-        disks[vbd.userdevice] = await this.getRecord('VDI', vdiRef)
-      }
-    }),
-  ])
-  return disks
-}
-
-defer(async function main($defer, args) {
-  if (args.length === 0 || args.includes('-h') || args.includes('--help')) {
-    const cliName = Object.keys(pkg.bin)[0]
-    return console.error(
-      '%s',
-      `
-Usage: ${cliName} <source XAPI URL> <source snapshot UUID> <target XAPI URL> <target VM UUID> <backup job id> <backup schedule id>
-
-${cliName} v${pkg.version}
-`
-    )
-  }
-
-  const [
-    srcXapiUrl,
-    srcSnapshotUuid,
-    tgtXapiUrl,
-    tgtVmUuid,
-    jobId,
-    scheduleId,
-  ] = args
-
-  const srcXapi = new Xapi({
-    allowUnauthorized: true,
-    url: srcXapiUrl,
-    watchEvents: false,
-  })
-  await srcXapi.connect()
-  defer.call(srcXapi, 'disconnect')
-
-  const tgtXapi = new Xapi({
-    allowUnauthorized: true,
-    url: tgtXapiUrl,
-    watchEvents: false,
-  })
-  await tgtXapi.connect()
-  defer.call(tgtXapi, 'disconnect')
-
-  const [srcSnapshot, tgtVm] = await Promise.all([
-    srcXapi.getRecordByUuid('VM', srcSnapshotUuid),
-    tgtXapi.getRecordByUuid('VM', tgtVmUuid),
-  ])
-  const srcVm = await srcXapi.getRecord('VM', srcSnapshot.snapshot_of)
-
-  const metadata = {
-    'xo:backup:datetime': srcSnapshot.snapshot_time,
-    'xo:backup:job': jobId,
-    'xo:backup:schedule': scheduleId,
-    'xo:backup:vm': srcVm.uuid,
-  }
-
-  const [srcDisks, tgtDisks] = await Promise.all([
-    srcXapi.getVmDisks(srcSnapshot),
-    tgtXapi.getVmDisks(tgtVm),
-  ])
-  const userDevices = Object.keys(tgtDisks)
-
-  const tgtSr = await tgtXapi.getRecord(
-    'SR',
-    tgtDisks[Object.keys(tgtDisks)[0]].SR
-  )
-
-  await Promise.all([
-    srcSnapshot.update_other_config(metadata),
-    srcSnapshot.update_other_config('xo:backup:exported', 'true'),
-    tgtVm.set_name_label(`${srcVm.name_label} (${srcSnapshot.snapshot_time})`),
-    tgtVm.update_other_config(metadata),
-    tgtVm.update_other_config({
-      'xo:backup:sr': tgtSr.uuid,
-      'xo:copy_of': srcSnapshotUuid,
-    }),
-    tgtVm.update_blocked_operations(
-      'start',
-      'Start operation for this vm is blocked, clone it if you want to use it.'
-    ),
-    Promise.all(
-      userDevices.map(userDevice => {
-        const srcDisk = srcDisks[userDevice]
-        const tgtDisk = tgtDisks[userDevice]
-
-        return tgtDisk.update_other_config({
-          'xo:copy_of': srcDisk.uuid,
-        })
-      })
-    ),
-  ])
-})(process.argv.slice(2)).catch(console.error.bind(console, 'Fatal error:'))

@xen-orchestra/cr-seed-cli/package.json

@@ -1,31 +0,0 @@
-{
-  "private": false,
-  "name": "@xen-orchestra/cr-seed-cli",
-  "version": "0.2.0",
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/cr-seed-cli",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@xen-orchestra/cr-seed-cli",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "engines": {
-    "node": ">=8"
-  },
-  "bin": {
-    "xo-cr-seed": "./index.js"
-  },
-  "preferGlobal": true,
-  "dependencies": {
-    "golike-defer": "^0.4.1",
-    "xen-api": "^0.29.0"
-  },
-  "scripts": {
-    "postversion": "npm publish"
-  },
-  "license": "AGPL-3.0-or-later",
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  }
-}

@xen-orchestra/cron/.babelrc.js

@@ -1,3 +0,0 @@
-module.exports = require('../../@xen-orchestra/babel-config')(
-  require('./package.json')
-)

@xen-orchestra/cron/.npmignore

@@ -1,24 +0,0 @@
-/benchmark/
-/benchmarks/
-*.bench.js
-*.bench.js.map
-
-/examples/
-example.js
-example.js.map
-*.example.js
-*.example.js.map
-
-/fixture/
-/fixtures/
-*.fixture.js
-*.fixture.js.map
-*.fixtures.js
-*.fixtures.js.map
-
-/test/
-/tests/
-*.spec.js
-*.spec.js.map
-
-__snapshots__/

@xen-orchestra/cron/README.md

@@ -1,131 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/cron
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/cron)](https://npmjs.org/package/@xen-orchestra/cron) ![License](https://badgen.net/npm/license/@xen-orchestra/cron) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/cron)](https://bundlephobia.com/result?p=@xen-orchestra/cron) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/cron)](https://npmjs.org/package/@xen-orchestra/cron)
-
-> Focused, well maintained, cron parser/scheduler
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/cron):
-
-```
-> npm install --save @xen-orchestra/cron
-```
-
-## Usage
-
-### Pattern syntax
-
-```
-<minute> <hour> <day of month> <month> <day of week>
-```
-
-Each entry can be:
-
-- a single value
-- a range (`0-23` or `*/2`)
-- a list of values/ranges (`1,8-12`)
-
-A wildcard (`*`) can be used as a shortcut for the whole range
-(`first-last`).
-
-Step values can be used in conjunctions with ranges. For instance,
-`1-7/2` is the same as `1,3,5,7`.
-
-| Field            | Allowed values                                                     |
-| ---------------- | ------------------------------------------------------------------ |
-| minute           | 0-59                                                               |
-| hour             | 0-23                                                               |
-| day of the month | 1-31 or 3-letter names (`jan`, `feb`, …)                           |
-| month            | 0-11                                                               |
-| day of week      | 0-7 (0 and 7 both mean Sunday) or 3-letter names (`mon`, `tue`, …) |
-
-> Note: the month range is 0-11 to be compatible with
-> [cron](https://github.com/kelektiv/node-cron), it does not appear to
-> be very standard though.
-
-### API
-
-`createSchedule(pattern: string, zone: string = 'utc'): Schedule`
-
-> Create a new schedule.
-
-- `pattern`: the pattern to use, see [the syntax](#pattern-syntax)
-- `zone`: the timezone to use, use `'local'` for the local timezone
-
-```js
-import { createSchedule } from '@xen-orchestra/cron'
-
-const schedule = createSchedule('0 0 * * sun', 'America/New_York')
-```
-
-`Schedule#createJob(fn: Function): Job`
-
-> Create a new job from this schedule.
-
-- `fn`: function to execute, if it returns a promise, it will be
-  awaited before scheduling the next run.
-
-```js
-const job = schedule.createJob(() => {
-  console.log(new Date())
-})
-```
-
-`Schedule#next(n: number): Array<Date>`
-
-> Returns the next dates matching this schedule.
-
-- `n`: number of dates to return
-
-```js
-schedule.next(2)
-// [ 2018-02-11T05:00:00.000Z, 2018-02-18T05:00:00.000Z ]
-```
-
-`Schedule#startJob(fn: Function): () => void`
-
-> Start a new job from this schedule and return a function to stop it.
-
-- `fn`: function to execute, if it returns a promise, it will be
-  awaited before scheduling the next run.
-
-```js
-const stopJob = schedule.startJob(() => {
-  console.log(new Date())
-})
-stopJob()
-```
-
-`Job#start(): void`
-
-> Start this job.
-
-```js
-job.start()
-```
-
-`Job#stop(): void`
-
-> Stop this job.
-
-```js
-job.stop()
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@xen-orchestra/cron/USAGE.md

@@ -1,98 +0,0 @@
-### Pattern syntax
-
-```
-<minute> <hour> <day of month> <month> <day of week>
-```
-
-Each entry can be:
-
-- a single value
-- a range (`0-23` or `*/2`)
-- a list of values/ranges (`1,8-12`)
-
-A wildcard (`*`) can be used as a shortcut for the whole range
-(`first-last`).
-
-Step values can be used in conjunctions with ranges. For instance,
-`1-7/2` is the same as `1,3,5,7`.
-
-| Field            | Allowed values                                                     |
-| ---------------- | ------------------------------------------------------------------ |
-| minute           | 0-59                                                               |
-| hour             | 0-23                                                               |
-| day of the month | 1-31 or 3-letter names (`jan`, `feb`, …)                           |
-| month            | 0-11                                                               |
-| day of week      | 0-7 (0 and 7 both mean Sunday) or 3-letter names (`mon`, `tue`, …) |
-
-> Note: the month range is 0-11 to be compatible with
-> [cron](https://github.com/kelektiv/node-cron), it does not appear to
-> be very standard though.
-
-### API
-
-`createSchedule(pattern: string, zone: string = 'utc'): Schedule`
-
-> Create a new schedule.
-
-- `pattern`: the pattern to use, see [the syntax](#pattern-syntax)
-- `zone`: the timezone to use, use `'local'` for the local timezone
-
-```js
-import { createSchedule } from '@xen-orchestra/cron'
-
-const schedule = createSchedule('0 0 * * sun', 'America/New_York')
-```
-
-`Schedule#createJob(fn: Function): Job`
-
-> Create a new job from this schedule.
-
-- `fn`: function to execute, if it returns a promise, it will be
-  awaited before scheduling the next run.
-
-```js
-const job = schedule.createJob(() => {
-  console.log(new Date())
-})
-```
-
-`Schedule#next(n: number): Array<Date>`
-
-> Returns the next dates matching this schedule.
-
-- `n`: number of dates to return
-
-```js
-schedule.next(2)
-// [ 2018-02-11T05:00:00.000Z, 2018-02-18T05:00:00.000Z ]
-```
-
-`Schedule#startJob(fn: Function): () => void`
-
-> Start a new job from this schedule and return a function to stop it.
-
-- `fn`: function to execute, if it returns a promise, it will be
-  awaited before scheduling the next run.
-
-```js
-const stopJob = schedule.startJob(() => {
-  console.log(new Date())
-})
-stopJob()
-```
-
-`Job#start(): void`
-
-> Start this job.
-
-```js
-job.start()
-```
-
-`Job#stop(): void`
-
-> Stop this job.
-
-```js
-job.stop()
-```

@xen-orchestra/cron/package.json

@@ -1,62 +0,0 @@
-{
-  "private": false,
-  "name": "@xen-orchestra/cron",
-  "version": "1.0.6",
-  "license": "ISC",
-  "description": "Focused, well maintained, cron parser/scheduler",
-  "keywords": [
-    "cron",
-    "cronjob",
-    "crontab",
-    "job",
-    "parser",
-    "pattern",
-    "schedule",
-    "scheduling",
-    "task"
-  ],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/cron",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@xen-orchestra/cron",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "preferGlobal": false,
-  "main": "dist/",
-  "bin": {},
-  "files": [
-    "dist/"
-  ],
-  "browserslist": [
-    ">2%"
-  ],
-  "engines": {
-    "node": ">=6"
-  },
-  "dependencies": {
-    "lodash": "^4.17.4",
-    "moment-timezone": "^0.5.14"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.0.0",
-    "@babel/core": "^7.0.0",
-    "@babel/preset-env": "^7.0.0",
-    "@babel/preset-flow": "^7.0.0",
-    "cross-env": "^7.0.2",
-    "rimraf": "^3.0.0"
-  },
-  "scripts": {
-    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
-    "clean": "rimraf dist/",
-    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
-    "prebuild": "yarn run clean",
-    "predev": "yarn run clean",
-    "prepublishOnly": "yarn run build",
-    "postversion": "npm publish"
-  }
-}

@xen-orchestra/cron/src/index.js

@@ -1,105 +0,0 @@
-import moment from 'moment-timezone'
-
-import next from './next'
-import parse from './parse'
-
-const MAX_DELAY = 2 ** 31 - 1
-
-class Job {
-  constructor(schedule, fn) {
-    let scheduledDate
-    const wrapper = () => {
-      const now = Date.now()
-      if (scheduledDate > now) {
-        // we're early, delay
-        //
-        // no need to check _isEnabled, we're just delaying the existing timeout
-        //
-        // see https://github.com/vatesfr/xen-orchestra/issues/4625
-        this._timeout = setTimeout(wrapper, scheduledDate - now)
-        return
-      }
-
-      this._isRunning = true
-
-      let result
-      try {
-        result = fn()
-      } catch (_) {
-        // catch any thrown value to ensure it does not break the job
-      }
-      let then
-      if (result != null && typeof (then = result.then) === 'function') {
-        then.call(result, scheduleNext, scheduleNext)
-      } else {
-        scheduleNext()
-      }
-    }
-    const scheduleNext = () => {
-      this._isRunning = false
-
-      if (this._isEnabled) {
-        const now = schedule._createDate()
-        scheduledDate = +next(schedule._schedule, now)
-        const delay = scheduledDate - now
-        this._timeout =
-          delay < MAX_DELAY
-            ? setTimeout(wrapper, delay)
-            : setTimeout(scheduleNext, MAX_DELAY)
-      }
-    }
-
-    this._isEnabled = false
-    this._isRunning = false
-    this._scheduleNext = scheduleNext
-    this._timeout = undefined
-  }
-
-  start() {
-    this.stop()
-
-    this._isEnabled = true
-    if (!this._isRunning) {
-      this._scheduleNext()
-    }
-  }
-
-  stop() {
-    this._isEnabled = false
-    clearTimeout(this._timeout)
-  }
-}
-
-class Schedule {
-  constructor(pattern, zone = 'utc') {
-    this._schedule = parse(pattern)
-    this._createDate =
-      zone.toLowerCase() === 'utc'
-        ? moment.utc
-        : zone === 'local'
-        ? moment
-        : () => moment.tz(zone)
-  }
-
-  createJob(fn) {
-    return new Job(this, fn)
-  }
-
-  next(n) {
-    const dates = new Array(n)
-    const schedule = this._schedule
-    let date = this._createDate()
-    for (let i = 0; i < n; ++i) {
-      dates[i] = (date = next(schedule, date)).toDate()
-    }
-    return dates
-  }
-
-  startJob(fn) {
-    const job = this.createJob(fn)
-    job.start()
-    return job.stop.bind(job)
-  }
-}
-
-export const createSchedule = (...args) => new Schedule(...args)

@xen-orchestra/cron/src/index.spec.js

@@ -1,78 +0,0 @@
-/* eslint-env jest */
-
-import { createSchedule } from './'
-
-const wrap = value => () => value
-
-describe('issues', () => {
-  let originalDateNow
-  beforeAll(() => {
-    originalDateNow = Date.now
-  })
-  afterAll(() => {
-    Date.now = originalDateNow
-    originalDateNow = undefined
-  })
-
-  test('stop during async execution', async () => {
-    let nCalls = 0
-    let resolve, promise
-
-    const schedule = createSchedule('* * * * *')
-    const job = schedule.createJob(() => {
-      ++nCalls
-
-      // eslint-disable-next-line promise/param-names
-      promise = new Promise(r => {
-        resolve = r
-      })
-      return promise
-    })
-
-    job.start()
-    Date.now = wrap(+schedule.next(1)[0])
-    jest.runAllTimers()
-
-    expect(nCalls).toBe(1)
-
-    job.stop()
-
-    resolve()
-    await promise
-
-    jest.runAllTimers()
-    expect(nCalls).toBe(1)
-  })
-
-  test('stop then start during async job execution', async () => {
-    let nCalls = 0
-    let resolve, promise
-
-    const schedule = createSchedule('* * * * *')
-    const job = schedule.createJob(() => {
-      ++nCalls
-
-      // eslint-disable-next-line promise/param-names
-      promise = new Promise(r => {
-        resolve = r
-      })
-      return promise
-    })
-
-    job.start()
-    Date.now = wrap(+schedule.next(1)[0])
-    jest.runAllTimers()
-
-    expect(nCalls).toBe(1)
-
-    job.stop()
-    job.start()
-
-    resolve()
-    await promise
-
-    Date.now = wrap(+schedule.next(1)[0])
-    jest.runAllTimers()
-    expect(nCalls).toBe(2)
-  })
-})

@xen-orchestra/cron/src/next.js

@@ -1,89 +0,0 @@
-import moment from 'moment-timezone'
-import sortedIndex from 'lodash/sortedIndex'
-
-const NEXT_MAPPING = {
-  month: { year: 1 },
-  date: { month: 1 },
-  day: { week: 1 },
-  hour: { day: 1 },
-  minute: { hour: 1 },
-}
-
-const getFirst = values => (values !== undefined ? values[0] : 0)
-
-const setFirstAvailable = (date, unit, values) => {
-  if (values === undefined) {
-    return
-  }
-
-  const curr = date.get(unit)
-  const next = values[sortedIndex(values, curr) % values.length]
-  if (curr === next) {
-    return
-  }
-
-  const timestamp = +date
-  date.set(unit, next)
-  if (timestamp > +date) {
-    date.add(NEXT_MAPPING[unit])
-  }
-  return true
-}
-
-// returns the next run, after the passed date
-export default (schedule, fromDate) => {
-  let date = moment(fromDate)
-    .set({
-      second: 0,
-      millisecond: 0,
-    })
-    .add({ minute: 1 })
-
-  const { minute, hour, dayOfMonth, month, dayOfWeek } = schedule
-  setFirstAvailable(date, 'minute', minute)
-
-  if (setFirstAvailable(date, 'hour', hour)) {
-    date.set('minute', getFirst(minute))
-  }
-
-  let loop
-  let i = 0
-  do {
-    loop = false
-
-    if (setFirstAvailable(date, 'month', month)) {
-      date.set({
-        date: 1,
-        hour: getFirst(hour),
-        minute: getFirst(minute),
-      })
-    }
-
-    let newDate = date.clone()
-    if (dayOfMonth === undefined) {
-      if (dayOfWeek !== undefined) {
-        setFirstAvailable(newDate, 'day', dayOfWeek)
-      }
-    } else if (dayOfWeek === undefined) {
-      setFirstAvailable(newDate, 'date', dayOfMonth)
-    } else {
-      const dateDay = newDate.clone()
-      setFirstAvailable(dateDay, 'date', dayOfMonth)
-      setFirstAvailable(newDate, 'day', dayOfWeek)
-      newDate = moment.min(dateDay, newDate)
-    }
-    if (+date !== +newDate) {
-      loop = date.month() !== newDate.month()
-      date = newDate.set({
-        hour: getFirst(hour),
-        minute: getFirst(minute),
-      })
-    }
-  } while (loop && ++i < 5)
-
-  if (loop) {
-    throw new Error('no solutions found for this schedule')
-  }
-
-  return date
-}

@xen-orchestra/cron/src/next.spec.js

@@ -1,48 +0,0 @@
-/* eslint-env jest */
-
-import mapValues from 'lodash/mapValues'
-import moment from 'moment-timezone'
-
-import next from './next'
-import parse from './parse'
-
-const N = (pattern, fromDate = '2018-04-09T06:25') => {
-  const iso = next(parse(pattern), moment.utc(fromDate)).toISOString()
-  return iso.slice(0, iso.lastIndexOf(':'))
-}
-
-describe('next()', () => {
-  mapValues(
-    {
-      minutely: ['* * * * *', '2018-04-09T06:26'],
-      hourly: ['@hourly', '2018-04-09T07:00'],
-      daily: ['@daily', '2018-04-10T00:00'],
-      monthly: ['@monthly', '2018-05-01T00:00'],
-      yearly: ['@yearly', '2019-01-01T00:00'],
-      weekly: ['@weekly', '2018-04-15T00:00'],
-    },
-    ([pattern, result], title) =>
-      it(title, () => {
-        expect(N(pattern)).toBe(result)
-      })
-  )
-
-  it('select first between month-day and week-day', () => {
-    expect(N('* * 10 * wen')).toBe('2018-04-10T00:00')
-    expect(N('* * 12 * wen')).toBe('2018-04-11T00:00')
-  })
-
-  it('select the last available day of a month', () => {
-    expect(N('* * 29 feb *')).toBe('2020-02-29T00:00')
-  })
-
-  it('fails when no solutions has been found', () => {
-    expect(() => N('0 0 30 feb *')).toThrow(
-      'no solutions found for this schedule'
-    )
-  })
-
-  it('select the first sunday of the month', () => {
-    expect(N('* * * * 0', '2018-03-31T00:00')).toBe('2018-04-01T00:00')
-  })
-})

@xen-orchestra/cron/src/parse.js

@@ -1,193 +0,0 @@
-const compareNumbers = (a, b) => a - b
-
-const createParser = ({ fields: [...fields], presets: { ...presets } }) => {
-  const m = fields.length
-
-  for (let j = 0; j < m; ++j) {
-    const field = fields[j]
-    let { aliases } = field
-    if (aliases !== undefined) {
-      let symbols = aliases
-
-      if (Array.isArray(aliases)) {
-        aliases = {}
-        const [start] = field.range
-        symbols.forEach((alias, i) => {
-          aliases[alias] = start + i
-        })
-      } else {
-        symbols = Object.keys(aliases)
-      }
-
-      fields[j] = {
-        ...field,
-        aliases,
-        aliasesRegExp: new RegExp(symbols.join('|'), 'y'),
-      }
-    }
-  }
-
-  let field, i, n, pattern, schedule, values
-
-  const isDigit = c => c >= '0' && c <= '9'
-  const match = c => pattern[i] === c && (++i, true)
-
-  const consumeWhitespaces = () => {
-    let c
-    while ((c = pattern[i]) === ' ' || c === '\t') {
-      ++i
-    }
-  }
-
-  const parseInteger = () => {
-    let c
-    const digits = []
-    while (isDigit((c = pattern[i]))) {
-      ++i
-      digits.push(c)
-    }
-    if (digits.length === 0) {
-      throw new SyntaxError(`${field.name}: missing integer at character ${i}`)
-    }
-    return Number.parseInt(digits.join(''), 10)
-  }
-
-  const parseValue = () => {
-    let value
-
-    const { aliasesRegExp } = field
-    if (aliasesRegExp === undefined || isDigit(pattern[i])) {
-      value = parseInteger()
-      const { post } = field
-      if (post !== undefined) {
-        value = post(value)
-      }
-    } else {
-      aliasesRegExp.lastIndex = i
-      const matches = aliasesRegExp.exec(pattern)
-      if (matches === null) {
-        throw new SyntaxError(
-          `${field.name}: missing alias or integer at character ${i}`
-        )
-      }
-      const [alias] = matches
-      i += alias.length
-      value = field.aliases[alias]
-    }
-
-    const { range } = field
-    if (value < range[0] || value > range[1]) {
-      throw new SyntaxError(
-        `${field.name}: ${value} is not between ${range[0]} and ${range[1]}`
-      )
-    }
-    return value
-  }
-
-  const parseRange = () => {
-    let end, start, step
-    if (match('*')) {
-      if (!match('/')) {
-        return
-      }
-      ;[start, end] = field.range
-      step = parseInteger()
-    } else {
-      start = parseValue()
-      if (!match('-')) {
-        values.add(start)
-        return
-      }
-      end = parseValue()
-      step = match('/') ? parseInteger() : 1
-    }
-
-    for (let i = start; i <= end; i += step) {
-      values.add(i)
-    }
-  }
-
-  const parseSequence = () => {
-    do {
-      parseRange()
-    } while (match(','))
-  }
-
-  const parse = p => {
-    {
-      const schedule = presets[p]
-      if (schedule !== undefined) {
-        return typeof schedule === 'string'
-          ? (presets[p] = parse(schedule))
-          : schedule
-      }
-    }
-
-    try {
-      i = 0
-      n = p.length
-      pattern = p
-      schedule = {}
-
-      for (let j = 0; j < m; ++j) {
-        consumeWhitespaces()
-
-        field = fields[j]
-        values = new Set()
-        parseSequence()
-        if (values.size !== 0) {
-          schedule[field.name] = Array.from(values).sort(compareNumbers)
-        }
-      }
-
-      consumeWhitespaces()
-      if (i !== n) {
-        throw new SyntaxError(
-          `unexpected character at offset ${i}, expected end`
-        )
-      }
-
-      return schedule
-    } finally {
-      field = pattern = schedule = values = undefined
-    }
-  }
-
-  return parse
-}
-
-export default createParser({
-  fields: [
-    {
-      name: 'minute',
-      range: [0, 59],
-    },
-    {
-      name: 'hour',
-      range: [0, 23],
-    },
-    {
-      name: 'dayOfMonth',
-      range: [1, 31],
-    },
-    {
-      aliases: 'jan feb mar apr may jun jul aug sep oct nov dec'.split(' '),
-      name: 'month',
-      range: [0, 11],
-    },
-    {
-      aliases: 'sun mon tue wen thu fri sat'.split(' '),
-      name: 'dayOfWeek',
-      post: value => (value === 7 ? 0 : value),
-      range: [0, 6],
-    },
-  ],
-  presets: {
-    '@annually': '0 0 1 jan *',
-    '@daily': '0 0 * * *',
-    '@hourly': '0 * * * *',
-    '@monthly': '0 0 1 * *',
-    '@weekly': '0 0 * * sun',
-    '@yearly': '0 0 1 jan *',
-  },
-})

@xen-orchestra/cron/src/parse.spec.js

@@ -1,49 +0,0 @@
-/* eslint-env jest */
-
-import parse from './parse'
-
-describe('parse()', () => {
-  it('works', () => {
-    expect(parse('0 0-10 */10 jan,2,4-11/3 *')).toEqual({
-      minute: [0],
-      hour: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
-      dayOfMonth: [1, 11, 21, 31],
-      month: [0, 2, 4, 7, 10],
-    })
-  })
-
-  it('correctly parse months', () => {
-    expect(parse('* * * 0,11 *')).toEqual({
-      month: [0, 11],
-    })
-    expect(parse('* * * jan,dec *')).toEqual({
-      month: [0, 11],
-    })
-  })
-
-  it('correctly parse days', () => {
-    expect(parse('* * * * mon,sun')).toEqual({
-      dayOfWeek: [0, 1],
-    })
-  })
-
-  it('reports missing integer', () => {
-    expect(() => parse('*/a')).toThrow('minute: missing integer at character 2')
-    expect(() => parse('*')).toThrow('hour: missing integer at character 1')
-  })
-
-  it('reports invalid aliases', () => {
-    expect(() => parse('* * * jan-foo *')).toThrow(
-      'month: missing alias or integer at character 10'
-    )
-  })
-
-  it('dayOfWeek: 0 and 7 bind to sunday', () => {
-    expect(parse('* * * * 0')).toEqual({
-      dayOfWeek: [0],
-    })
-    expect(parse('* * * * 7')).toEqual({
-      dayOfWeek: [0],
-    })
-  })
-})

@xen-orchestra/defined/.babelrc.js

@@ -1,3 +0,0 @@
-module.exports = require('../../@xen-orchestra/babel-config')(
-  require('./package.json')
-)

@xen-orchestra/defined/.npmignore

@@ -1,24 +0,0 @@
-/benchmark/
-/benchmarks/
-*.bench.js
-*.bench.js.map
-
-/examples/
-example.js
-example.js.map
-*.example.js
-*.example.js.map
-
-/fixture/
-/fixtures/
-*.fixture.js
-*.fixture.js.map
-*.fixtures.js
-*.fixtures.js.map
-
-/test/
-/tests/
-*.spec.js
-*.spec.js.map
-
-__snapshots__/

@xen-orchestra/defined/README.md

@@ -1,28 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/defined
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/defined)](https://npmjs.org/package/@xen-orchestra/defined) ![License](https://badgen.net/npm/license/@xen-orchestra/defined) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/defined)](https://bundlephobia.com/result?p=@xen-orchestra/defined) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/defined)](https://npmjs.org/package/@xen-orchestra/defined)
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/defined):
-
-```
-> npm install --save @xen-orchestra/defined
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@xen-orchestra/defined/package.json

@@ -1,50 +0,0 @@
-{
-  "private": false,
-  "name": "@xen-orchestra/defined",
-  "version": "0.0.0",
-  "license": "ISC",
-  "description": "",
-  "keywords": [],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/defined",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@xen-orchestra/defined",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "preferGlobal": false,
-  "main": "dist/",
-  "bin": {},
-  "files": [
-    "dist/"
-  ],
-  "browserslist": [
-    ">2%"
-  ],
-  "engines": {
-    "node": ">=6"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "@babel/cli": "^7.0.0",
-    "@babel/core": "^7.0.0",
-    "@babel/preset-env": "^7.0.0",
-    "@babel/preset-flow": "^7.0.0",
-    "babel-plugin-lodash": "^3.3.2",
-    "cross-env": "^7.0.2",
-    "rimraf": "^3.0.0"
-  },
-  "scripts": {
-    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
-    "clean": "rimraf dist/",
-    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
-    "prebuild": "yarn run clean",
-    "predev": "yarn run prebuild",
-    "prepublishOnly": "yarn run build",
-    "postversion": "npm publish"
-  }
-}

@xen-orchestra/defined/src/index.js

@@ -1,64 +0,0 @@
-// @flow
-
-// Usage:
-//
-// ```js
-// const httpProxy = defined(
-//   process.env.HTTP_PROXY,
-//   process.env.http_proxy
-// )
-//
-// const httpProxy = defined([
-//   process.env.HTTP_PROXY,
-//   process.env.http_proxy
-// ])
-// ```
-export default function defined() {
-  let args = arguments
-  let n = args.length
-  if (n === 1) {
-    args = arguments[0]
-    n = args.length
-  }
-
-  for (let i = 0; i < n; ++i) {
-    let arg = arguments[i]
-    if (typeof arg === 'function') {
-      arg = get(arg)
-    }
-    if (arg !== undefined) {
-      return arg
-    }
-  }
-}
-
-// Usage:
-//
-// ```js
-// const friendName = get(() => props.user.friends[0].name)
-//
-// // this form can be used to avoid recreating functions:
-// const getFriendName = _ => _.friends[0].name
-// const friendName = get(getFriendName, props.user)
-// ```
-export const get = (accessor: (input: ?any) => any, arg: ?any) => {
-  try {
-    return accessor(arg)
-  } catch (error) {
-    if (!(error instanceof TypeError)) {
-      // avoid hiding other errors
-      throw error
-    }
-  }
-}
-
-// Usage:
-//
-// ```js
-// const httpAgent = ifDef(
-//   process.env.HTTP_PROXY,
-//   _ => new ProxyAgent(_)
-// )
-// ```
-export const ifDef = (value: ?any, thenFn: (value: any) => any) =>
-  value !== undefined ? thenFn(value) : value

@xen-orchestra/emit-async/.babelrc.js

@@ -1,3 +0,0 @@
-module.exports = require('../../@xen-orchestra/babel-config')(
-  require('./package.json')
-)

@xen-orchestra/emit-async/.npmignore

@@ -1,24 +0,0 @@
-/benchmark/
-/benchmarks/
-*.bench.js
-*.bench.js.map
-
-/examples/
-example.js
-example.js.map
-*.example.js
-*.example.js.map
-
-/fixture/
-/fixtures/
-*.fixture.js
-*.fixture.js.map
-*.fixtures.js
-*.fixtures.js.map
-
-/test/
-/tests/
-*.spec.js
-*.spec.js.map
-
-__snapshots__/

@xen-orchestra/emit-async/README.md

@@ -1,57 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/emit-async
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/emit-async)](https://npmjs.org/package/@xen-orchestra/emit-async) ![License](https://badgen.net/npm/license/@xen-orchestra/emit-async) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/emit-async)](https://bundlephobia.com/result?p=@xen-orchestra/emit-async) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/emit-async)](https://npmjs.org/package/@xen-orchestra/emit-async)
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/emit-async):
-
-```
-> npm install --save @xen-orchestra/emit-async
-```
-
-## Usage
-
-```js
-import EE from 'events'
-import emitAsync from '@xen-orchestra/emit-async'
-
-const ee = new EE()
-ee.emitAsync = emitAsync
-
-ee.on('start', async function () {
-  // whatever
-})
-
-// similar to EventEmmiter#emit() but returns a promise which resolves when all
-// listeners have resolved
-await ee.emitAsync('start')
-
-// by default, it will rejects as soon as one listener reject, you can customise
-// error handling though:
-await ee.emitAsync(
-  {
-    onError(error) {
-      console.warn(error)
-    },
-  },
-  'start'
-)
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[ISC](https://spdx.org/licenses/ISC) © [Vates SAS](https://vates.fr)

@xen-orchestra/emit-async/USAGE.md

@@ -1,26 +0,0 @@
-```js
-import EE from 'events'
-import emitAsync from '@xen-orchestra/emit-async'
-
-const ee = new EE()
-ee.emitAsync = emitAsync
-
-ee.on('start', async function () {
-  // whatever
-})
-
-// similar to EventEmmiter#emit() but returns a promise which resolves when all
-// listeners have resolved
-await ee.emitAsync('start')
-
-// by default, it will rejects as soon as one listener reject, you can customise
-// error handling though:
-await ee.emitAsync(
-  {
-    onError(error) {
-      console.warn(error)
-    },
-  },
-  'start'
-)
-```

@xen-orchestra/emit-async/package.json

@@ -1,49 +0,0 @@
-{
-  "private": false,
-  "name": "@xen-orchestra/emit-async",
-  "version": "0.0.0",
-  "license": "ISC",
-  "description": "",
-  "keywords": [],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/emit-async",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@xen-orchestra/emit-async",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  },
-  "preferGlobal": false,
-  "main": "dist/",
-  "bin": {},
-  "files": [
-    "dist/"
-  ],
-  "browserslist": [
-    ">2%"
-  ],
-  "engines": {
-    "node": ">=6"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "@babel/cli": "^7.0.0",
-    "@babel/core": "^7.0.0",
-    "@babel/preset-env": "^7.0.0",
-    "babel-plugin-lodash": "^3.3.2",
-    "cross-env": "^7.0.2",
-    "rimraf": "^3.0.0"
-  },
-  "scripts": {
-    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
-    "clean": "rimraf dist/",
-    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
-    "prebuild": "yarn run clean",
-    "predev": "yarn run prebuild",
-    "prepublishOnly": "yarn run build",
-    "postversion": "npm publish"
-  }
-}

@xen-orchestra/emit-async/src/index.js

@@ -1,26 +0,0 @@
-export default function emitAsync(event) {
-  let opts
-  let i = 1
-
-  // an option object has been passed as first param
-  if (typeof event !== 'string') {
-    opts = event
-    event = arguments[i++]
-  }
-
-  const n = arguments.length - i
-  const args = new Array(n)
-  for (let j = 0; j < n; ++j) {
-    args[j] = arguments[j + i]
-  }
-
-  const onError = opts != null && opts.onError
-
-  return Promise.all(
-    this.listeners(event).map(listener =>
-      new Promise(resolve => {
-        resolve(listener.apply(this, args))
-      }).catch(onError)
-    )
-  )
-}

@xen-orchestra/fs/.babelrc.js

@@ -1,3 +0,0 @@
-module.exports = require('../../@xen-orchestra/babel-config')(
-  require('./package.json')
-)

@xen-orchestra/fs/README.md

@@ -1,30 +0,0 @@
-<!-- DO NOT EDIT MANUALLY, THIS FILE HAS BEEN GENERATED -->
-
-# @xen-orchestra/fs
-
-[![Package Version](https://badgen.net/npm/v/@xen-orchestra/fs)](https://npmjs.org/package/@xen-orchestra/fs) ![License](https://badgen.net/npm/license/@xen-orchestra/fs) [![PackagePhobia](https://badgen.net/bundlephobia/minzip/@xen-orchestra/fs)](https://bundlephobia.com/result?p=@xen-orchestra/fs) [![Node compatibility](https://badgen.net/npm/node/@xen-orchestra/fs)](https://npmjs.org/package/@xen-orchestra/fs)
-
-> The File System for Xen Orchestra backups.
-
-## Install
-
-Installation of the [npm package](https://npmjs.org/package/@xen-orchestra/fs):
-
-```
-> npm install --global @xen-orchestra/fs
-```
-
-## Contributions
-
-Contributions are _very_ welcomed, either on the documentation or on
-the code.
-
-You may:
-
-- report any [issue](https://github.com/vatesfr/xen-orchestra/issues)
-  you've encountered;
-- fork and create a pull request.
-
-## License
-
-[AGPL-3.0-or-later](https://spdx.org/licenses/AGPL-3.0-or-later) © [Vates SAS](https://vates.fr)

@xen-orchestra/fs/package.json

@@ -1,68 +0,0 @@
-{
-  "private": false,
-  "name": "@xen-orchestra/fs",
-  "version": "0.10.4",
-  "license": "AGPL-3.0-or-later",
-  "description": "The File System for Xen Orchestra backups.",
-  "keywords": [],
-  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/@xen-orchestra/fs",
-  "bugs": "https://github.com/vatesfr/xen-orchestra/issues",
-  "repository": {
-    "directory": "@xen-orchestra/fs",
-    "type": "git",
-    "url": "https://github.com/vatesfr/xen-orchestra.git"
-  },
-  "preferGlobal": true,
-  "main": "dist/",
-  "bin": {},
-  "files": [
-    "dist/"
-  ],
-  "engines": {
-    "node": ">=8.10"
-  },
-  "dependencies": {
-    "@marsaud/smb2": "^0.15.0",
-    "@sindresorhus/df": "^3.1.1",
-    "@xen-orchestra/async-map": "^0.0.0",
-    "decorator-synchronized": "^0.5.0",
-    "execa": "^4.0.2",
-    "fs-extra": "^9.0.0",
-    "get-stream": "^5.1.0",
-    "limit-concurrency-decorator": "^0.4.0",
-    "lodash": "^4.17.4",
-    "promise-toolbox": "^0.15.0",
-    "readable-stream": "^3.0.6",
-    "through2": "^3.0.0",
-    "tmp": "^0.1.0",
-    "xo-remote-parser": "^0.5.0"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.0.0",
-    "@babel/core": "^7.0.0",
-    "@babel/plugin-proposal-decorators": "^7.1.6",
-    "@babel/plugin-proposal-function-bind": "^7.0.0",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.4.4",
-    "@babel/preset-env": "^7.0.0",
-    "@babel/preset-flow": "^7.0.0",
-    "async-iterator-to-stream": "^1.1.0",
-    "babel-plugin-lodash": "^3.3.2",
-    "cross-env": "^7.0.2",
-    "dotenv": "^8.0.0",
-    "index-modules": "^0.3.0",
-    "rimraf": "^3.0.0"
-  },
-  "scripts": {
-    "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
-    "clean": "rimraf dist/",
-    "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
-    "prebuild": "yarn run clean",
-    "predev": "yarn run clean",
-    "prepare": "yarn run build",
-    "postversion": "npm publish"
-  },
-  "author": {
-    "name": "Vates SAS",
-    "url": "https://vates.fr"
-  }
-}

@xen-orchestra/fs/src/_mount.js

@@ -1,108 +0,0 @@
-import execa from 'execa'
-import fs from 'fs-extra'
-import { ignoreErrors } from 'promise-toolbox'
-import { join } from 'path'
-import { tmpdir } from 'os'
-
-import LocalHandler from './local'
-
-const sudoExeca = (command, args, opts) =>
-  execa('sudo', [command, ...args], opts)
-
-export default class MountHandler extends LocalHandler {
-  constructor(
-    remote,
-    {
-      mountsDir = join(tmpdir(), 'xo-fs-mounts'),
-      useSudo = false,
-      ...opts
-    } = {},
-    params
-  ) {
-    super(remote, opts)
-
-    this._execa = useSudo ? sudoExeca : execa
-    this._keeper = undefined
-    this._params = {
-      ...params,
-      options: [params.options, remote.options]
-        .filter(_ => _ !== undefined)
-        .join(','),
-    }
-    this._realPath = join(
-      mountsDir,
-      remote.id || Math.random().toString(36).slice(2)
-    )
-  }
-
-  async _forget() {
-    const keeper = this._keeper
-    if (keeper === undefined) {
-      return
-    }
-    this._keeper = undefined
-    await fs.close(keeper)
-
-    await ignoreErrors.call(
-      this._execa('umount', [this._getRealPath()], {
-        env: {
-          LANG: 'C',
-        },
-      })
-    )
-  }
-
-  _getRealPath() {
-    return this._realPath
-  }
-
-  async _sync() {
-    // in case of multiple `sync`s, ensure we properly close previous keeper
-    {
-      const keeper = this._keeper
-      if (keeper !== undefined) {
-        this._keeper = undefined
-        ignoreErrors.call(fs.close(keeper))
-      }
-    }
-
-    const realPath = this._getRealPath()
-
-    await fs.ensureDir(realPath)
-
-    try {
-      const { type, device, options, env } = this._params
-
-      // Linux mount is more flexible in which order the mount arguments appear.
-      // But FreeBSD requires this order of the arguments.
-      await this._execa(
-        'mount',
-        ['-o', options, '-t', type, device, realPath],
-        {
-          env: {
-            LANG: 'C',
-            ...env,
-          },
-        }
-      )
-    } catch (error) {
-      try {
-        // the failure may mean it's already mounted, use `findmnt` to check
-        // that's the case
-        await this._execa('findmnt', [realPath], {
-          stdio: 'ignore',
-        })
-      } catch (_) {
-        throw error
-      }
-    }
-
-    // keep an open file on the mount to prevent it from being unmounted if used
-    // by another handler/process
-    const keeperPath = `${realPath}/.keeper_${Math.random()
-      .toString(36)
-      .slice(2)}`
-    this._keeper = await fs.open(keeperPath, 'w')
-    ignoreErrors.call(fs.unlink(keeperPath))
-  }
-}

@xen-orchestra/fs/src/_normalizePath.js

@@ -1,9 +0,0 @@
-import path from 'path'
-
-const { resolve } = path.posix
-
-// normalize the path:
-// - does not contains `.` or `..`  (cannot escape root dir)
-// - always starts with `/`
-const normalizePath = path => resolve('/', path)
-export { normalizePath as default }

@xen-orchestra/fs/src/abstract.js

@@ -1,662 +0,0 @@
-// @flow
-
-// $FlowFixMe
-import getStream from 'get-stream'
-
-import asyncMap from '@xen-orchestra/async-map'
-import limit from 'limit-concurrency-decorator'
-import path from 'path'
-import synchronized from 'decorator-synchronized'
-import { fromCallback, fromEvent, ignoreErrors, timeout } from 'promise-toolbox'
-import { parse } from 'xo-remote-parser'
-import { randomBytes } from 'crypto'
-import { type Readable, type Writable } from 'stream'
-
-import normalizePath from './_normalizePath'
-import { createChecksumStream, validChecksumOfReadStream } from './checksum'
-
-const { dirname } = path.posix
-
-type Data = Buffer | Readable | string
-type FileDescriptor = {| fd: mixed, path: string |}
-type LaxReadable = Readable & Object
-type LaxWritable = Writable & Object
-type RemoteInfo = { used?: number, size?: number }
-
-type File = FileDescriptor | string
-
-const checksumFile = file => file + '.checksum'
-const computeRate = (hrtime: number[], size: number) => {
-  const seconds = hrtime[0] + hrtime[1] / 1e9
-  return size / seconds
-}
-
-const DEFAULT_TIMEOUT = 6e5 // 10 min
-const DEFAULT_MAX_PARALLEL_OPERATIONS = 10
-
-const ignoreEnoent = error => {
-  if (error == null || error.code !== 'ENOENT') {
-    throw error
-  }
-}
-
-class PrefixWrapper {
-  constructor(handler, prefix) {
-    this._prefix = prefix
-    this._handler = handler
-  }
-
-  get type() {
-    return this._handler.type
-  }
-
-  // necessary to remove the prefix from the path with `prependDir` option
-  async list(dir, opts) {
-    const entries = await this._handler.list(this._resolve(dir), opts)
-    if (opts != null && opts.prependDir) {
-      const n = this._prefix.length
-      entries.forEach((entry, i, entries) => {
-        entries[i] = entry.slice(n)
-      })
-    }
-    return entries
-  }
-
-  rename(oldPath, newPath) {
-    return this._handler.rename(this._resolve(oldPath), this._resolve(newPath))
-  }
-
-  _resolve(path) {
-    return this._prefix + normalizePath(path)
-  }
-}
-
-export default class RemoteHandlerAbstract {
-  _remote: Object
-  _timeout: number
-
-  constructor(remote: any, options: Object = {}) {
-    if (remote.url === 'test://') {
-      this._remote = remote
-    } else {
-      this._remote = { ...remote, ...parse(remote.url) }
-      if (this._remote.type !== this.type) {
-        throw new Error('Incorrect remote type')
-      }
-    }
-    ;({ timeout: this._timeout = DEFAULT_TIMEOUT } = options)
-
-    const sharedLimit = limit(
-      options.maxParallelOperations ?? DEFAULT_MAX_PARALLEL_OPERATIONS
-    )
-    this.closeFile = sharedLimit(this.closeFile)
-    this.getInfo = sharedLimit(this.getInfo)
-    this.getSize = sharedLimit(this.getSize)
-    this.list = sharedLimit(this.list)
-    this.mkdir = sharedLimit(this.mkdir)
-    this.openFile = sharedLimit(this.openFile)
-    this.outputFile = sharedLimit(this.outputFile)
-    this.read = sharedLimit(this.read)
-    this.readFile = sharedLimit(this.readFile)
-    this.rename = sharedLimit(this.rename)
-    this.rmdir = sharedLimit(this.rmdir)
-    this.truncate = sharedLimit(this.truncate)
-    this.unlink = sharedLimit(this.unlink)
-    this.write = sharedLimit(this.write)
-    this.writeFile = sharedLimit(this.writeFile)
-  }
-
-  // Public members
-
-  get type(): string {
-    throw new Error('Not implemented')
-  }
-
-  addPrefix(prefix: string) {
-    prefix = normalizePath(prefix)
-    return prefix === '/' ? this : new PrefixWrapper(this, prefix)
-  }
-
-  async closeFile(fd: FileDescriptor): Promise<void> {
-    await this.__closeFile(fd)
-  }
-
-  async createOutputStream(
-    file: File,
-    { checksum = false, ...options }: Object = {}
-  ): Promise<LaxWritable> {
-    if (typeof file === 'string') {
-      file = normalizePath(file)
-    }
-    const path = typeof file === 'string' ? file : file.path
-    const streamP = timeout.call(
-      this._createOutputStream(file, {
-        flags: 'wx',
-        ...options,
-      }),
-      this._timeout
-    )
-
-    if (!checksum) {
-      return streamP
-    }
-
-    const checksumStream = createChecksumStream()
-    const forwardError = error => {
-      checksumStream.emit('error', error)
-    }
-
-    const stream = await streamP
-    stream.on('error', forwardError)
-    checksumStream.pipe(stream)
-
-    // $FlowFixMe
-    checksumStream.checksumWritten = checksumStream.checksum
-      .then(value =>
-        this._outputFile(checksumFile(path), value, { flags: 'wx' })
-      )
-      .catch(forwardError)
-
-    return checksumStream
-  }
-
-  createReadStream(
-    file: File,
-    { checksum = false, ignoreMissingChecksum = false, ...options }: Object = {}
-  ): Promise<LaxReadable> {
-    if (typeof file === 'string') {
-      file = normalizePath(file)
-    }
-    const path = typeof file === 'string' ? file : file.path
-    const streamP = timeout
-      .call(this._createReadStream(file, options), this._timeout)
-      .then(stream => {
-        // detect early errors
-        let promise = fromEvent(stream, 'readable')
-
-        // try to add the length prop if missing and not a range stream
-        if (
-          stream.length === undefined &&
-          options.end === undefined &&
-          options.start === undefined
-        ) {
-          promise = Promise.all([
-            promise,
-            ignoreErrors.call(
-              this._getSize(file).then(size => {
-                stream.length = size
-              })
-            ),
-          ])
-        }
-
-        return promise.then(() => stream)
-      })
-
-    if (!checksum) {
-      return streamP
-    }
-
-    // avoid a unhandled rejection warning
-    ignoreErrors.call(streamP)
-
-    return this._readFile(checksumFile(path), { flags: 'r' }).then(
-      checksum =>
-        streamP.then(stream => {
-          const { length } = stream
-          stream = (validChecksumOfReadStream(
-            stream,
-            String(checksum).trim()
-          ): LaxReadable)
-          stream.length = length
-
-          return stream
-        }),
-      error => {
-        if (ignoreMissingChecksum && error && error.code === 'ENOENT') {
-          return streamP
-        }
-        throw error
-      }
-    )
-  }
-
-  createWriteStream(
-    file: File,
-    options: { end?: number, flags?: string, start?: number } = {}
-  ): Promise<LaxWritable> {
-    return timeout.call(
-      this._createWriteStream(
-        typeof file === 'string' ? normalizePath(file) : file,
-        {
-          flags: 'wx',
-          ...options,
-        }
-      )
-    )
-  }
-
-  // Free the resources possibly dedicated to put the remote at work, when it
-  // is no more needed
-  //
-  // FIXME: Some handlers are implemented based on system-wide mecanisms (such
-  // as mount), forgetting them might breaking other processes using the same
-  // remote.
-  @synchronized()
-  async forget(): Promise<void> {
-    await this._forget()
-  }
-
-  async getInfo(): Promise<RemoteInfo> {
-    return timeout.call(this._getInfo(), this._timeout)
-  }
-
-  async getSize(file: File): Promise<number> {
-    return timeout.call(
-      this._getSize(typeof file === 'string' ? normalizePath(file) : file),
-      this._timeout
-    )
-  }
-
-  async list(
-    dir: string,
-    {
-      filter,
-      prependDir = false,
-    }: { filter?: (name: string) => boolean, prependDir?: boolean } = {}
-  ): Promise<string[]> {
-    const virtualDir = normalizePath(dir)
-    dir = normalizePath(dir)
-
-    let entries = await timeout.call(this._list(dir), this._timeout)
-    if (filter !== undefined) {
-      entries = entries.filter(filter)
-    }
-
-    if (prependDir) {
-      entries.forEach((entry, i) => {
-        entries[i] = virtualDir + '/' + entry
-      })
-    }
-
-    return entries
-  }
-
-  async mkdir(dir: string): Promise<void> {
-    await this.__mkdir(normalizePath(dir))
-  }
-
-  async mktree(dir: string): Promise<void> {
-    await this._mktree(normalizePath(dir))
-  }
-
-  openFile(path: string, flags: string): Promise<FileDescriptor> {
-    return this.__openFile(path, flags)
-  }
-
-  async outputFile(
-    file: string,
-    data: Data,
-    { flags = 'wx' }: { flags?: string } = {}
-  ): Promise<void> {
-    await this._outputFile(normalizePath(file), data, { flags })
-  }
-
-  async read(
-    file: File,
-    buffer: Buffer,
-    position?: number
-  ): Promise<{| bytesRead: number, buffer: Buffer |}> {
-    return this._read(
-      typeof file === 'string' ? normalizePath(file) : file,
-      buffer,
-      position
-    )
-  }
-
-  async readFile(
-    file: string,
-    { flags = 'r' }: { flags?: string } = {}
-  ): Promise<Buffer> {
-    return this._readFile(normalizePath(file), { flags })
-  }
-
-  async refreshChecksum(path: string): Promise<void> {
-    path = normalizePath(path)
-
-    const stream = (await this._createReadStream(path, { flags: 'r' })).pipe(
-      createChecksumStream()
-    )
-    stream.resume() // start reading the whole file
-    await this._outputFile(checksumFile(path), await stream.checksum, {
-      flags: 'wx',
-    })
-  }
-
-  async rename(
-    oldPath: string,
-    newPath: string,
-    { checksum = false }: Object = {}
-  ) {
-    oldPath = normalizePath(oldPath)
-    newPath = normalizePath(newPath)
-
-    let p = timeout.call(this._rename(oldPath, newPath), this._timeout)
-    if (checksum) {
-      p = Promise.all([
-        p,
-        this._rename(checksumFile(oldPath), checksumFile(newPath)),
-      ])
-    }
-    return p
-  }
-
-  async rmdir(dir: string): Promise<void> {
-    await timeout.call(
-      this._rmdir(normalizePath(dir)).catch(ignoreEnoent),
-      this._timeout
-    )
-  }
-
-  async rmtree(dir: string): Promise<void> {
-    await this._rmtree(normalizePath(dir))
-  }
-
-  // Asks the handler to sync the state of the effective remote with its'
-  // metadata
-  //
-  // This method MUST ALWAYS be called before using the handler.
-  @synchronized()
-  async sync(): Promise<void> {
-    await this._sync()
-  }
-
-  async test(): Promise<Object> {
-    const SIZE = 1024 * 1024 * 10
-    const testFileName = normalizePath(`${Date.now()}.test`)
-    const data = await fromCallback(randomBytes, SIZE)
-    let step = 'write'
-    try {
-      const writeStart = process.hrtime()
-      await this._outputFile(testFileName, data, { flags: 'wx' })
-      const writeDuration = process.hrtime(writeStart)
-
-      step = 'read'
-      const readStart = process.hrtime()
-      const read = await this._readFile(testFileName, { flags: 'r' })
-      const readDuration = process.hrtime(readStart)
-
-      if (!data.equals(read)) {
-        throw new Error('output and input did not match')
-      }
-      return {
-        success: true,
-        writeRate: computeRate(writeDuration, SIZE),
-        readRate: computeRate(readDuration, SIZE),
-      }
-    } catch (error) {
-      return {
-        success: false,
-        step,
-        file: testFileName,
-        error: error.message || String(error),
-      }
-    } finally {
-      ignoreErrors.call(this._unlink(testFileName))
-    }
-  }
-
-  async truncate(file: string, len: number): Promise<void> {
-    await this._truncate(file, len)
-  }
-
-  async unlink(file: string, { checksum = true }: Object = {}): Promise<void> {
-    file = normalizePath(file)
-
-    if (checksum) {
-      ignoreErrors.call(this._unlink(checksumFile(file)))
-    }
-
-    await this._unlink(file).catch(ignoreEnoent)
-  }
-
-  async write(
-    file: File,
-    buffer: Buffer,
-    position: number
-  ): Promise<{| bytesWritten: number, buffer: Buffer |}> {
-    await this._write(
-      typeof file === 'string' ? normalizePath(file) : file,
-      buffer,
-      position
-    )
-  }
-
-  async writeFile(
-    file: string,
-    data: Data,
-    { flags = 'wx' }: { flags?: string } = {}
-  ): Promise<void> {
-    await this._writeFile(normalizePath(file), data, { flags })
-  }
-
-  // Methods that can be called by private methods to avoid parallel limit on public methods
-
-  async __closeFile(fd: FileDescriptor): Promise<void> {
-    await timeout.call(this._closeFile(fd.fd), this._timeout)
-  }
-
-  async __mkdir(dir: string): Promise<void> {
-    try {
-      await this._mkdir(dir)
-    } catch (error) {
-      if (error == null || error.code !== 'EEXIST') {
-        throw error
-      }
-
-      // this operation will throw if it's not already a directory
-      await this._list(dir)
-    }
-  }
-
-  async __openFile(path: string, flags: string): Promise<FileDescriptor> {
-    path = normalizePath(path)
-
-    return {
-      fd: await timeout.call(this._openFile(path, flags), this._timeout),
-      path,
-    }
-  }
-
-  // Methods that can be implemented by inheriting classes
-
-  async _closeFile(fd: mixed): Promise<void> {
-    throw new Error('Not implemented')
-  }
-
-  async _createOutputStream(file: File, options: Object): Promise<LaxWritable> {
-    try {
-      return await this._createWriteStream(file, options)
-    } catch (error) {
-      if (typeof file !== 'string' || error.code !== 'ENOENT') {
-        throw error
-      }
-    }
-
-    await this._mktree(dirname(file))
-    return this._createOutputStream(file, options)
-  }
-
-  async _createReadStream(file: File, options?: Object): Promise<LaxReadable> {
-    throw new Error('Not implemented')
-  }
-
-  async _createWriteStream(file: File, options: Object): Promise<LaxWritable> {
-    throw new Error('Not implemented')
-  }
-
-  // called to finalize the remote
-  async _forget(): Promise<void> {}
-
-  async _getInfo(): Promise<Object> {
-    return {}
-  }
-
-  async _getSize(file: File): Promise<number> {
-    throw new Error('Not implemented')
-  }
-
-  async _list(dir: string): Promise<string[]> {
-    throw new Error('Not implemented')
-  }
-
-  async _mkdir(dir: string): Promise<void> {
-    throw new Error('Not implemented')
-  }
-
-  async _mktree(dir: string): Promise<void> {
-    try {
-      return await this.__mkdir(dir)
-    } catch (error) {
-      if (error.code !== 'ENOENT') {
-        throw error
-      }
-    }
-
-    await this._mktree(dirname(dir))
-    return this._mktree(dir)
-  }
-
-  async _openFile(path: string, flags: string): Promise<mixed> {
-    throw new Error('Not implemented')
-  }
-
-  async _outputFile(
-    file: string,
-    data: Data,
-    options: { flags?: string }
-  ): Promise<void> {
-    try {
-      return await this._writeFile(file, data, options)
-    } catch (error) {
-      if (error.code !== 'ENOENT') {
-        throw error
-      }
-    }
-
-    await this._mktree(dirname(file))
-    return this._outputFile(file, data, options)
-  }
-
-  _read(
-    file: File,
-    buffer: Buffer,
-    position?: number
-  ): Promise<{| bytesRead: number, buffer: Buffer |}> {
-    throw new Error('Not implemented')
-  }
-
-  _readFile(file: string, options?: Object): Promise<Buffer> {
-    return this._createReadStream(file, options).then(getStream.buffer)
-  }
-
-  async _rename(oldPath: string, newPath: string) {
-    throw new Error('Not implemented')
-  }
-
-  async _rmdir(dir: string) {
-    throw new Error('Not implemented')
-  }
-
-  async _rmtree(dir: string) {
-    try {
-      return await this._rmdir(dir)
-    } catch (error) {
-      if (error.code !== 'ENOTEMPTY') {
-        throw error
-      }
-    }
-
-    const files = await this._list(dir)
-    await asyncMap(files, file =>
-      this._unlink(`${dir}/${file}`).catch(error => {
-        if (error.code === 'EISDIR') {
-          return this._rmtree(`${dir}/${file}`)
-        }
-        throw error
-      })
-    )
-    return this._rmtree(dir)
-  }
-
-  // called to initialize the remote
-  async _sync(): Promise<void> {}
-
-  async _unlink(file: string): Promise<void> {
-    throw new Error('Not implemented')
-  }
-
-  async _write(file: File, buffer: Buffer, position: number): Promise<void> {
-    const isPath = typeof file === 'string'
-    if (isPath) {
-      file = await this.__openFile(file, 'r+')
-    }
-    try {
-      return await this._writeFd(file, buffer, position)
-    } finally {
-      if (isPath) {
-        await this.__closeFile(file)
-      }
-    }
-  }
-
-  async _writeFd(
-    fd: FileDescriptor,
-    buffer: Buffer,
-    position: number
-  ): Promise<void> {
-    throw new Error('Not implemented')
-  }
-
-  async _writeFile(
-    file: string,
-    data: Data,
-    options: { flags?: string }
-  ): Promise<void> {
-    throw new Error('Not implemented')
-  }
-}
-
-function createPrefixWrapperMethods() {
-  const pPw = PrefixWrapper.prototype
-  const pRha = RemoteHandlerAbstract.prototype
-
-  const {
-    defineProperty,
-    getOwnPropertyDescriptor,
-    prototype: { hasOwnProperty },
-  } = Object
-
-  Object.getOwnPropertyNames(pRha).forEach(name => {
-    let descriptor, value
-    if (
-      hasOwnProperty.call(pPw, name) ||
-      name[0] === '_' ||
-      typeof (value = (descriptor = getOwnPropertyDescriptor(pRha, name))
-        .value) !== 'function'
-    ) {
-      return
-    }
-
-    descriptor.value = function () {
-      let path
-      if (arguments.length !== 0 && typeof (path = arguments[0]) === 'string') {
-        arguments[0] = this._resolve(path)
-      }
-      return value.apply(this._handler, arguments)
-    }
-
-    defineProperty(pPw, name, descriptor)
-  })
-}
-createPrefixWrapperMethods()

@xen-orchestra/fs/src/abstract.spec.js

@@ -1,127 +0,0 @@
-/* eslint-env jest */
-
-import { TimeoutError } from 'promise-toolbox'
-
-import AbstractHandler from './abstract'
-
-const TIMEOUT = 10e3
-
-class TestHandler extends AbstractHandler {
-  constructor(impl) {
-    super({ url: 'test://' }, { timeout: TIMEOUT })
-
-    Object.keys(impl).forEach(method => {
-      this[`_${method}`] = impl[method]
-    })
-  }
-}
-
-jest.useFakeTimers()
-
-describe('closeFile()', () => {
-  it(`throws in case of timeout`, async () => {
-    const testHandler = new TestHandler({
-      closeFile: () => new Promise(() => {}),
-    })
-
-    const promise = testHandler.closeFile({ fd: undefined, path: '' })
-    jest.advanceTimersByTime(TIMEOUT)
-    await expect(promise).rejects.toThrowError(TimeoutError)
-  })
-})
-
-describe('createOutputStream()', () => {
-  it(`throws in case of timeout`, async () => {
-    const testHandler = new TestHandler({
-      createOutputStream: () => new Promise(() => {}),
-    })
-
-    const promise = testHandler.createOutputStream('File')
-    jest.advanceTimersByTime(TIMEOUT)
-    await expect(promise).rejects.toThrowError(TimeoutError)
-  })
-})
-
-describe('createReadStream()', () => {
-  it(`throws in case of timeout`, async () => {
-    const testHandler = new TestHandler({
-      createReadStream: () => new Promise(() => {}),
-    })
-
-    const promise = testHandler.createReadStream('file')
-    jest.advanceTimersByTime(TIMEOUT)
-    await expect(promise).rejects.toThrowError(TimeoutError)
-  })
-})
-
-describe('getInfo()', () => {
-  it('throws in case of timeout', async () => {
-    const testHandler = new TestHandler({
-      getInfo: () => new Promise(() => {}),
-    })
-
-    const promise = testHandler.getInfo()
-    jest.advanceTimersByTime(TIMEOUT)
-    await expect(promise).rejects.toThrowError(TimeoutError)
-  })
-})
-
-describe('getSize()', () => {
-  it(`throws in case of timeout`, async () => {
-    const testHandler = new TestHandler({
-      getSize: () => new Promise(() => {}),
-    })
-
-    const promise = testHandler.getSize('')
-    jest.advanceTimersByTime(TIMEOUT)
-    await expect(promise).rejects.toThrowError(TimeoutError)
-  })
-})
-
-describe('list()', () => {
-  it(`throws in case of timeout`, async () => {
-    const testHandler = new TestHandler({
-      list: () => new Promise(() => {}),
-    })
-
-    const promise = testHandler.list('.')
-    jest.advanceTimersByTime(TIMEOUT)
-    await expect(promise).rejects.toThrowError(TimeoutError)
-  })
-})
-
-describe('openFile()', () => {
-  it(`throws in case of timeout`, async () => {
-    const testHandler = new TestHandler({
-      openFile: () => new Promise(() => {}),
-    })
-
-    const promise = testHandler.openFile('path')
-    jest.advanceTimersByTime(TIMEOUT)
-    await expect(promise).rejects.toThrowError(TimeoutError)
-  })
-})
-
-describe('rename()', () => {
-  it(`throws in case of timeout`, async () => {
-    const testHandler = new TestHandler({
-      rename: () => new Promise(() => {}),
-    })
-
-    const promise = testHandler.rename('oldPath', 'newPath')
-    jest.advanceTimersByTime(TIMEOUT)
-    await expect(promise).rejects.toThrowError(TimeoutError)
-  })
-})
-
-describe('rmdir()', () => {
-  it(`throws in case of timeout`, async () => {
-    const testHandler = new TestHandler({
-      rmdir: () => new Promise(() => {}),
-    })
-
-    const promise = testHandler.rmdir('dir')
-    jest.advanceTimersByTime(TIMEOUT)
-    await expect(promise).rejects.toThrowError(TimeoutError)
-  })
-})

@xen-orchestra/fs/src/checksum.js

@@ -1,99 +0,0 @@
-// @flow
-
-import through2 from 'through2'
-import { createHash } from 'crypto'
-import { defer, fromEvent } from 'promise-toolbox'
-import { invert } from 'lodash'
-import { type Readable, type Transform } from 'stream'
-
-// Format: $<algorithm>$<salt>$<encrypted>
-//
-// http://man7.org/linux/man-pages/man3/crypt.3.html#NOTES
-const ALGORITHM_TO_ID = {
-  md5: '1',
-  sha256: '5',
-  sha512: '6',
-}
-
-const ID_TO_ALGORITHM = invert(ALGORITHM_TO_ID)
-
-// Create a through stream which computes the checksum of all data going
-// through.
-//
-// The `checksum` attribute is a promise which resolves at the end of the stream
-// with a string representation of the checksum.
-//
-//    const source = ...
-//    const checksumStream = source.pipe(createChecksumStream())
-//    checksumStream.resume() // make the data flow without an output
-//    console.log(await checksumStream.checksum)
-export const createChecksumStream = (
-  algorithm: string = 'md5'
-): Transform & { checksum: Promise<string> } => {
-  const algorithmId = ALGORITHM_TO_ID[algorithm]
-
-  if (!algorithmId) {
-    throw new Error(`unknown algorithm: ${algorithm}`)
-  }
-
-  const hash = createHash(algorithm)
-  const { promise, resolve, reject } = defer()
-
-  const stream = through2(
-    (chunk, enc, callback) => {
-      hash.update(chunk)
-      callback(null, chunk)
-    },
-    callback => {
-      resolve(`$${algorithmId}$$${hash.digest('hex')}`)
-      callback()
-    }
-  ).once('error', reject)
-  stream.checksum = promise
-  return stream
-}
-
-// Check if the checksum of a readable stream is equals to an expected checksum.
-// The given stream is wrapped in a stream which emits an error event
-// if the computed checksum is not equals to the expected checksum.
-export const validChecksumOfReadStream = (
-  stream: Readable,
-  expectedChecksum: string
-): Readable & { checksumVerified: Promise<void> } => {
-  const algorithmId = expectedChecksum.slice(
-    1,
-    expectedChecksum.indexOf('$', 1)
-  )
-
-  if (!algorithmId) {
-    throw new Error(`unknown algorithm: ${algorithmId}`)
-  }
-
-  const hash = createHash(ID_TO_ALGORITHM[algorithmId])
-
-  const wrapper: any = stream.pipe(
-    through2(
-      { highWaterMark: 0 },
-      (chunk, enc, callback) => {
-        hash.update(chunk)
-        callback(null, chunk)
-      },
-      callback => {
-        const checksum = `$${algorithmId}$$${hash.digest('hex')}`
-
-        callback(
-          checksum !== expectedChecksum
-            ? new Error(
-                `Bad checksum (${checksum}), expected: ${expectedChecksum}`
-              )
-            : null
-        )
-      }
-    )
-  )
-
-  stream.on('error', error => wrapper.emit('error', error))
-  wrapper.checksumVerified = fromEvent(wrapper, 'end')
-
-  return wrapper
-}