feat(cron): 0.1.0

Instead of failing when an id refers to a no missing item, simply remove it from the index.

.eslintrc.js

@@ -0,0 +1,15 @@
+module.exports = {
+  'extends': [
+    'standard',
+  ],
+  'parser': 'babel-eslint',
+  'rules': {
+    'comma-dangle': ['error', 'always-multiline'],
+    'no-var': 'error',
+    'node/no-extraneous-import': 'error',
+    'node/no-extraneous-require': 'error',
+    'node/no-missing-import': 'error',
+    'node/no-missing-require': 'error',
+    'prefer-const': 'error',
+  },
+}

.flowconfig

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

.gitignore

@@ -1,10 +1,18 @@
+/coverage/
 /node_modules/
 /lerna-debug.log
 /lerna-debug.log.*
 
+/@xen-orchestra/*/dist/
+/@xen-orchestra/*/node_modules/
 /packages/*/dist/
 /packages/*/node_modules/
 
+/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
+
 npm-debug.log
 npm-debug.log.*
 pnpm-debug.log

.travis.yml

@@ -1,8 +1,16 @@
 language: node_js
 node_js:
   - stable
+  - 8
   - 6
 
 # Use containers.
 # http://docs.travis-ci.com/user/workers/container-based-infrastructure/
 sudo: false
+
+before_install:
+  - curl -o- -L https://yarnpkg.com/install.sh | bash
+  - export PATH="$HOME/.yarn/bin:$PATH"
+
+cache:
+  yarn: true

@xen-orchestra/cron/.babelrc.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const NODE_ENV = process.env.NODE_ENV || 'development'
+const __PROD__ = NODE_ENV === 'production'
+const __TEST__ = NODE_ENV === 'test'
+
+const pkg = require('./package')
+
+let nodeCompat = (pkg.engines || {}).node
+if (nodeCompat === undefined) {
+  nodeCompat = '6'
+} else {
+  const trimChars = '^=>~'
+  while (trimChars.includes(nodeCompat[0])) {
+    nodeCompat = nodeCompat.slice(1)
+  }
+}
+
+module.exports = {
+  comments: !__PROD__,
+  ignore: __TEST__ ? undefined : [/\.spec\.js$/],
+  plugins: ['lodash'],
+  presets: [
+    [
+      '@babel/env',
+      {
+        debug: !__TEST__,
+        loose: true,
+        shippedProposals: true,
+        targets: __PROD__
+          ? {
+            browsers: '>2%',
+            node: nodeCompat,
+          }
+          : { node: 'current' },
+        useBuiltIns: '@babel/polyfill' in (pkg.dependencies || {}) && 'usage',
+      },
+    ],
+    '@babel/flow',
+  ],
+}

@xen-orchestra/cron/.npmignore

@@ -0,0 +1,24 @@
+/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

@@ -0,0 +1,95 @@
+# @xen-orchestra/cron [![Build Status](https://travis-ci.org/vatesfr/xen-orchestra.png?branch=master)](https://travis-ci.org/vatesfr/xen-orchestra)
+
+> 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
+
+```js
+import { createSchedule } from '@xen-orchestra/cron'
+
+const schedule = createSchedule('0 0 * * sun', 'America/New_York')
+
+schedule.next(2)
+// [ 2018-02-11T05:00:00.000Z, 2018-02-18T05:00:00.000Z ]
+
+const job = schedule.createJob(() => {
+  console.log(new Date())
+})
+
+job.start()
+
+job.stop()
+```
+
+### 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.
+
+## Development
+
+```
+# Install dependencies
+> yarn
+
+# Run the tests
+> yarn test
+
+# Continuously compile
+> yarn dev
+
+# Continuously run the tests
+> yarn dev-test
+
+# Build for production (automatically called by npm install)
+> yarn build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](https://github.com/vatesfr/xo-web/issues)
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+ISC © [Vates SAS](https://vates.fr)

@xen-orchestra/cron/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@xen-orchestra/cron",
+  "version": "0.1.0",
+  "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/packages/@xen-orchestra/cron",
+  "bugs": "https://github.com/vatesfr/xo-web/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@isonoe.net"
+  },
+  "preferGlobal": false,
+  "main": "dist/",
+  "bin": {},
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=6"
+  },
+  "dependencies": {
+    "lodash": "^4.17.4",
+    "luxon": "^0.4.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.0.0-beta.39",
+    "@babel/core": "7.0.0-beta.39",
+    "@babel/preset-env": "7.0.0-beta.39",
+    "@babel/preset-flow": "7.0.0-beta.39",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.2"
+  },
+  "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"
+  }
+}

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

@@ -0,0 +1,49 @@
+import { DateTime } from 'luxon'
+
+import next from './next'
+import parse from './parse'
+
+class Job {
+  constructor (schedule, fn) {
+    const wrapper = scheduledRun => {
+      if (scheduledRun) {
+        fn()
+      }
+      this._timeout = setTimeout(wrapper, schedule.next() - Date.now(), true)
+    }
+    this._fn = wrapper
+    this._timeout = undefined
+  }
+
+  start () {
+    this.stop()
+    this._fn()
+  }
+
+  stop () {
+    clearTimeout(this._timeout)
+  }
+}
+
+class Schedule {
+  constructor (pattern, zone = 'utc') {
+    this._schedule = parse(pattern)
+    this._dateTimeOpts = { zone }
+  }
+
+  createJob (fn) {
+    return new Job(this, fn)
+  }
+
+  next (n) {
+    const dates = new Array(n)
+    const schedule = this._schedule
+    let date = DateTime.fromObject(this._dateTimeOpts)
+    for (let i = 0; i < n; ++i) {
+      dates[i] = (date = next(schedule, date)).toJSDate()
+    }
+    return dates
+  }
+}
+
+export const createSchedule = (...args) => new Schedule(...args)

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

@@ -0,0 +1,90 @@
+import sortedIndex from 'lodash/sortedIndex'
+import { DateTime } from 'luxon'
+
+const NEXT_MAPPING = {
+  month: { year: 1 },
+  day: { month: 1 },
+  weekday: { 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 date
+  }
+
+  const curr = date.get(unit)
+  const next = values[sortedIndex(values, curr) % values.length]
+  if (curr === next) {
+    return date
+  }
+
+  const newDate = date.set({ [unit]: next })
+  return newDate > date ? newDate : newDate.plus(NEXT_MAPPING[unit])
+}
+
+// returns the next run, after the passed date
+export default (schedule, fromDate) => {
+  let date = fromDate
+    .set({
+      second: 0,
+      millisecond: 0,
+    })
+    .plus({ minute: 1 })
+
+  const { minute, hour, dayOfMonth, month, dayOfWeek } = schedule
+  date = setFirstAvailable(date, 'minute', minute)
+
+  let tmp
+
+  tmp = setFirstAvailable(date, 'hour', hour)
+  if (tmp !== date) {
+    date = tmp.set({
+      minute: getFirst(minute),
+    })
+  }
+
+  let loop
+  let i = 0
+  do {
+    loop = false
+
+    tmp = setFirstAvailable(date, 'month', month)
+    if (tmp !== date) {
+      date = tmp.set({
+        day: 1,
+        hour: getFirst(hour),
+        minute: getFirst(minute),
+      })
+    }
+
+    if (dayOfMonth === undefined) {
+      if (dayOfWeek !== undefined) {
+        tmp = setFirstAvailable(date, 'weekday', dayOfWeek)
+      }
+    } else if (dayOfWeek === undefined) {
+      tmp = setFirstAvailable(date, 'day', dayOfMonth)
+    } else {
+      tmp = DateTime.min(
+        setFirstAvailable(date, 'day', dayOfMonth),
+        setFirstAvailable(date, 'weekday', dayOfWeek)
+      )
+    }
+    if (tmp !== date) {
+      loop = tmp.month !== date.month
+      date = tmp.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

@@ -0,0 +1,46 @@
+/* eslint-env jest */
+
+import mapValues from 'lodash/mapValues'
+import { DateTime } from 'luxon'
+
+import next from './next'
+import parse from './parse'
+
+const N = (pattern, fromDate = '2018-04-09T06:25') =>
+  next(parse(pattern), DateTime.fromISO(fromDate, { zone: 'utc' })).toISO({
+    includeOffset: false,
+    suppressMilliseconds: true,
+    suppressSeconds: true,
+  })
+
+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'
+    )
+  })
+})

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

@@ -0,0 +1,198 @@
+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: [1, 12],
+
+      // this function is applied to numeric entries (not steps)
+      //
+      // currently parse month 0-11
+      post: value => value + 1,
+    },
+    {
+      aliases: 'mon tue wen thu fri sat sun'.split(' '),
+      name: 'dayOfWeek',
+      post: value => (value === 0 ? 7 : value),
+      range: [1, 7],
+    },
+  ],
+  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

@@ -0,0 +1,51 @@
+/* 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: [1, 3, 5, 8, 11],
+    })
+  })
+
+  it('correctly parse months', () => {
+    expect(parse('* * * 0,11 *')).toEqual({
+      month: [1, 12],
+    })
+    expect(parse('* * * jan,dec *')).toEqual({
+      month: [1, 12],
+    })
+  })
+
+  it('correctly parse days', () => {
+    expect(parse('* * * * mon,sun')).toEqual({
+      dayOfWeek: [1, 7],
+    })
+  })
+
+  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: [7],
+    })
+    expect(parse('* * * * 7')).toEqual({
+      dayOfWeek: [7],
+    })
+  })
+})

README.md

@@ -1,5 +1,7 @@
 Almost all dev for Xen Orchestra is happening in this repository.
 
-Because transition is still underway, [xo-web](https://github.com/vatesfr/xo-web) and [xo-server](https://github.com/vatesfr/xo-server) are still developped in their own repositories.
+Because transition is still underway,
+[xo-web](https://github.com/vatesfr/xo-web) is still developed in
+their own repositories.
 
 For now, all issues are still to be reported in [xo-web's tracker](https://github.com/vatesfr/xo-web/issues).

lerna.json

@@ -1,7 +0,0 @@
-{
-  "lerna": "2.0.0-beta.38-40-g203f7eb",
-  "packages": [
-    "packages/*"
-  ],
-  "version": "0.0.0"
-}

package.json

@@ -1,12 +1,64 @@
 {
   "devDependencies": {
-    "husky": "^0.13.3",
-    "lerna": "^2.0.0-beta.38-40-g203f7eb",
-    "promise-toolbox": "^0.8.2"
+    "babel-7-jest": "^21.3.2",
+    "babel-eslint": "^8.1.2",
+    "eslint": "^4.14.0",
+    "eslint-config-standard": "^11.0.0-beta.0",
+    "eslint-plugin-import": "^2.8.0",
+    "eslint-plugin-node": "^5.2.1",
+    "eslint-plugin-promise": "^3.6.0",
+    "eslint-plugin-standard": "^3.0.1",
+    "exec-promise": "^0.7.0",
+    "flow-bin": "^0.64.0",
+    "husky": "^0.14.3",
+    "jest": "^22.0.4",
+    "lint-staged": "^6.0.0",
+    "lodash": "^4.17.4",
+    "promise-toolbox": "^0.9.5",
+    "sorted-object": "^2.0.1"
   },
+  "engines": {
+    "yarn": "^1.2.1"
+  },
+  "jest": {
+    "collectCoverage": true,
+    "testEnvironment": "node",
+    "testPathIgnorePatterns": [
+      "/dist/",
+      "/xo-vmdk-to-vhd/"
+    ],
+    "testRegex": "\\.spec\\.js$",
+    "transform": {
+      "/@xen-orchestra/cron/.+\\.jsx?$": "babel-7-jest",
+      "/packages/complex-matcher/.+\\.jsx?$": "babel-7-jest",
+      "/packages/value-matcher/.+\\.jsx?$": "babel-7-jest",
+      "/packages/xo-cli/.+\\.jsx?$": "babel-7-jest",
+      "\\.jsx?$": "babel-jest"
+    }
+  },
+  "lint-staged": {
+    "*.js": [
+      "lint-staged-stash",
+      "eslint --fix",
+      "jest --findRelatedTests --passWithNoTests",
+      "lint-staged-unstash"
+    ]
+  },
+  "private": true,
   "scripts": {
-    "commitmsg": "yarn test",
-    "install": "lerna exec --concurrency 1 -- yarn",
-    "test": "lerna run test"
-  }
+    "build": "scripts/run-script --parallel build",
+    "clean": "scripts/run-script --parallel clean",
+    "dev-test": "jest --bail --watch",
+    "lint-staged-stash": "touch .lint-staged && git stash save --include-untracked --keep-index && true",
+    "lint-staged-unstash": "git stash pop && rm -f .lint-staged && true",
+    "posttest": "scripts/run-script test",
+    "precommit": "lint-staged",
+    "prepare": "scripts/run-script prepare",
+    "pretest": "eslint --ignore-path .gitignore .",
+    "test": "jest && flow status"
+  },
+  "workspaces": [
+    "@xen-orchestra/*",
+    "packages/*"
+  ]
 }

packages/complex-matcher/.babelrc.js

@@ -0,0 +1,28 @@
+const dependencies = require('./package').dependencies || {}
+
+const NODE_ENV = process.env.NODE_ENV || 'development'
+const __PROD__ = NODE_ENV === 'production'
+const __TEST__ = NODE_ENV === 'test'
+
+module.exports = {
+  comments: !__PROD__,
+  ignore: __TEST__ ? undefined : [/\.spec\.js$/],
+  plugins: ['lodash'],
+  presets: [
+    [
+      '@babel/env',
+      {
+        debug: !__TEST__,
+        loose: true,
+        shippedProposals: true,
+        targets: __PROD__
+          ? {
+            browsers: '>2%',
+            node: '4',
+          }
+          : { node: 'current' },
+        useBuiltIns: '@babel/polyfill' in dependencies && 'usage',
+      },
+    ],
+  ],
+}

packages/complex-matcher/.npmignore

@@ -0,0 +1,24 @@
+/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__/

packages/complex-matcher/README.md

@@ -0,0 +1,66 @@
+# complex-matcher [![Build Status](https://travis-ci.org/vatesfr/xen-orchestra.png?branch=master)](https://travis-ci.org/vatesfr/xen-orchestra)
+
+> ${pkg.description}
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/complex-matcher):
+
+```
+> npm install --save complex-matcher
+```
+
+## Usage
+
+```js
+import * as CM from 'complex-matcher'
+
+const characters = [
+  { name: 'Catwoman', costumeColor: 'black' },
+  { name: 'Superman', costumeColor: 'blue', hasCape: true },
+  { name: 'Wonder Woman', costumeColor: 'blue' },
+]
+
+const predicate = CM.parse('costumeColor:blue hasCape?').createPredicate()
+
+characters.filter(predicate)
+// [
+//   { name: 'Superman', costumeColor: 'blue', hasCape: true },
+// ]
+
+new CM.String('foo').createPredicate()
+```
+
+## Development
+
+```
+# Install dependencies
+> yarn
+
+# Run the tests
+> yarn test
+
+# Continuously compile
+> yarn dev
+
+# Continuously run the tests
+> yarn dev-test
+
+# Build for production (automatically called by npm install)
+> yarn build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](https://github.com/vatesfr/xo-web/issues)
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+ISC © [Vates SAS](https://vates.fr)

packages/complex-matcher/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "complex-matcher",
+  "version": "0.2.1",
+  "license": "ISC",
+  "description": "",
+  "keywords": [],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/packages/complex-matcher",
+  "bugs": "https://github.com/vatesfr/xo-web/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@isonoe.net"
+  },
+  "preferGlobal": false,
+  "main": "dist/",
+  "bin": {},
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=4"
+  },
+  "dependencies": {
+    "lodash": "^4.17.4"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.0.0-beta.39",
+    "@babel/core": "7.0.0-beta.39",
+    "@babel/preset-env": "7.0.0-beta.39",
+    "babel-plugin-lodash": "^3.3.2",
+    "cross-env": "^5.1.1",
+    "rimraf": "^2.6.2"
+  },
+  "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"
+  }
+}

packages/complex-matcher/src/index.bench.js

@@ -0,0 +1,12 @@
+import { parse } from './'
+import { ast, pattern } from './index.fixtures'
+
+export default ({ benchmark }) => {
+  benchmark('parse', () => {
+    parse(pattern)
+  })
+
+  benchmark('toString', () => {
+    ast.toString()
+  })
+}

packages/complex-matcher/src/index.fixtures.js

@@ -0,0 +1,15 @@
+import * as CM from './'
+
+export const pattern =
+  'foo !"\\\\ \\"" name:|(wonderwoman batman) hasCape? age:32'
+
+export const ast = new CM.And([
+  new CM.String('foo'),
+  new CM.Not(new CM.String('\\ "')),
+  new CM.Property(
+    'name',
+    new CM.Or([new CM.String('wonderwoman'), new CM.String('batman')])
+  ),
+  new CM.TruthyProperty('hasCape'),
+  new CM.Property('age', new CM.Number(32)),
+])

packages/complex-matcher/src/index.js

@@ -0,0 +1,495 @@
+import { isPlainObject, some } from 'lodash'
+
+// ===================================================================
+
+const RAW_STRING_CHARS = (() => {
+  const chars = { __proto__: null }
+  const add = (a, b = a) => {
+    let i = a.charCodeAt(0)
+    const j = b.charCodeAt(0)
+    while (i <= j) {
+      chars[String.fromCharCode(i++)] = true
+    }
+  }
+  add('$')
+  add('-')
+  add('.')
+  add('0', '9')
+  add('_')
+  add('A', 'Z')
+  add('a', 'z')
+  return chars
+})()
+const isRawString = string => {
+  const { length } = string
+  for (let i = 0; i < length; ++i) {
+    if (!(string[i] in RAW_STRING_CHARS)) {
+      return false
+    }
+  }
+  return true
+}
+
+// -------------------------------------------------------------------
+
+class Node {
+  createPredicate () {
+    return value => this.match(value)
+  }
+}
+
+export class Null extends Node {
+  match () {
+    return true
+  }
+
+  toString () {
+    return ''
+  }
+}
+
+const formatTerms = terms => terms.map(term => term.toString(true)).join(' ')
+
+export class And extends Node {
+  constructor (children) {
+    super()
+
+    if (children.length === 1) {
+      return children[0]
+    }
+    this.children = children
+  }
+
+  match (value) {
+    return this.children.every(child => child.match(value))
+  }
+
+  toString (isNested) {
+    const terms = formatTerms(this.children)
+    return isNested ? `(${terms})` : terms
+  }
+}
+
+export class Or extends Node {
+  constructor (children) {
+    super()
+
+    if (children.length === 1) {
+      return children[0]
+    }
+    this.children = children
+  }
+
+  match (value) {
+    return this.children.some(child => child.match(value))
+  }
+
+  toString () {
+    return `|(${formatTerms(this.children)})`
+  }
+}
+
+export class Not extends Node {
+  constructor (child) {
+    super()
+
+    this.child = child
+  }
+
+  match (value) {
+    return !this.child.match(value)
+  }
+
+  toString () {
+    return '!' + this.child.toString(true)
+  }
+}
+
+export class NumberNode extends Node {
+  constructor (value) {
+    super()
+
+    this.value = value
+
+    // should not be enumerable for the tests
+    Object.defineProperty(this, 'match', {
+      value: this.match.bind(this),
+    })
+  }
+
+  match (value) {
+    return (
+      value === this.value ||
+      (value !== null && typeof value === 'object' && some(value, this.match))
+    )
+  }
+
+  toString () {
+    return String(this.value)
+  }
+}
+export { NumberNode as Number }
+
+export class Property extends Node {
+  constructor (name, child) {
+    super()
+
+    this.name = name
+    this.child = child
+  }
+
+  match (value) {
+    return value != null && this.child.match(value[this.name])
+  }
+
+  toString () {
+    return `${formatString(this.name)}:${this.child.toString(true)}`
+  }
+}
+
+const escapeChar = char => '\\' + char
+const formatString = value =>
+  Number.isNaN(+value)
+    ? isRawString(value) ? value : `"${value.replace(/\\|"/g, escapeChar)}"`
+    : `"${value}"`
+
+export class StringNode extends Node {
+  constructor (value) {
+    super()
+
+    this.lcValue = value.toLowerCase()
+    this.value = value
+
+    // should not be enumerable for the tests
+    Object.defineProperty(this, 'match', {
+      value: this.match.bind(this),
+    })
+  }
+
+  match (value) {
+    if (typeof value === 'string') {
+      return value.toLowerCase().indexOf(this.lcValue) !== -1
+    }
+
+    if (Array.isArray(value) || isPlainObject(value)) {
+      return some(value, this.match)
+    }
+
+    return false
+  }
+
+  toString () {
+    return formatString(this.value)
+  }
+}
+export { StringNode as String }
+
+export class TruthyProperty extends Node {
+  constructor (name) {
+    super()
+
+    this.name = name
+  }
+
+  match (value) {
+    return value != null && !!value[this.name]
+  }
+
+  toString () {
+    return formatString(this.name) + '?'
+  }
+}
+
+// -------------------------------------------------------------------
+
+// https://gist.github.com/yelouafi/556e5159e869952335e01f6b473c4ec1
+
+class Failure {
+  constructor (pos, expected) {
+    this.expected = expected
+    this.pos = pos
+  }
+
+  get value () {
+    throw new Error(
+      `parse error: expected ${this.expected} at position ${this.pos}`
+    )
+  }
+}
+
+class Success {
+  constructor (pos, value) {
+    this.pos = pos
+    this.value = value
+  }
+}
+
+// -------------------------------------------------------------------
+
+class P {
+  static alt (...parsers) {
+    const { length } = parsers
+    return new P((input, pos, end) => {
+      for (let i = 0; i < length; ++i) {
+        const result = parsers[i]._parse(input, pos, end)
+        if (result instanceof Success) {
+          return result
+        }
+      }
+      return new Failure(pos, 'alt')
+    })
+  }
+
+  static grammar (rules) {
+    const grammar = {}
+    Object.keys(rules).forEach(k => {
+      const rule = rules[k]
+      grammar[k] = rule instanceof P ? rule : P.lazy(rule, grammar)
+    })
+    return grammar
+  }
+
+  static lazy (parserCreator, arg) {
+    const parser = new P((input, pos, end) =>
+      (parser._parse = parserCreator(arg)._parse)(input, pos, end)
+    )
+    return parser
+  }
+
+  static regex (regex) {
+    regex = new RegExp(regex.source, 'y')
+    return new P((input, pos) => {
+      regex.lastIndex = pos
+      const matches = regex.exec(input)
+      return matches !== null
+        ? new Success(regex.lastIndex, matches[0])
+        : new Failure(pos, regex)
+    })
+  }
+
+  static seq (...parsers) {
+    const { length } = parsers
+    return new P((input, pos, end) => {
+      const values = new Array(length)
+      for (let i = 0; i < length; ++i) {
+        const result = parsers[i]._parse(input, pos, end)
+        if (result instanceof Failure) {
+          return result
+        }
+        pos = result.pos
+        values[i] = result.value
+      }
+      return new Success(pos, values)
+    })
+  }
+
+  static text (text) {
+    const { length } = text
+    return new P(
+      (input, pos) =>
+        input.startsWith(text, pos)
+          ? new Success(pos + length, text)
+          : new Failure(pos, `'${text}'`)
+    )
+  }
+
+  constructor (parse) {
+    this._parse = parse
+  }
+
+  map (fn) {
+    return new P((input, pos, end) => {
+      const result = this._parse(input, pos, end)
+      if (result instanceof Success) {
+        result.value = fn(result.value)
+      }
+      return result
+    })
+  }
+
+  parse (input, pos = 0, end = input.length) {
+    return this._parse(input, pos, end).value
+  }
+
+  repeat (min = 0, max = Infinity) {
+    return new P((input, pos, end) => {
+      const value = []
+      let result
+      let i = 0
+      while (i < min) {
+        ++i
+        result = this._parse(input, pos, end)
+        if (result instanceof Failure) {
+          return result
+        }
+        value.push(result.value)
+        pos = result.pos
+      }
+      while (i < max && (result = this._parse(input, pos, end)) instanceof Success) {
+        ++i
+        value.push(result.value)
+        pos = result.pos
+      }
+      return new Success(pos, value)
+    })
+  }
+
+  skip (otherParser) {
+    return new P((input, pos, end) => {
+      const result = this._parse(input, pos, end)
+      if (result instanceof Failure) {
+        return result
+      }
+      const otherResult = otherParser._parse(input, result.pos, end)
+      if (otherResult instanceof Failure) {
+        return otherResult
+      }
+      result.pos = otherResult.pos
+      return result
+    })
+  }
+}
+
+P.eof = new P(
+  (input, pos, end) =>
+    pos < end ? new Failure(pos, 'end of input') : new Success(pos)
+)
+
+// -------------------------------------------------------------------
+
+const parser = P.grammar({
+  default: r =>
+    P.seq(r.ws, r.term.repeat(), P.eof)
+      .map(([, terms]) => (terms.length === 0 ? new Null() : new And(terms))),
+  quotedString: new P((input, pos, end) => {
+    if (input[pos] !== '"') {
+      return new Failure(pos, '"')
+    }
+    ++pos
+
+    const value = []
+    let char
+    while (pos < end && (char = input[pos++]) !== '"') {
+      if (char === '\\') {
+        char = input[pos++]
+      }
+      value.push(char)
+    }
+
+    return new Success(pos, value.join(''))
+  }),
+  rawString: new P((input, pos, end) => {
+    let value = ''
+    let c
+    while (pos < end && RAW_STRING_CHARS[(c = input[pos])]) {
+      ++pos
+      value += c
+    }
+    return value.length === 0
+      ? new Failure(pos, 'a raw string')
+      : new Success(pos, value)
+  }),
+  string: r => P.alt(r.quotedString, r.rawString),
+  term: r =>
+    P.alt(
+      P.seq(P.text('('), r.ws, r.term.repeat(1), P.text(')')).map(
+        _ => new And(_[2])
+      ),
+      P.seq(
+        P.text('|'),
+        r.ws,
+        P.text('('),
+        r.ws,
+        r.term.repeat(1),
+        P.text(')')
+      ).map(_ => new Or(_[4])),
+      P.seq(P.text('!'), r.ws, r.term).map(_ => new Not(_[2])),
+      P.seq(r.string, r.ws, P.text(':'), r.ws, r.term).map(
+        _ => new Property(_[0], _[4])
+      ),
+      P.seq(r.string, P.text('?')).map(_ => new TruthyProperty(_[0])),
+      P.alt(
+        r.quotedString.map(_ => new StringNode(_)),
+        r.rawString.map(str => {
+          const asNum = +str
+          return Number.isNaN(asNum)
+            ? new StringNode(str)
+            : new NumberNode(asNum)
+        })
+      ),
+    ).skip(r.ws),
+  ws: P.regex(/\s*/),
+}).default
+export const parse = parser.parse.bind(parser)
+
+// -------------------------------------------------------------------
+
+const _getPropertyClauseStrings = ({ child }) => {
+  if (child instanceof Or) {
+    const strings = []
+    child.children.forEach(child => {
+      if (child instanceof StringNode) {
+        strings.push(child.value)
+      }
+    })
+    return strings
+  }
+
+  if (child instanceof StringNode) {
+    return [child.value]
+  }
+
+  return []
+}
+
+// Find possible values for property clauses in a and clause.
+export const getPropertyClausesStrings = node => {
+  if (!node) {
+    return {}
+  }
+
+  if (node instanceof Property) {
+    return {
+      [node.name]: _getPropertyClauseStrings(node),
+    }
+  }
+
+  if (node instanceof And) {
+    const strings = {}
+    node.children.forEach(node => {
+      if (node instanceof Property) {
+        const { name } = node
+        const values = strings[name]
+        if (values) {
+          values.push.apply(values, _getPropertyClauseStrings(node))
+        } else {
+          strings[name] = _getPropertyClauseStrings(node)
+        }
+      }
+    })
+    return strings
+  }
+
+  return {}
+}
+
+// -------------------------------------------------------------------
+
+export const setPropertyClause = (node, name, child) => {
+  const property = child && new Property(
+    name,
+    typeof child === 'string' ? new StringNode(child) : child
+  )
+
+  if (node === undefined) {
+    return property
+  }
+
+  const children = (node instanceof And ? node.children : [node]).filter(child =>
+    !(child instanceof Property && child.name === name)
+  )
+  if (property !== undefined) {
+    children.push(property)
+  }
+  return new And(children)
+}

packages/complex-matcher/src/index.spec.js

@@ -0,0 +1,84 @@
+/* eslint-env jest */
+
+import { ast, pattern } from './index.fixtures'
+import {
+  getPropertyClausesStrings,
+  Null,
+  NumberNode,
+  parse,
+  setPropertyClause,
+} from './'
+
+it('getPropertyClausesStrings', () => {
+  const tmp = getPropertyClausesStrings(parse('foo bar:baz baz:|(foo bar)'))
+  expect(tmp).toEqual({
+    bar: ['baz'],
+    baz: ['foo', 'bar'],
+  })
+})
+
+describe('parse', () => {
+  it('analyses a string and returns a node/tree', () => {
+    expect(parse(pattern)).toEqual(ast)
+  })
+
+  it('supports an empty string', () => {
+    expect(parse('')).toEqual(new Null())
+  })
+
+  it('differentiate between numbers and numbers in strings', () => {
+    let node
+
+    node = parse('32')
+    expect(node.match(32)).toBe(true)
+    expect(node.match('32')).toBe(false)
+    expect(node.toString()).toBe('32')
+
+    node = parse('"32"')
+    expect(node.match(32)).toBe(false)
+    expect(node.match('32')).toBe(true)
+    expect(node.toString()).toBe('"32"')
+  })
+})
+
+describe('Number', () => {
+  it('match a number recursively', () => {
+    expect(new NumberNode(3).match([{ foo: 3 }])).toBe(true)
+  })
+})
+
+describe('setPropertyClause', () => {
+  it('creates a node if none passed', () => {
+    expect(setPropertyClause(undefined, 'foo', 'bar').toString()).toBe('foo:bar')
+  })
+
+  it('adds a property clause if there was none', () => {
+    expect(
+      setPropertyClause(parse('baz'), 'foo', 'bar').toString()
+    ).toBe('baz foo:bar')
+  })
+
+  it('replaces the property clause if there was one', () => {
+    expect(
+      setPropertyClause(parse('plip foo:baz plop'), 'foo', 'bar').toString()
+    ).toBe('plip plop foo:bar')
+
+    expect(
+      setPropertyClause(parse('foo:|(baz plop)'), 'foo', 'bar').toString()
+    ).toBe('foo:bar')
+  })
+
+  it('removes the property clause if no chid is passed', () => {
+    expect(
+      setPropertyClause(parse('foo bar:baz qux'), 'bar', undefined).toString()
+    ).toBe('foo qux')
+
+    expect(
+      setPropertyClause(parse('foo bar:baz qux'), 'baz', undefined).toString()
+    ).toBe('foo bar:baz qux')
+  })
+})
+
+it('toString', () => {
+  expect(pattern).toBe(ast.toString())
+})

packages/value-matcher/.babelrc.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const NODE_ENV = process.env.NODE_ENV || 'development'
+const __PROD__ = NODE_ENV === 'production'
+const __TEST__ = NODE_ENV === 'test'
+
+const pkg = require('./package')
+
+let nodeCompat = (pkg.engines || {}).node
+if (nodeCompat === undefined) {
+  nodeCompat = '6'
+} else {
+  const trimChars = '^=>~'
+  while (trimChars.includes(nodeCompat[0])) {
+    nodeCompat = nodeCompat.slice(1)
+  }
+}
+
+module.exports = {
+  comments: !__PROD__,
+  ignore: __TEST__ ? undefined : [/\.spec\.js$/],
+  presets: [
+    [
+      '@babel/env',
+      {
+        debug: !__TEST__,
+        loose: true,
+        shippedProposals: true,
+        targets: __PROD__
+          ? {
+            browsers: '>2%',
+            node: nodeCompat,
+          }
+          : { node: 'current' },
+        useBuiltIns: '@babel/polyfill' in (pkg.dependencies || {}) && 'usage',
+      },
+    ],
+    '@babel/flow',
+  ],
+}

packages/value-matcher/.npmignore

@@ -0,0 +1,24 @@
+/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__/

packages/value-matcher/README.md

@@ -0,0 +1,66 @@
+# value-matcher [![Build Status](https://travis-ci.org/vatefr/xen-orchestra.png?branch=master)](https://travis-ci.org/vatefr/xen-orchestra)
+
+> ${pkg.description}
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/value-matcher):
+
+```
+> npm install --save value-matcher
+```
+
+## Usage
+
+```js
+import { createPredicate } from 'value-matcher'
+
+[
+  { user: 'sam', age: 65, active: false },
+  { user: 'barney', age: 36, active: true },
+  { user: 'fred', age: 40, active: false },
+].filter(createPredicate({
+  __or: [
+    { user: 'sam' },
+    { active: true },
+  ],
+}))
+// [
+//   { user: 'sam', age: 65, active: false },
+//   { user: 'barney', age: 36, active: true },
+// ]
+```
+
+## Development
+
+```
+# Install dependencies
+> yarn
+
+# Run the tests
+> yarn test
+
+# Continuously compile
+> yarn dev
+
+# Continuously run the tests
+> yarn dev-test
+
+# Build for production (automatically called by npm install)
+> yarn build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](https://github.com/vatesfr/xo-web/issues)
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+ISC © [Vates SAS](https://vates.fr)

packages/value-matcher/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "value-matcher",
+  "version": "0.1.0",
+  "license": "ISC",
+  "description": "",
+  "keywords": [],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/packages/value-matcher",
+  "bugs": "https://github.com/vatesfr/xo-web/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@isonoe.net"
+  },
+  "preferGlobal": false,
+  "main": "dist/",
+  "bin": {},
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=4"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@babel/cli": "7.0.0-beta.39",
+    "@babel/core": "7.0.0-beta.39",
+    "@babel/preset-env": "7.0.0-beta.39",
+    "@babel/preset-flow": "7.0.0-beta.39",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.2"
+  },
+  "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"
+  }
+}

packages/value-matcher/src/index.js

@@ -0,0 +1,70 @@
+// @flow
+
+// eslint-disable-next-line no-use-before-define
+export type Pattern = OrPattern | NotPattern | ObjectPattern | ArrayPattern | ValuePattern
+
+// all patterns must match
+type AndPattern = {| __and: Array<Pattern> |}
+
+// one of the pattern must match
+type OrPattern = {| __or: Array<Pattern> |}
+
+// the pattern must not  match
+type NotPattern = {| __not: Pattern |}
+
+// value is an object with properties matching the patterns
+type ObjectPattern = { [string]: Pattern }
+
+// value is an array and each patterns must match a different item
+type ArrayPattern = Array<Pattern>
+
+// value equals the pattern
+type ValuePattern = bool | number | string
+
+const match = (pattern: Pattern, value: any) => {
+  if (Array.isArray(pattern)) {
+    return Array.isArray(value) && pattern.every((subpattern, i) =>
+      // FIXME: subpatterns should match different subvalues
+      value.some(subvalue => match(subpattern, subvalue))
+    )
+  }
+
+  if (pattern !== null && typeof pattern === 'object') {
+    const keys = Object.keys(pattern)
+    const { length } = keys
+
+    if (length === 1) {
+      const [ key ] = keys
+      if (key === '__and') {
+        const andPattern: AndPattern = (pattern: any)
+        return andPattern.__and.every(subpattern => match(subpattern, value))
+      }
+      if (key === '__or') {
+        const orPattern: OrPattern = (pattern: any)
+        return orPattern.__or.some(subpattern => match(subpattern, value))
+      }
+      if (key === '__not') {
+        const notPattern: NotPattern = (pattern: any)
+        return !match(notPattern.__not, value)
+      }
+    }
+
+    if (value === null || typeof value !== 'object') {
+      return false
+    }
+
+    const objectPattern: ObjectPattern = (pattern: any)
+    for (let i = 0; i < length; ++i) {
+      const key = keys[i]
+      const subvalue = value[key]
+      if (subvalue === undefined || !match(objectPattern[key], subvalue)) {
+        return false
+      }
+    }
+    return true
+  }
+
+  return pattern === value
+}
+
+export const createPredicate = (pattern: Pattern) => (value: any) => match(pattern, value)

packages/vhd-cli/package.json

@@ -29,31 +29,23 @@
     "@nraynaud/struct-fu": "^1.0.1",
     "@nraynaud/xo-fs": "^0.0.5",
     "babel-runtime": "^6.22.0",
-    "exec-promise": "^0.6.1"
+    "exec-promise": "^0.7.0"
   },
   "devDependencies": {
-    "babel-cli": "^6.22.2",
-    "babel-eslint": "^7.1.1",
-    "babel-plugin-lodash": "^3.2.11",
-    "babel-plugin-transform-runtime": "^6.22.0",
-    "babel-preset-env": "^1.1.8",
-    "babel-preset-stage-3": "^6.22.0",
-    "cross-env": "^3.1.4",
-    "dependency-check": "^2.8.0",
-    "jest": "^18.1.0",
-    "rimraf": "^2.5.4",
-    "standard": "^8.6.0"
+    "babel-cli": "^6.24.1",
+    "babel-plugin-lodash": "^3.3.2",
+    "babel-plugin-transform-runtime": "^6.23.0",
+    "babel-preset-env": "^1.5.2",
+    "babel-preset-stage-3": "^6.24.1",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.1"
   },
   "scripts": {
     "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
-    "commitmsg": "npm test",
     "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
-    "dev-test": "jest --bail --watch",
-    "posttest": "standard && dependency-check ./package.json",
     "prebuild": "rimraf dist/",
-    "predev": "npm run prebuild",
-    "prepublish": "npm run build",
-    "test": "jest"
+    "predev": "yarn run prebuild",
+    "prepublishOnly": "yarn run build"
   },
   "babel": {
     "plugins": [
@@ -71,17 +63,5 @@
       ],
       "stage-3"
     ]
-  },
-  "jest": {
-    "testPathDirs": [
-      "<rootDir>/src"
-    ],
-    "testRegex": "\\.spec\\.js$"
-  },
-  "standard": {
-    "ignore": [
-      "dist"
-    ],
-    "parser": "babel-eslint"
   }
 }

packages/vhd-cli/src/vhd.js

@@ -30,7 +30,7 @@ const fuFooter = fu.struct([
   fu.uint32('fileFormatVersion'), // 12
   fu.struct('dataOffset', [
     fu.uint32('high'), // 16
-    fu.uint32('low') // 20
+    fu.uint32('low'), // 20
   ]),
   fu.uint32('timestamp'), // 24
   fu.char('creatorApplication', 4), // 28
@@ -38,23 +38,23 @@ const fuFooter = fu.struct([
   fu.uint32('creatorHostOs'), // 36
   fu.struct('originalSize', [ // At the creation, current size of the hard disk.
     fu.uint32('high'), // 40
-    fu.uint32('low') // 44
+    fu.uint32('low'), // 44
   ]),
   fu.struct('currentSize', [ // Current size of the virtual disk. At the creation: currentSize = originalSize.
     fu.uint32('high'), // 48
-    fu.uint32('low') // 52
+    fu.uint32('low'), // 52
   ]),
   fu.struct('diskGeometry', [
     fu.uint16('cylinders'), // 56
     fu.uint8('heads'), // 58
-    fu.uint8('sectorsPerTrackCylinder') // 59
+    fu.uint8('sectorsPerTrackCylinder'), // 59
   ]),
   fu.uint32('diskType'), // 60 Disk type, must be equal to HARD_DISK_TYPE_DYNAMIC/HARD_DISK_TYPE_DIFFERENCING.
   fu.uint32('checksum'), // 64
   fu.uint8('uuid', 16), // 68
   fu.char('saved'), // 84
   fu.char('hidden'), // 85
-  fu.byte('reserved', 426) // 86
+  fu.byte('reserved', 426), // 86
 ])
 const FOOTER_SIZE = fuFooter.size
 
@@ -62,11 +62,11 @@ const fuHeader = fu.struct([
   fu.char('cookie', 8),
   fu.struct('dataOffset', [
     fu.uint32('high'),
-    fu.uint32('low')
+    fu.uint32('low'),
   ]),
   fu.struct('tableOffset', [ // Absolute byte offset of the Block Allocation Table.
     fu.uint32('high'),
-    fu.uint32('low')
+    fu.uint32('low'),
   ]),
   fu.uint32('headerVersion'),
   fu.uint32('maxTableEntries'), // Max entries in the Block Allocation Table.
@@ -83,10 +83,10 @@ const fuHeader = fu.struct([
     fu.uint32('reserved'),
     fu.struct('platformDataOffset', [ // Absolute byte offset of the locator data.
       fu.uint32('high'),
-      fu.uint32('low')
-    ])
+      fu.uint32('low'),
+    ]),
   ], 8),
-  fu.byte('reserved2', 256)
+  fu.byte('reserved2', 256),
 ])
 const HEADER_SIZE = fuHeader.size
 
@@ -265,7 +265,7 @@ export default class Vhd {
 
     return this._handler.createReadStream(this._path, {
       end: begin + length - 1,
-      start: begin
+      start: begin,
     }).then(buf
       ? stream => streamToExistingBuffer(stream, buf, offset, (offset || 0) + length)
       : streamToNewBuffer
@@ -324,7 +324,7 @@ export default class Vhd {
     const sectorsPerBlock = header.blockSize / SECTOR_SIZE
     assert(sectorsPerBlock % 1 === 0)
 
-     // 1 bit per sector, rounded up to full sectors
+    // 1 bit per sector, rounded up to full sectors
     this._blockBitmapSize = Math.ceil(sectorsPerBlock / 8 / SECTOR_SIZE) * SECTOR_SIZE
     assert(this._blockBitmapSize === SECTOR_SIZE)
 

packages/xen-api/.gitignore

@@ -0,0 +1 @@
+/plot.dat

packages/xen-api/.npmignore

@@ -0,0 +1,24 @@
+/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__/

packages/xen-api/README.md

@@ -0,0 +1,128 @@
+# xen-api [![Build Status](https://travis-ci.org/vatesfr/xen-orchestra.png?branch=master)](https://travis-ci.org/vatesfr/xen-orchestra)
+
+> Connector to the Xen API
+
+Tested with:
+
+- XenServer 7.1
+- XenServer 7
+- XenServer 6.5
+- XenServer 6.2
+- XenServer 5.6
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/xen-api):
+
+```
+> npm install --save xen-api
+```
+
+## Usage
+
+### Library
+
+```javascript
+const { createClient } = require('xen-api')
+
+const xapi = createClient({
+  url: 'https://xen1.company.net',
+  allowUnauthorized: false,
+  auth: {
+    user: 'root',
+    password: 'important secret password'
+  },
+  readOnly: false
+})
+```
+
+Options:
+
+- `url`: address of a host in the pool we are trying to connect to
+- `allowUnauthorized`: whether to accept self-signed certificates
+- `auth`: credentials used to sign in (can also be specified in the URL)
+- `readOnly = false`: if true, no methods with side-effects can be called
+
+```js
+// Force connection.
+xapi.connect().catch(error => {
+  console.error(error)
+})
+
+// Watch objects.
+xapi.objects.on('add', objects => {
+  console.log('new objects:', objects)
+})
+```
+
+> Note: all objects are frozen and cannot be altered!
+
+Custom fields on objects (hidden − ie. non enumerable):
+- `$type`: the type of the object (`VM`, `task`, …);
+- `$ref`: the (opaque) reference of the object;
+- `$id`: the identifier of this object (its UUID if any, otherwise its reference);
+- `$pool`: the pool object this object belongs to.
+
+Furthermore, any field containing a reference (or references if an
+array) can be resolved by prepending the field name with a `$`:
+
+```javascript
+console.log(xapi.pool.$master.$resident_VMs[0].name_label)
+// vm1
+```
+
+### CLI
+
+A CLI is provided to help exploration and discovery of the XAPI.
+
+```
+> xen-api https://xen1.company.net root
+Password: ******
+root@xen1.company.net> xapi.status
+'connected'
+root@xen1.company.net> xapi.pool.master
+'OpaqueRef:ec7c5147-8aee-990f-c70b-0de916a8e993'
+root@xen1.company.net> xapi.pool.$master.name_label
+'xen1'
+```
+
+To ease searches, `find()` and `findAll()` functions are available:
+
+```
+root@xen1.company.net> findAll({ $type: 'vm' }).length
+183
+```
+
+## Development
+
+```
+# Install dependencies
+> npm install
+
+# Run the tests
+> npm test
+
+# Continuously compile
+> npm run dev
+
+# Continuously run the tests
+> npm run dev-test
+
+# Build for production (automatically called by npm install)
+> npm run build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](https://github.com/xen-api/issues)
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+ISC © [Julien Fontanet](https://github.com/julien-f)

packages/xen-api/examples/export-vdi

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+process.env.DEBUG = '*'
+
+const defer = require('golike-defer').default
+const pump = require('pump')
+const { fromCallback } = require('promise-toolbox')
+
+const { createClient } = require('../')
+
+const { createOutputStream, resolveRef } = require('./utils')
+
+defer(async ($defer, args) => {
+  let raw = false
+  if (args[0] === '--raw') {
+    raw = true
+    args.shift()
+  }
+
+  if (args.length < 2) {
+    return console.log('Usage: export-vdi [--raw] <XS URL> <VDI identifier> [<VHD file>]')
+  }
+
+  const xapi = createClient({
+    allowUnauthorized: true,
+    url: args[0],
+    watchEvents: false
+  })
+
+  await xapi.connect()
+  $defer(() => xapi.disconnect())
+
+  // https://xapi-project.github.io/xen-api/snapshots.html#downloading-a-disk-or-snapshot
+  const exportStream = await xapi.getResource('/export_raw_vdi/', {
+    query: {
+      format: raw ? 'raw' : 'vhd',
+      vdi: await resolveRef(xapi, 'VDI', args[1])
+    }
+  })
+
+  console.warn('Export task:', exportStream.headers['task-id'])
+
+  await fromCallback(cb => pump(
+    exportStream,
+    createOutputStream(args[2]),
+    cb
+  ))
+})(process.argv.slice(2)).catch(
+  console.error.bind(console, 'error')
+)

packages/xen-api/examples/export-vm

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+process.env.DEBUG = '*'
+
+const defer = require('golike-defer').default
+const pump = require('pump')
+const { fromCallback } = require('promise-toolbox')
+
+const { createClient } = require('../')
+
+const { createOutputStream, resolveRef } = require('./utils')
+
+defer(async ($defer, args) => {
+  if (args.length < 2) {
+    return console.log('Usage: export-vm <XS URL> <VM identifier> [<XVA file>]')
+  }
+
+  const xapi = createClient({
+    allowUnauthorized: true,
+    url: args[0],
+    watchEvents: false
+  })
+
+  await xapi.connect()
+  $defer(() => xapi.disconnect())
+
+  // https://xapi-project.github.io/xen-api/importexport.html
+  const exportStream = await xapi.getResource('/export/', {
+    query: {
+      ref: await resolveRef(xapi, 'VM', args[1]),
+      use_compression: 'true'
+    }
+  })
+
+  console.warn('Export task:', exportStream.headers['task-id'])
+
+  await fromCallback(cb => pump(
+    exportStream,
+    createOutputStream(args[2]),
+    cb
+  ))
+})(process.argv.slice(2)).catch(
+  console.error.bind(console, 'error')
+)

packages/xen-api/examples/import-vdi

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+process.env.DEBUG = '*'
+
+const defer = require('golike-defer').default
+
+const { createClient } = require('../')
+
+const { createInputStream, resolveRef } = require('./utils')
+
+defer(async ($defer, args) => {
+  let raw = false
+  if (args[0] === '--raw') {
+    raw = true
+    args.shift()
+  }
+
+  if (args.length < 2) {
+    return console.log('Usage: import-vdi [--raw] <XS URL> <VDI identifier> [<VHD file>]')
+  }
+
+  const xapi = createClient({
+    allowUnauthorized: true,
+    url: args[0],
+    watchEvents: false
+  })
+
+  await xapi.connect()
+  $defer(() => xapi.disconnect())
+
+  // https://xapi-project.github.io/xen-api/snapshots.html#uploading-a-disk-or-snapshot
+  await xapi.putResource(createInputStream(args[2]), '/import_raw_vdi/', {
+    query: {
+      format: raw ? 'raw' : 'vhd',
+      vdi: await resolveRef(xapi, 'VDI', args[1])
+    }
+  })
+})(process.argv.slice(2)).catch(
+  console.error.bind(console, 'error')
+)

packages/xen-api/examples/import-vm

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+process.env.DEBUG = '*'
+
+const defer = require('golike-defer').default
+
+const { createClient } = require('../')
+
+const { createInputStream, resolveRef } = require('./utils')
+
+defer(async ($defer, args) => {
+  if (args.length < 1) {
+    return console.log('Usage: import-vm <XS URL> [<XVA file>] [<SR identifier>]')
+  }
+
+  const xapi = createClient({
+    allowUnauthorized: true,
+    url: args[0],
+    watchEvents: false
+  })
+
+  await xapi.connect()
+  $defer(() => xapi.disconnect())
+
+  // https://xapi-project.github.io/xen-api/importexport.html
+  await xapi.putResource(createInputStream(args[1]), '/import/', {
+    query: args[2] && { sr_id: await resolveRef(xapi, 'SR', args[2]) }
+  })
+})(process.argv.slice(2)).catch(
+  console.error.bind(console, 'error')
+)

packages/xen-api/examples/log-events

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+require('source-map-support').install()
+
+const { forEach, size } = require('lodash')
+
+const { createClient } = require('../')
+
+// ===================================================================
+
+if (process.argv.length < 3) {
+  return console.log('Usage: log-events <XS URL>')
+}
+
+// ===================================================================
+// Creation
+
+const xapi = createClient({
+  allowUnauthorized: true,
+  url: process.argv[2]
+})
+
+// ===================================================================
+// Method call
+
+xapi.connect().then(() => {
+  xapi.call('VM.get_all_records')
+  .then(function (vms) {
+    console.log('%s VMs fetched', size(vms))
+  })
+  .catch(function (error) {
+    console.error(error)
+  })
+})
+
+// ===================================================================
+// Objects
+
+const objects = xapi.objects
+
+objects.on('add', objects => {
+  forEach(objects, object => {
+    console.log('+ %s: %s', object.$type, object.$id)
+  })
+})
+
+objects.on('update', objects => {
+  forEach(objects, object => {
+    console.log('± %s: %s', object.$type, object.$id)
+  })
+})
+
+objects.on('remove', objects => {
+  forEach(objects, (value, id) => {
+    console.log('- %s', id)
+  })
+})

packages/xen-api/examples/package.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "golike-defer": "^0.1.0",
+    "pump": "^1.0.2"
+  }
+}

packages/xen-api/examples/utils.js

@@ -0,0 +1,41 @@
+const { createReadStream, createWriteStream, statSync } = require('fs')
+const { PassThrough } = require('stream')
+
+const { isOpaqueRef } = require('../') // eslint-disable-line node/no-missing-require
+
+exports.createInputStream = path => {
+  if (path === undefined || path === '-') {
+    return process.stdin
+  }
+
+  const { size } = statSync(path)
+
+  const stream = createReadStream(path)
+  stream.length = size
+  return stream
+}
+
+exports.createOutputStream = path => {
+  if (path !== undefined && path !== '-') {
+    return createWriteStream(path)
+  }
+
+  // introduce a through stream because stdout is not a normal stream!
+  const stream = new PassThrough()
+  stream.pipe(process.stdout)
+  return stream
+}
+
+exports.resolveRef = (xapi, type, refOrUuidOrNameLabel) =>
+  isOpaqueRef(refOrUuidOrNameLabel)
+    ? refOrUuidOrNameLabel
+    : xapi.call(`${type}.get_by_uuid`, refOrUuidOrNameLabel).catch(
+      () => xapi.call(`${type}.get_by_name_label`, refOrUuidOrNameLabel).then(
+        refs => {
+          if (refs.length === 1) {
+            return refs[0]
+          }
+          throw new Error(`no single match for ${type} with name label ${refOrUuidOrNameLabel}`)
+        }
+      )
+    )

packages/xen-api/memory-test.gnu

@@ -0,0 +1,4 @@
+set yrange [ 0 : ]
+set grid
+
+plot for [i=2:4] "plot.dat" using 1:i with lines

packages/xen-api/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "xen-api",
+  "version": "0.16.4",
+  "license": "ISC",
+  "description": "Connector to the Xen API",
+  "keywords": [
+    "xen",
+    "api",
+    "xen-api",
+    "xenapi",
+    "xapi"
+  ],
+  "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/packages/xen-api",
+  "bugs": "https://github.com/vatesfr/xo-web/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vatesfr/xen-orchestra.git"
+  },
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@vates.fr"
+  },
+  "preferGlobal": false,
+  "main": "dist/",
+  "bin": {
+    "xen-api": "dist/cli.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=4"
+  },
+  "dependencies": {
+    "babel-polyfill": "^6.23.0",
+    "blocked": "^1.2.1",
+    "debug": "^3.1.0",
+    "event-to-promise": "^0.8.0",
+    "exec-promise": "^0.7.0",
+    "http-request-plus": "^0.5.0",
+    "iterable-backoff": "^0.0.0",
+    "json-rpc-protocol": "^0.11.2",
+    "kindof": "^2.0.0",
+    "lodash": "^4.17.4",
+    "make-error": "^1.3.0",
+    "minimist": "^1.2.0",
+    "ms": "^2.1.1",
+    "promise-toolbox": "^0.9.5",
+    "pw": "0.0.4",
+    "xmlrpc": "^1.3.2",
+    "xo-collection": "^0.4.1"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.24.1",
+    "babel-plugin-lodash": "^3.3.2",
+    "babel-plugin-transform-decorators-legacy": "^1.3.4",
+    "babel-plugin-transform-function-bind": "^6.22.0",
+    "babel-preset-env": "^1.6.0",
+    "babel-preset-stage-3": "^6.24.1",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.1"
+  },
+  "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/",
+    "plot": "gnuplot -p memory-test.gnu",
+    "prebuild": "rimraf dist/",
+    "predev": "yarn run prebuild",
+    "prepare": "yarn run build",
+    "prepublishOnly": "yarn run build"
+  },
+  "babel": {
+    "plugins": [
+      "lodash",
+      "transform-decorators-legacy",
+      "transform-function-bind"
+    ],
+    "presets": [
+      [
+        "env",
+        {
+          "targets": {
+            "node": 4
+          }
+        }
+      ],
+      "stage-3"
+    ]
+  }
+}

packages/xen-api/src/cli.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+import 'babel-polyfill'
+
+import blocked from 'blocked'
+import createDebug from 'debug'
+import eventToPromise from 'event-to-promise'
+import execPromise from 'exec-promise'
+import minimist from 'minimist'
+import pw from 'pw'
+import { asCallback, fromCallback } from 'promise-toolbox'
+import { filter, find, isArray } from 'lodash'
+import { start as createRepl } from 'repl'
+
+import { createClient } from './'
+
+// ===================================================================
+
+function askPassword (prompt = 'Password: ') {
+  if (prompt) {
+    process.stdout.write(prompt)
+  }
+
+  return new Promise(resolve => {
+    pw(resolve)
+  })
+}
+
+// ===================================================================
+
+const usage = 'Usage: xen-api <url> [<user> [<password>]]'
+
+const main = async args => {
+  const opts = minimist(args, {
+    boolean: ['allow-unauthorized', 'help', 'read-only', 'verbose'],
+
+    alias: {
+      'allow-unauthorized': 'au',
+      debounce: 'd',
+      help: 'h',
+      'read-only': 'ro',
+      verbose: 'v',
+    },
+  })
+
+  if (opts.help) {
+    return usage
+  }
+
+  if (opts.verbose) {
+    // Does not work perfectly.
+    //
+    // https://github.com/visionmedia/debug/pull/156
+    createDebug.enable('xen-api,xen-api:*')
+  }
+
+  let auth
+  if (opts._.length > 1) {
+    const [ , user, password = await askPassword() ] = opts._
+    auth = { user, password }
+  }
+
+  {
+    const debug = createDebug('xen-api:perf')
+    blocked(ms => {
+      debug('blocked for %sms', ms | 0)
+    })
+  }
+
+  const xapi = createClient({
+    url: opts._[0],
+    allowUnauthorized: opts.au,
+    auth,
+    debounce: opts.debounce != null ? +opts.debounce : null,
+    readOnly: opts.ro,
+  })
+  await xapi.connect()
+
+  const repl = createRepl({
+    prompt: `${xapi._humanId}> `,
+  })
+  repl.context.xapi = xapi
+
+  repl.context.find = predicate => find(xapi.objects.all, predicate)
+  repl.context.findAll = predicate => filter(xapi.objects.all, predicate)
+
+  // Make the REPL waits for promise completion.
+  repl.eval = (evaluate => (cmd, context, filename, cb) => {
+    fromCallback(cb => {
+      evaluate.call(repl, cmd, context, filename, cb)
+    }).then(value =>
+      isArray(value) ? Promise.all(value) : value
+    )::asCallback(cb)
+  })(repl.eval)
+
+  await eventToPromise(repl, 'exit')
+
+  try {
+    await xapi.disconnect()
+  } catch (error) {}
+}
+export default main
+
+if (!module.parent) {
+  execPromise(main)
+}

packages/xen-api/src/inject-events.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import { delay as pDelay } from 'promise-toolbox'
+
+import { createClient } from './'
+
+const xapi = (() => {
+  const [ , , url, user, password ] = process.argv
+
+  return createClient({
+    auth: { user, password },
+    url,
+    watchEvents: false,
+  })
+})()
+
+xapi.connect()
+
+  // Get the pool record's ref.
+  .then(() => xapi.call('pool.get_all'))
+
+  // Injects lots of events.
+  .then(([ poolRef ]) => {
+    const loop = () => xapi.call('event.inject', 'pool', poolRef)
+      ::pDelay(10) // A small delay is required to avoid overloading the Xen API.
+      .then(loop)
+
+    return loop()
+  })

packages/xen-api/src/memory-test.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+import { createClient } from './'
+
+let i = 0
+setInterval(() => {
+  const usage = process.memoryUsage()
+  console.log(
+    '%s %s %s %s',
+    i++,
+    Math.round(usage.rss / 1e6),
+    Math.round(usage.heapTotal / 1e6),
+    Math.round(usage.heapUsed / 1e6)
+  )
+}, 1e2)
+
+const [ , , url, user, password ] = process.argv
+createClient({
+  auth: { user, password },
+  readOnly: true,
+  url,
+}).connect()

packages/xen-api/src/transports/_utils.js

@@ -0,0 +1,3 @@
+import makeError from 'make-error'
+
+export const UnsupportedTransport = makeError('UnsupportedTransport')

packages/xen-api/src/transports/auto.js

@@ -0,0 +1,36 @@
+import jsonRpc from './json-rpc'
+import xmlRpc from './xml-rpc'
+import xmlRpcJson from './xml-rpc-json'
+import { UnsupportedTransport } from './_utils'
+
+const factories = [ jsonRpc, xmlRpcJson, xmlRpc ]
+const { length } = factories
+
+export default opts => {
+  let i = 0
+
+  let call
+  function create () {
+    const current = factories[i++](opts)
+    if (i < length) {
+      const currentI = i
+      call = (method, args) => current(method, args).catch(
+        error => {
+          if (error instanceof UnsupportedTransport) {
+            if (currentI === i) { // not changed yet
+              create()
+            }
+            return call(method, args)
+          }
+
+          throw error
+        }
+      )
+    } else {
+      call = current
+    }
+  }
+  create()
+
+  return (method, args) => call(method, args)
+}

packages/xen-api/src/transports/json-rpc.js

@@ -0,0 +1,38 @@
+import httpRequestPlus from 'http-request-plus'
+import { format, parse } from 'json-rpc-protocol'
+
+import { UnsupportedTransport } from './_utils'
+
+export default ({ allowUnauthorized, url }) => {
+  return (method, args) => httpRequestPlus.post(url, {
+    rejectUnauthorized: !allowUnauthorized,
+    body: format.request(0, method, args),
+    headers: {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json',
+    },
+    path: '/jsonrpc',
+  }).readAll('utf8').then(
+    text => {
+      let response
+      try {
+        response = parse(text)
+      } catch (error) {
+        throw new UnsupportedTransport()
+      }
+
+      if (response.type === 'response') {
+        return response.result
+      }
+
+      throw response.error
+    },
+    error => {
+      if (error.response !== undefined) { // HTTP error
+        throw new UnsupportedTransport()
+      }
+
+      throw error
+    }
+  )
+}

packages/xen-api/src/transports/xml-rpc-json.js

@@ -0,0 +1,97 @@
+import { createClient, createSecureClient } from 'xmlrpc'
+import { promisify } from 'promise-toolbox'
+
+import { UnsupportedTransport } from './_utils'
+
+const logError = error => {
+  if (error.res) {
+    console.error(
+      'XML-RPC Error: %s (response status %s)',
+      error.message,
+      error.res.statusCode
+    )
+    console.error('%s', error.body)
+  }
+
+  throw error
+}
+
+const SPECIAL_CHARS = {
+  '\r': '\\r',
+  '\t': '\\t',
+}
+const SPECIAL_CHARS_RE = new RegExp(
+  Object.keys(SPECIAL_CHARS).join('|'),
+  'g'
+)
+
+const parseResult = result => {
+  const status = result.Status
+
+  // Return the plain result if it does not have a valid XAPI
+  // format.
+  if (status === undefined) {
+    return result
+  }
+
+  if (status !== 'Success') {
+    throw result.ErrorDescription
+  }
+
+  const value = result.Value
+
+  // XAPI returns an empty string (invalid JSON) for an empty
+  // result.
+  if (value === '') {
+    return ''
+  }
+
+  try {
+    return JSON.parse(value)
+  } catch (error) {
+    // XAPI JSON sometimes contains invalid characters.
+    if (!(error instanceof SyntaxError)) {
+      throw error
+    }
+  }
+
+  let replaced = false
+  const fixedValue = value.replace(SPECIAL_CHARS_RE, match => {
+    replaced = true
+    return SPECIAL_CHARS[match]
+  })
+
+  if (replaced) {
+    try {
+      return JSON.parse(fixedValue)
+    } catch (error) {
+      if (!(error instanceof SyntaxError)) {
+        throw error
+      }
+    }
+  }
+
+  throw new UnsupportedTransport()
+}
+
+export default ({
+  allowUnauthorized,
+  url: { hostname, path, port, protocol },
+}) => {
+  const client = (
+    protocol === 'https:'
+      ? createSecureClient
+      : createClient
+  )({
+    host: hostname,
+    path: '/json',
+    port,
+    rejectUnauthorized: !allowUnauthorized,
+  })
+  const call = promisify(client.methodCall, client)
+
+  return (method, args) => call(method, args).then(
+    parseResult,
+    logError
+  )
+}

packages/xen-api/src/transports/xml-rpc.js

@@ -0,0 +1,52 @@
+import { createClient, createSecureClient } from 'xmlrpc'
+import { promisify } from 'promise-toolbox'
+
+const logError = error => {
+  if (error.res) {
+    console.error(
+      'XML-RPC Error: %s (response status %s)',
+      error.message,
+      error.res.statusCode
+    )
+    console.error('%s', error.body)
+  }
+
+  throw error
+}
+
+const parseResult = result => {
+  const status = result.Status
+
+  // Return the plain result if it does not have a valid XAPI
+  // format.
+  if (status === undefined) {
+    return result
+  }
+
+  if (status !== 'Success') {
+    throw result.ErrorDescription
+  }
+
+  return result.Value
+}
+
+export default ({
+  allowUnauthorized,
+  url: { hostname, path, port, protocol },
+}) => {
+  const client = (
+    protocol === 'https:'
+      ? createSecureClient
+      : createClient
+  )({
+    host: hostname,
+    port,
+    rejectUnauthorized: !allowUnauthorized,
+  })
+  const call = promisify(client.methodCall, client)
+
+  return (method, args) => call(method, args).then(
+    parseResult,
+    logError
+  )
+}

packages/xo-acl-resolver/.babelrc

@@ -2,7 +2,12 @@
  "comments": false,
  "compact": true,
  "presets": [
-   "stage-0",
-   "es2015"
+   [
+     "env", {
+       "targets": {
+         "node": 4
+       }
+     }
+   ]
  ]
 }

packages/xo-acl-resolver/package.json

@@ -24,25 +24,13 @@
     "node": ">=0.12"
   },
   "devDependencies": {
-    "babel-cli": "^6.4.5",
-    "babel-eslint": "^7.0.0",
-    "babel-preset-es2015": "^6.3.13",
-    "babel-preset-stage-0": "^6.3.13",
-    "dependency-check": "^2.5.1",
-    "standard": "^8.0.0"
+    "babel-cli": "^6.24.1",
+    "babel-preset-env": "^1.6.1"
   },
   "scripts": {
     "build": "babel --source-maps --out-dir=dist/ src/",
-    "depcheck": "dependency-check ./package.json",
     "dev": "babel --watch --source-maps --out-dir=dist/ src/",
-    "lint": "standard",
-    "posttest": "yarn run lint && yarn run depcheck",
-    "prepublish": "yarn run build"
-  },
-  "standard": {
-    "ignore": [
-      "dist/**"
-    ],
-    "parser": "babel-eslint"
+    "prepare": "yarn run build",
+    "prepublishOnly": "yarn run build"
   }
 }

packages/xo-acl-resolver/src/index.js

@@ -85,7 +85,7 @@ const checkAuthorizationByTypes = {
 
   'VM-snapshot': checkMember('$snapshot_of'),
 
-  'VM-template': or(checkSelf, checkMember('$pool'))
+  'VM-template': or(checkSelf, checkMember('$pool')),
 }
 
 // Hoisting is important for this function.

packages/xo-cli/.babelrc.js

@@ -0,0 +1,25 @@
+const { NODE_ENV = 'development' } = process.env
+const __PROD__ = NODE_ENV === 'production'
+const __TEST__ = NODE_ENV === 'test'
+
+module.exports = {
+  comments: !__PROD__,
+  compact: __PROD__,
+  ignore: __TEST__ ? undefined : [ /\.spec\.js$/ ],
+  plugins: ['lodash'],
+  presets: [
+    [
+      '@babel/env',
+      {
+        debug: !__TEST__,
+        loose: true,
+        shippedProposals: true,
+        targets: __PROD__
+          ? { node: '6' }
+          : { node: 'current' },
+        useBuiltIns: 'usage',
+      },
+    ],
+    '@babel/flow',
+  ],
+}

packages/xo-cli/.jshintrc

@@ -1,90 +0,0 @@
-{
-  // Julien Fontanet JSHint configuration
-  //
-  // Changes from defaults:
-  // - all enforcing options (except `++` & `--`) enabled
-  // - single quotes
-  // - indentation set to 2 instead of 4
-  // - almost all relaxing options disabled
-  // - allow expression statements (necessary for chai.expect())
-  // - allow global strict (most of my devs are in Node.js or Browserify)
-  // - environments are set to Browserify, mocha & Node.js
-  //
-  // See http://jshint.com/docs/ for more details
-
-  "maxerr"        : 50,       // {int} Maximum error before stopping
-
-  // Enforcing
-  "bitwise"       : true,     // true: Prohibit bitwise operators (&, |, ^, etc.)
-  "camelcase"     : true,     // true: Identifiers must be in camelCase
-  "curly"         : true,     // true: Require {} for every new block or scope
-  "eqeqeq"        : true,     // true: Require triple equals (===) for comparison
-  "forin"         : true,     // true: Require filtering for..in loops with obj.hasOwnProperty()
-  "immed"         : true,     // true: Require immediate invocations to be wrapped in parens e.g. `(function () { } ());`
-  "indent"        : 2,        // {int} Number of spaces to use for indentation
-  "latedef"       : true,     // true: Require variables/functions to be defined before being used
-  "newcap"        : true,     // true: Require capitalization of all constructor functions e.g. `new F()`
-  "noarg"         : true,     // true: Prohibit use of `arguments.caller` and `arguments.callee`
-  "noempty"       : true,     // true: Prohibit use of empty blocks
-  "nonew"         : true,     // true: Prohibit use of constructors for side-effects (without assignment)
-  "plusplus"      : false,    // true: Prohibit use of `++` & `--`
-  "quotmark"      : "single", // Quotation mark consistency:
-                              //   false    : do nothing (default)
-                              //   true     : ensure whatever is used is consistent
-                              //   "single" : require single quotes
-                              //   "double" : require double quotes
-  "undef"         : true,     // true: Require all non-global variables to be declared (prevents global leaks)
-  "unused"        : true,     // true: Require all defined variables be used
-  "strict"        : true,     // true: Requires all functions run in ES5 Strict Mode
-  "maxparams"     : 4,        // {int} Max number of formal params allowed per function
-  "maxdepth"      : 3,        // {int} Max depth of nested blocks (within functions)
-  "maxstatements" : 20,       // {int} Max number statements per function
-  "maxcomplexity" : 7,        // {int} Max cyclomatic complexity per function
-  "maxlen"        : 80,       // {int} Max number of characters per line
-
-  // Relaxing
-  "asi"           : false,     // true: Tolerate Automatic Semicolon Insertion (no semicolons)
-  "boss"          : false,     // true: Tolerate assignments where comparisons would be expected
-  "debug"         : false,     // true: Allow debugger statements e.g. browser breakpoints.
-  "eqnull"        : false,     // true: Tolerate use of `== null`
-  "es5"           : false,     // true: Allow ES5 syntax (ex: getters and setters)
-  "esnext"        : false,     // true: Allow ES.next (ES6) syntax (ex: `const`)
-  "moz"           : false,     // true: Allow Mozilla specific syntax (extends and overrides esnext features)
-                               // (ex: `for each`, multiple try/catch, function expression…)
-  "evil"          : false,     // true: Tolerate use of `eval` and `new Function()`
-  "expr"          : true,      // true: Tolerate `ExpressionStatement` as Programs
-  "funcscope"     : false,     // true: Tolerate defining variables inside control statements
-  "globalstrict"  : true,      // true: Allow global "use strict" (also enables 'strict')
-  "iterator"      : false,     // true: Tolerate using the `__iterator__` property
-  "lastsemic"     : false,     // true: Tolerate omitting a semicolon for the last statement of a 1-line block
-  "laxbreak"      : false,     // true: Tolerate possibly unsafe line breakings
-  "laxcomma"      : false,     // true: Tolerate comma-first style coding
-  "loopfunc"      : false,     // true: Tolerate functions being defined in loops
-  "multistr"      : false,     // true: Tolerate multi-line strings
-  "proto"         : false,     // true: Tolerate using the `__proto__` property
-  "scripturl"     : false,     // true: Tolerate script-targeted URLs
-  "shadow"        : false,     // true: Allows re-define variables later in code e.g. `var x=1; x=2;`
-  "sub"           : false,     // true: Tolerate using `[]` notation when it can still be expressed in dot notation
-  "supernew"      : false,     // true: Tolerate `new function () { ... };` and `new Object;`
-  "validthis"     : false,     // true: Tolerate using this in a non-constructor function
-
-  // Environments
-  "browser"       : false,    // Web Browser (window, document, etc)
-  "browserify"    : true,     // Browserify (node.js code in the browser)
-  "couch"         : false,    // CouchDB
-  "devel"         : true,     // Development/debugging (alert, confirm, etc)
-  "dojo"          : false,    // Dojo Toolkit
-  "jquery"        : false,    // jQuery
-  "mocha"         : true,     // mocha
-  "mootools"      : false,    // MooTools
-  "node"          : true,     // Node.js
-  "nonstandard"   : false,    // Widely adopted globals (escape, unescape, etc)
-  "prototypejs"   : false,    // Prototype and Scriptaculous
-  "rhino"         : false,    // Rhino
-  "worker"        : false,    // Web Workers
-  "wsh"           : false,    // Windows Scripting Host
-  "yui"           : false,    // Yahoo User Interface
-
-  // Custom Globals
-  "globals"       : {}        // additional predefined global variables
-}

packages/xo-cli/.npmignore

@@ -0,0 +1,24 @@
+/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__/

packages/xo-cli/README.md

@@ -5,7 +5,7 @@
 
 > Basic CLI for Xen-Orchestra
 
-## Installation
+## Install
 
 #### [npm](https://npmjs.org/package/xo-cli)
 
@@ -19,9 +19,13 @@ npm install -g xo-cli
 > xo-cli --help
 Usage:
 
-  xo-cli --register <XO-Server URL> <username> [<password>]
+  xo-cli --register [--expiresIn duration] <XO-Server URL> <username> [<password>]
     Registers the XO instance to use.
 
+    --expiresIn duration
+      Can be used to change the validity duration of the
+      authorization token (default: one month).
+
   xo-cli --unregister
     Remove stored credentials.
 
@@ -113,9 +117,28 @@ encoding by prefixing with `json:`:
 > xo-cli vm.import host=60a6939e-8b0a-4352-9954-5bde44bcdf7d @=vm.xva
 ```
 
-## Contributing
+## Development
 
-Contributions are *very* welcome, either on the documentation or on
+```
+# Install dependencies
+> yarn
+
+# Run the tests
+> yarn test
+
+# Continuously compile
+> yarn dev
+
+# Continuously run the tests
+> yarn dev-test
+
+# Build for production (automatically called by npm install)
+> yarn build
+```
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
 the code.
 
 You may:

packages/xo-cli/index.js

@@ -1,419 +0,0 @@
-#!/usr/bin/env node
-
-'use strict'
-
-var Bluebird = require('bluebird')
-Bluebird.longStackTraces()
-
-var createReadStream = require('fs').createReadStream
-var createWriteStream = require('fs').createWriteStream
-var resolveUrl = require('url').resolve
-var stat = require('fs-promise').stat
-
-var chalk = require('chalk')
-var eventToPromise = require('event-to-promise')
-var filter = require('lodash/filter')
-var forEach = require('lodash/forEach')
-var getKeys = require('lodash/keys')
-var got = require('got')
-var humanFormat = require('human-format')
-var identity = require('lodash/identity')
-var isArray = require('lodash/isArray')
-var isObject = require('lodash/isObject')
-var micromatch = require('micromatch')
-var multiline = require('multiline')
-var nicePipe = require('nice-pipe')
-var pairs = require('lodash/toPairs')
-var pick = require('lodash/pick')
-var prettyMs = require('pretty-ms')
-var progressStream = require('progress-stream')
-var pw = require('pw')
-var Xo = require('xo-lib').default
-
-// -------------------------------------------------------------------
-
-var config = require('./config')
-
-// ===================================================================
-
-function connect () {
-  return config.load().bind({}).then(function (config) {
-    if (!config.server) {
-      throw new Error('no server to connect to!')
-    }
-
-    if (!config.token) {
-      throw new Error('no token available')
-    }
-
-    var xo = new Xo({ url: config.server })
-
-    return xo.open().then(function () {
-      return xo.signIn({ token: config.token })
-    }).then(function () {
-      return xo
-    })
-  })
-}
-
-function _startsWith (string, search) {
-  return string.lastIndexOf(search, 0) === 0
-}
-
-var FLAG_RE = /^--([^=]+)(?:=([^]*))?$/
-function extractFlags (args) {
-  var flags = {}
-
-  var i = 0
-  var n = args.length
-  var matches
-  while (i < n && (matches = args[i].match(FLAG_RE))) {
-    var value = matches[2]
-
-    flags[matches[1]] = value === undefined ? true : value
-    ++i
-  }
-  args.splice(0, i)
-
-  return flags
-}
-
-var PARAM_RE = /^([^=]+)=([^]*)$/
-function parseParameters (args) {
-  var params = {}
-  forEach(args, function (arg) {
-    var matches
-    if (!(matches = arg.match(PARAM_RE))) {
-      throw new Error('invalid arg: ' + arg)
-    }
-    var name = matches[1]
-    var value = matches[2]
-
-    if (_startsWith(value, 'json:')) {
-      value = JSON.parse(value.slice(5))
-    }
-
-    if (name === '@') {
-      params['@'] = value
-      return
-    }
-
-    if (value === 'true') {
-      value = true
-    } else if (value === 'false') {
-      value = false
-    }
-
-    params[name] = value
-  })
-
-  return params
-}
-
-var humanFormatOpts = {
-  unit: 'B',
-  scale: 'binary'
-}
-
-function printProgress (progress) {
-  if (progress.length) {
-    console.warn('%s% of %s @ %s/s - ETA %s',
-      Math.round(progress.percentage),
-      humanFormat(progress.length, humanFormatOpts),
-      humanFormat(progress.speed, humanFormatOpts),
-      prettyMs(progress.eta * 1e3)
-    )
-  } else {
-    console.warn('%s @ %s/s',
-      humanFormat(progress.transferred, humanFormatOpts),
-      humanFormat(progress.speed, humanFormatOpts)
-    )
-  }
-}
-
-function wrap (val) {
-  return function wrappedValue () {
-    return val
-  }
-}
-
-// ===================================================================
-
-var help = wrap((function (pkg) {
-  return multiline.stripIndent(function () { /*
-    Usage:
-
-      $name --register <XO-Server URL> <username> [<password>]
-        Registers the XO instance to use.
-
-      $name --unregister
-        Remove stored credentials.
-
-      $name --list-commands [--json] [<pattern>]...
-        Returns the list of available commands on the current XO instance.
-
-        The patterns can be used to filter on command names.
-
-      $name --list-objects [--<property>]… [<property>=<value>]...
-        Returns a list of XO objects.
-
-        --<property>
-          Restricts displayed properties to those listed.
-
-        <property>=<value>
-          Restricted displayed objects to those matching the patterns.
-
-      $name <command> [<name>=<value>]...
-        Executes a command on the current XO instance.
-
-    $name v$version
-  */ }).replace(/<([^>]+)>|\$(\w+)/g, function (_, arg, key) {
-    if (arg) {
-      return '<' + chalk.yellow(arg) + '>'
-    }
-
-    if (key === 'name') {
-      return chalk.bold(pkg[key])
-    }
-
-    return pkg[key]
-  })
-})(require('./package')))
-
-// -------------------------------------------------------------------
-
-function main (args) {
-  if (!args || !args.length || args[0] === '-h') {
-    return help()
-  }
-
-  var fnName = args[0].replace(/^--|-\w/g, function (match) {
-    if (match === '--') {
-      return ''
-    }
-
-    return match[1].toUpperCase()
-  })
-  if (fnName in exports) {
-    return exports[fnName](args.slice(1))
-  }
-
-  return exports.call(args)
-}
-exports = module.exports = main
-
-// -------------------------------------------------------------------
-
-exports.help = help
-
-function register (args) {
-  var password, xo
-  return Promise.resolve(args[2] || new Promise(function (resolve) {
-    process.stdout.write('Password: ')
-    pw(resolve)
-  })).then(function (password_) {
-    password = password_
-
-    xo = new Xo({ url: args[0] })
-    return xo.open()
-  }).then(function () {
-    return xo.signIn({
-      email: args[1],
-      password: password
-    })
-  }).then(function () {
-    console.log('Successfully logged with', xo.user.email)
-
-    return xo.call('token.create')
-  }).then(function (token) {
-    return config.set({
-      server: args[0],
-      token: token
-    })
-  })
-}
-exports.register = register
-
-function unregister () {
-  return config.unset([
-    'server',
-    'token'
-  ])
-}
-exports.unregister = unregister
-
-function listCommands (args) {
-  return connect().then(function getMethodsInfo (xo) {
-    return xo.call('system.getMethodsInfo')
-  }).then(function formatMethodsInfo (methods) {
-    var json = false
-    var patterns = []
-    forEach(args, function (arg) {
-      if (arg === '--json') {
-        json = true
-      } else {
-        patterns.push(arg)
-      }
-    })
-
-    if (patterns.length) {
-      methods = pick(methods, micromatch(Object.keys(methods), patterns))
-    }
-
-    if (json) {
-      return methods
-    }
-
-    methods = pairs(methods)
-    methods.sort(function (a, b) {
-      a = a[0]
-      b = b[0]
-      if (a < b) {
-        return -1
-      }
-      return +(a > b)
-    })
-
-    var str = []
-    forEach(methods, function (method) {
-      var name = method[0]
-      var info = method[1]
-      str.push(chalk.bold.blue(name))
-      forEach(info.params || [], function (info, name) {
-        str.push(' ')
-        if (info.optional) {
-          str.push('[')
-        }
-
-        var type = info.type
-        str.push(
-          name,
-          '=<',
-          type == null
-            ? 'unknown type'
-            : isArray(type)
-              ? type.join('|')
-              : type,
-          '>'
-        )
-
-        if (info.optional) {
-          str.push(']')
-        }
-      })
-      str.push('\n')
-      if (info.description) {
-        str.push('  ', info.description, '\n')
-      }
-    })
-    return str.join('')
-  })
-}
-exports.listCommands = listCommands
-
-function listObjects (args) {
-  var properties = getKeys(extractFlags(args))
-  var filterProperties = properties.length
-    ? function (object) {
-      return pick(object, properties)
-    }
-    : identity
-
-  var sieve = args.length ? parseParameters(args) : null
-
-  return connect().then(function getXoObjects (xo) {
-    return xo.call('xo.getAllObjects')
-  }).then(function filterObjects (objects) {
-    objects = filter(objects, sieve)
-
-    const stdout = process.stdout
-    stdout.write('[\n')
-    for (var i = 0, n = objects.length; i < n;) {
-      stdout.write(JSON.stringify(filterProperties(objects[i]), null, 2))
-      stdout.write(++i < n ? ',\n' : '\n')
-    }
-    stdout.write(']\n')
-  })
-}
-exports.listObjects = listObjects
-
-function call (args) {
-  if (!args.length) {
-    throw new Error('missing command name')
-  }
-
-  var method = args.shift()
-  var params = parseParameters(args)
-
-  var file = params['@']
-  delete params['@']
-
-  var baseUrl
-  return connect().then(function (xo) {
-    // FIXME: do not use private properties.
-    baseUrl = xo._url.replace(/^ws/, 'http')
-
-    return xo.call(method, params)
-  }).then(function handleResult (result) {
-    var keys, key, url
-    if (
-      isObject(result) &&
-      (keys = getKeys(result)).length === 1
-    ) {
-      key = keys[0]
-
-      if (key === '$getFrom') {
-        url = resolveUrl(baseUrl, result[key])
-        var output = createWriteStream(file)
-
-        var progress = progressStream({ time: 1e3 }, printProgress)
-
-        return eventToPromise(nicePipe([
-          got.stream(url).on('response', function (response) {
-            var length = response.headers['content-length']
-            if (length) {
-              progress.length(length)
-            }
-          }),
-          progress,
-          output
-        ]), 'finish')
-      }
-
-      if (key === '$sendTo') {
-        url = resolveUrl(baseUrl, result[key])
-
-        return stat(file).then(function (stats) {
-          var length = stats.size
-
-          var input = nicePipe([
-            createReadStream(file),
-            progressStream({
-              length: length,
-              time: 1e3
-            }, printProgress)
-          ])
-
-          return got.post(url, {
-            body: input,
-            headers: {
-              'content-length': length
-            },
-            method: 'POST'
-          }).then(function (response) {
-            return response.body
-          })
-        })
-      }
-    }
-
-    return result
-  })
-}
-exports.call = call
-
-// ===================================================================
-
-if (!module.parent) {
-  require('exec-promise')(exports)
-}

packages/xo-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xo-cli",
-  "version": "0.8.3",
+  "version": "0.10.1",
   "license": "AGPL-3.0",
   "description": "Basic CLI for Xen-Orchestra",
   "keywords": [
@@ -11,48 +11,58 @@
   ],
   "homepage": "https://github.com/vatesfr/xen-orchestra/tree/master/packages/xo-cli",
   "bugs": "https://github.com/vatesfr/xo-web/issues",
-  "author": "Julien Fontanet <julien.fontanet@vates.fr>",
-  "preferGlobal": true,
-  "bin": {
-    "xo-cli": "index.js"
-  },
-  "files": [
-    "*.js"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/vatesfr/xen-orchestra.git"
   },
+  "author": "Julien Fontanet <julien.fontanet@vates.fr>",
+  "preferGlobal": true,
+  "main": "dist/",
+  "bin": {
+    "xo-cli": "dist/index.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=6"
+  },
   "dependencies": {
-    "bluebird": "^3.5.0",
-    "chalk": "^1.1.3",
+    "@babel/polyfill": "7.0.0-beta.39",
+    "bluebird": "^3.5.1",
+    "chalk": "^2.2.0",
     "event-to-promise": "^0.8.0",
-    "exec-promise": "^0.6.1",
-    "fs-promise": "^2.0.2",
-    "got": "^6.7.1",
-    "human-format": "^0.8.0",
+    "exec-promise": "^0.7.0",
+    "fs-promise": "^2.0.3",
+    "got": "^8.0.1",
+    "human-format": "^0.10.0",
     "l33teral": "^3.0.3",
     "lodash": "^4.17.4",
-    "micromatch": "^2.3.11",
+    "micromatch": "^3.1.3",
     "mkdirp": "^0.5.1",
-    "multiline": "^1.0.2",
     "nice-pipe": "0.0.0",
-    "pretty-ms": "^2.1.0",
-    "progress-stream": "^1.2.0",
+    "pretty-ms": "^3.0.1",
+    "progress-stream": "^2.0.0",
     "pw": "^0.0.4",
+    "strip-indent": "^2.0.0",
     "xdg-basedir": "^3.0.0",
-    "xo-lib": "^0.8.2"
+    "xo-lib": "^0.9.0"
   },
   "devDependencies": {
-    "standard": "^9.0.2"
+    "@babel/cli": "7.0.0-beta.39",
+    "@babel/core": "7.0.0-beta.39",
+    "@babel/preset-env": "7.0.0-beta.39",
+    "@babel/preset-flow": "7.0.0-beta.39",
+    "babel-plugin-lodash": "^3.3.2",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.2"
   },
   "scripts": {
-    "lint": "standard",
-    "posttest": "yarn run lint"
-  },
-  "greenkeeper": {
-    "ignore": [
-      "nice-pipe"
-    ]
+    "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/",
+    "prebuild": "rimraf dist/",
+    "predev": "yarn run prebuild",
+    "prepublishOnly": "yarn run build",
+    "pretest": "flow status"
   }
 }

packages/xo-cli/src/config.js

@@ -2,24 +2,24 @@
 
 // ===================================================================
 
-var promisify = require('bluebird').promisify
+const promisify = require('bluebird').promisify
 
-var readFile = promisify(require('fs').readFile)
-var writeFile = promisify(require('fs').writeFile)
+const readFile = promisify(require('fs').readFile)
+const writeFile = promisify(require('fs').writeFile)
 
-var assign = require('lodash/assign')
-var l33t = require('l33teral')
-var mkdirp = promisify(require('mkdirp'))
-var xdgBasedir = require('xdg-basedir')
+const assign = require('lodash/assign')
+const l33t = require('l33teral')
+const mkdirp = promisify(require('mkdirp'))
+const xdgBasedir = require('xdg-basedir')
 
 // ===================================================================
 
-var configPath = xdgBasedir.config + '/xo-cli'
-var configFile = configPath + '/config.json'
+const configPath = xdgBasedir.config + '/xo-cli'
+const configFile = configPath + '/config.json'
 
 // ===================================================================
 
-var load = exports.load = function () {
+const load = exports.load = function () {
   return readFile(configFile).then(JSON.parse).catch(function () {
     return {}
   })
@@ -31,7 +31,7 @@ exports.get = function (path) {
   })
 }
 
-var save = exports.save = function (config) {
+const save = exports.save = function (config) {
   return mkdirp(configPath).then(function () {
     return writeFile(configFile, JSON.stringify(config))
   })
@@ -45,7 +45,7 @@ exports.set = function (data) {
 
 exports.unset = function (paths) {
   return load().then(function (config) {
-    var l33tConfig = l33t(config)
+    const l33tConfig = l33t(config)
     ;[].concat(paths).forEach(function (path) {
       l33tConfig.purge(path, true)
     })

packages/xo-cli/src/index.js

@@ -0,0 +1,410 @@
+#!/usr/bin/env node
+
+'use strict'
+
+const Bluebird = require('bluebird')
+Bluebird.longStackTraces()
+
+const createReadStream = require('fs').createReadStream
+const createWriteStream = require('fs').createWriteStream
+const resolveUrl = require('url').resolve
+const stat = require('fs-promise').stat
+
+const chalk = require('chalk')
+const eventToPromise = require('event-to-promise')
+const forEach = require('lodash/forEach')
+const getKeys = require('lodash/keys')
+const got = require('got')
+const humanFormat = require('human-format')
+const identity = require('lodash/identity')
+const isArray = require('lodash/isArray')
+const isObject = require('lodash/isObject')
+const micromatch = require('micromatch')
+const nicePipe = require('nice-pipe')
+const pairs = require('lodash/toPairs')
+const pick = require('lodash/pick')
+const startsWith = require('lodash/startsWith')
+const prettyMs = require('pretty-ms')
+const progressStream = require('progress-stream')
+const pw = require('pw')
+
+// FIXME: re-enable the rule when https://github.com/mysticatea/eslint-plugin-node/issues/100 is fixed
+// eslint-disable-next-line node/no-missing-require
+const Xo = require('xo-lib').default
+
+// -------------------------------------------------------------------
+
+const config = require('./config')
+
+// ===================================================================
+
+async function connect () {
+  const { server, token } = await config.load()
+  if (server === undefined) {
+    throw new Error('no server to connect to!')
+  }
+
+  if (token === undefined) {
+    throw new Error('no token available')
+  }
+
+  const xo = new Xo({ url: server })
+  await xo.open()
+  await xo.signIn({ token })
+  return xo
+}
+
+const FLAG_RE = /^--([^=]+)(?:=([^]*))?$/
+function extractFlags (args) {
+  const flags = {}
+
+  let i = 0
+  const n = args.length
+  let matches
+  while (i < n && (matches = args[i].match(FLAG_RE))) {
+    const value = matches[2]
+
+    flags[matches[1]] = value === undefined ? true : value
+    ++i
+  }
+  args.splice(0, i)
+
+  return flags
+}
+
+const PARAM_RE = /^([^=]+)=([^]*)$/
+function parseParameters (args) {
+  const params = {}
+  forEach(args, function (arg) {
+    let matches
+    if (!(matches = arg.match(PARAM_RE))) {
+      throw new Error('invalid arg: ' + arg)
+    }
+    const name = matches[1]
+    let value = matches[2]
+
+    if (startsWith(value, 'json:')) {
+      value = JSON.parse(value.slice(5))
+    }
+
+    if (name === '@') {
+      params['@'] = value
+      return
+    }
+
+    if (value === 'true') {
+      value = true
+    } else if (value === 'false') {
+      value = false
+    }
+
+    params[name] = value
+  })
+
+  return params
+}
+
+const humanFormatOpts = {
+  unit: 'B',
+  scale: 'binary',
+}
+
+function printProgress (progress) {
+  if (progress.length) {
+    console.warn('%s% of %s @ %s/s - ETA %s',
+      Math.round(progress.percentage),
+      humanFormat(progress.length, humanFormatOpts),
+      humanFormat(progress.speed, humanFormatOpts),
+      prettyMs(progress.eta * 1e3)
+    )
+  } else {
+    console.warn('%s @ %s/s',
+      humanFormat(progress.transferred, humanFormatOpts),
+      humanFormat(progress.speed, humanFormatOpts)
+    )
+  }
+}
+
+function wrap (val) {
+  return function wrappedValue () {
+    return val
+  }
+}
+
+// ===================================================================
+
+const help = wrap((function (pkg) {
+  return require('strip-indent')(`
+    Usage:
+
+      $name --register [--expiresIn duration] <XO-Server URL> <username> [<password>]
+        Registers the XO instance to use.
+
+        --expiresIn duration
+          Can be used to change the validity duration of the
+          authorization token (default: one month).
+
+      $name --unregister
+        Remove stored credentials.
+
+      $name --list-commands [--json] [<pattern>]...
+        Returns the list of available commands on the current XO instance.
+
+        The patterns can be used to filter on command names.
+
+      $name --list-objects [--<property>]… [<property>=<value>]...
+        Returns a list of XO objects.
+
+        --<property>
+          Restricts displayed properties to those listed.
+
+        <property>=<value>
+          Restricted displayed objects to those matching the patterns.
+
+      $name <command> [<name>=<value>]...
+        Executes a command on the current XO instance.
+
+    $name v$version
+  `).replace(/<([^>]+)>|\$(\w+)/g, function (_, arg, key) {
+    if (arg) {
+      return '<' + chalk.yellow(arg) + '>'
+    }
+
+    if (key === 'name') {
+      return chalk.bold(pkg[key])
+    }
+
+    return pkg[key]
+  })
+})(require('../package')))
+
+// -------------------------------------------------------------------
+
+function main (args) {
+  if (!args || !args.length || args[0] === '-h') {
+    return help()
+  }
+
+  const fnName = args[0].replace(/^--|-\w/g, function (match) {
+    if (match === '--') {
+      return ''
+    }
+
+    return match[1].toUpperCase()
+  })
+  if (fnName in exports) {
+    return exports[fnName](args.slice(1))
+  }
+
+  return exports.call(args)
+}
+exports = module.exports = main
+
+// -------------------------------------------------------------------
+
+exports.help = help
+
+async function register (args) {
+  let expiresIn
+  if (args[0] === '--expiresIn') {
+    expiresIn = args[1]
+    args = args.slice(2)
+  }
+
+  const [
+    url,
+    email,
+    password = await new Promise(function (resolve) {
+      process.stdout.write('Password: ')
+      pw(resolve)
+    }),
+  ] = args
+
+  const xo = new Xo({ url })
+  await xo.open()
+  await xo.signIn({ email, password })
+  console.log('Successfully logged with', xo.user.email)
+
+  await config.set({
+    server: url,
+    token: await xo.call('token.create', { expiresIn }),
+  })
+}
+exports.register = register
+
+function unregister () {
+  return config.unset([
+    'server',
+    'token',
+  ])
+}
+exports.unregister = unregister
+
+async function listCommands (args) {
+  const xo = await connect()
+  let methods = await xo.call('system.getMethodsInfo')
+
+  let json = false
+  const patterns = []
+  forEach(args, function (arg) {
+    if (arg === '--json') {
+      json = true
+    } else {
+      patterns.push(arg)
+    }
+  })
+
+  if (patterns.length) {
+    methods = pick(methods, micromatch(Object.keys(methods), patterns))
+  }
+
+  if (json) {
+    return methods
+  }
+
+  methods = pairs(methods)
+  methods.sort(function (a, b) {
+    a = a[0]
+    b = b[0]
+    if (a < b) {
+      return -1
+    }
+    return +(a > b)
+  })
+
+  const str = []
+  forEach(methods, function (method) {
+    const name = method[0]
+    const info = method[1]
+    str.push(chalk.bold.blue(name))
+    forEach(info.params || [], function (info, name) {
+      str.push(' ')
+      if (info.optional) {
+        str.push('[')
+      }
+
+      const type = info.type
+      str.push(
+        name,
+        '=<',
+        type == null
+          ? 'unknown type'
+          : isArray(type)
+            ? type.join('|')
+            : type,
+        '>'
+      )
+
+      if (info.optional) {
+        str.push(']')
+      }
+    })
+    str.push('\n')
+    if (info.description) {
+      str.push('  ', info.description, '\n')
+    }
+  })
+  return str.join('')
+}
+exports.listCommands = listCommands
+
+async function listObjects (args) {
+  const properties = getKeys(extractFlags(args))
+  const filterProperties = properties.length
+    ? function (object) {
+      return pick(object, properties)
+    }
+    : identity
+
+  const filter = args.length ? parseParameters(args) : undefined
+
+  const xo = await connect()
+  const objects = await xo.call('xo.getAllObjects', { filter })
+
+  const stdout = process.stdout
+  stdout.write('[\n')
+  const keys = Object.keys(objects)
+  for (let i = 0, n = keys.length; i < n;) {
+    stdout.write(JSON.stringify(filterProperties(objects[keys[i]]), null, 2))
+    stdout.write(++i < n ? ',\n' : '\n')
+  }
+  stdout.write(']\n')
+}
+exports.listObjects = listObjects
+
+async function call (args) {
+  if (!args.length) {
+    throw new Error('missing command name')
+  }
+
+  const method = args.shift()
+  const params = parseParameters(args)
+
+  const file = params['@']
+  delete params['@']
+
+  const xo = await connect()
+
+  // FIXME: do not use private properties.
+  const baseUrl = xo._url.replace(/^ws/, 'http')
+
+  const result = await xo.call(method, params)
+  let keys, key, url
+  if (
+    isObject(result) &&
+    (keys = getKeys(result)).length === 1
+  ) {
+    key = keys[0]
+
+    if (key === '$getFrom') {
+      url = resolveUrl(baseUrl, result[key])
+      const output = createWriteStream(file)
+
+      const progress = progressStream({ time: 1e3 }, printProgress)
+
+      return eventToPromise(nicePipe([
+        got.stream(url).on('response', function (response) {
+          const length = response.headers['content-length']
+          if (length !== undefined) {
+            progress.length(length)
+          }
+        }),
+        progress,
+        output,
+      ]), 'finish')
+    }
+
+    if (key === '$sendTo') {
+      url = resolveUrl(baseUrl, result[key])
+
+      const stats = await stat(file)
+      const length = stats.size
+
+      const input = nicePipe([
+        createReadStream(file),
+        progressStream({
+          length: length,
+          time: 1e3,
+        }, printProgress),
+      ])
+
+      const response = await got.post(url, {
+        body: input,
+        headers: {
+          'content-length': length,
+        },
+        method: 'POST',
+      })
+      return response.body
+    }
+  }
+
+  return result
+}
+exports.call = call
+
+// ===================================================================
+
+if (!module.parent) {
+  require('exec-promise')(exports)
+}

packages/xo-collection/index.js

@@ -1 +1 @@
-module.exports = require('./dist/index')
+module.exports = require('./dist/index') // eslint-disable-line node/no-missing-require

packages/xo-collection/package.json

@@ -31,28 +31,21 @@
     "make-error": "^1.0.2"
   },
   "devDependencies": {
-    "babel-cli": "^6.18.0",
-    "babel-eslint": "^7.1.0",
-    "babel-plugin-lodash": "^3.2.11",
-    "babel-plugin-transform-runtime": "^6.15.0",
-    "babel-preset-env": "^1.1.8",
-    "babel-preset-stage-3": "^6.17.0",
-    "cross-env": "^3.1.4",
-    "dependency-check": "^2.7.0",
-    "event-to-promise": "^0.7.0",
-    "jest": "^18.1.0",
-    "rimraf": "^2.5.4",
-    "standard": "^8.6.0"
+    "babel-cli": "^6.24.1",
+    "babel-plugin-lodash": "^3.3.2",
+    "babel-plugin-transform-runtime": "^6.23.0",
+    "babel-preset-env": "^1.5.2",
+    "babel-preset-stage-3": "^6.24.1",
+    "cross-env": "^5.1.3",
+    "event-to-promise": "^0.8.0",
+    "rimraf": "^2.6.1"
   },
   "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/",
-    "dev-test": "jest --bail --watch",
-    "posttest": "standard && dependency-check ./package.json --entry dist/collection.js index.js unique-index.js view.js",
     "prebuild": "rimraf dist/",
     "predev": "yarn run prebuild",
-    "prepublish": "yarn run build",
-    "test": "jest"
+    "prepublishOnly": "yarn run build"
   },
   "babel": {
     "plugins": [
@@ -70,17 +63,5 @@
       ],
       "stage-3"
     ]
-  },
-  "jest": {
-    "testPathDirs": [
-      "<rootDir>/src"
-    ],
-    "testRegex": "\\.spec\\.js$"
-  },
-  "standard": {
-    "ignore": [
-      "dist"
-    ],
-    "parser": "babel-eslint"
   }
 }

packages/xo-collection/src/collection.js

@@ -10,7 +10,7 @@ import isObject from './is-object'
 
 const {
   create: createObject,
-  prototype: { hasOwnProperty }
+  prototype: { hasOwnProperty },
 } = Object
 
 export const ACTION_ADD = 'add'
@@ -269,7 +269,7 @@ export default class Collection extends EventEmitter {
       const data = {
         add: createObject(null),
         remove: createObject(null),
-        update: createObject(null)
+        update: createObject(null),
       }
 
       for (const key in this._buffer) {

packages/xo-collection/src/collection.spec.js

@@ -3,7 +3,7 @@
 import eventToPromise from 'event-to-promise'
 import { forEach } from 'lodash'
 
-import Collection, {DuplicateItem, NoSuchItem} from '..'
+import Collection, {DuplicateItem, NoSuchItem} from './collection'
 
 // ===================================================================
 
@@ -23,15 +23,16 @@ function waitTicks (n = 2) {
 }
 
 describe('Collection', function () {
+  let col
   beforeEach(function () {
-    this.col = new Collection()
-    this.col.add('bar', 0)
+    col = new Collection()
+    col.add('bar', 0)
 
     return waitTicks()
   })
 
   it('is iterable', function () {
-    const iterator = this.col[Symbol.iterator]()
+    const iterator = col[Symbol.iterator]()
 
     expect(iterator.next()).toEqual({done: false, value: ['bar', 0]})
     expect(iterator.next()).toEqual({done: true, value: undefined})
@@ -39,7 +40,7 @@ describe('Collection', function () {
 
   describe('#keys()', function () {
     it('returns an iterator over the keys', function () {
-      const iterator = this.col.keys()
+      const iterator = col.keys()
 
       expect(iterator.next()).toEqual({done: false, value: 'bar'})
       expect(iterator.next()).toEqual({done: true, value: undefined})
@@ -48,7 +49,7 @@ describe('Collection', function () {
 
   describe('#values()', function () {
     it('returns an iterator over the values', function () {
-      const iterator = this.col.values()
+      const iterator = col.values()
 
       expect(iterator.next()).toEqual({done: false, value: 0})
       expect(iterator.next()).toEqual({done: true, value: undefined})
@@ -58,114 +59,114 @@ describe('Collection', function () {
   describe('#add()', function () {
     it('adds item to the collection', function () {
       const spy = jest.fn()
-      this.col.on('add', spy)
+      col.on('add', spy)
 
-      this.col.add('foo', true)
+      col.add('foo', true)
 
-      expect(this.col.get('foo')).toBe(true)
+      expect(col.get('foo')).toBe(true)
 
       // No sync events.
       expect(spy).not.toHaveBeenCalled()
 
       // Async event.
-      return eventToPromise(this.col, 'add').then(function (added) {
+      return eventToPromise(col, 'add').then(function (added) {
         expect(Object.keys(added)).toEqual([ 'foo' ])
         expect(added.foo).toBe(true)
       })
     })
 
     it('throws an exception if the item already exists', function () {
-      expect(() => this.col.add('bar', true)).toThrowError(DuplicateItem)
+      expect(() => col.add('bar', true)).toThrowError(DuplicateItem)
     })
 
     it('accepts an object with an id property', function () {
       const foo = { id: 'foo' }
 
-      this.col.add(foo)
+      col.add(foo)
 
-      expect(this.col.get(foo.id)).toBe(foo)
+      expect(col.get(foo.id)).toBe(foo)
     })
   })
 
   describe('#update()', function () {
     it('updates an item of the collection', function () {
       const spy = jest.fn()
-      this.col.on('update', spy)
+      col.on('update', spy)
 
-      this.col.update('bar', 1)
-      expect(this.col.get('bar')).toBe(1) // Will be forgotten by de-duplication
-      this.col.update('bar', 2)
-      expect(this.col.get('bar')).toBe(2)
+      col.update('bar', 1)
+      expect(col.get('bar')).toBe(1) // Will be forgotten by de-duplication
+      col.update('bar', 2)
+      expect(col.get('bar')).toBe(2)
 
       // No sync events.
       expect(spy).not.toHaveBeenCalled()
 
       // Async event.
-      return eventToPromise(this.col, 'update').then(function (updated) {
+      return eventToPromise(col, 'update').then(function (updated) {
         expect(Object.keys(updated)).toEqual(['bar'])
         expect(updated.bar).toBe(2)
       })
     })
 
     it('throws an exception if the item does not exist', function () {
-      expect(() => this.col.update('baz', true)).toThrowError(NoSuchItem)
+      expect(() => col.update('baz', true)).toThrowError(NoSuchItem)
     })
 
     it('accepts an object with an id property', function () {
       const bar = { id: 'bar' }
 
-      this.col.update(bar)
+      col.update(bar)
 
-      expect(this.col.get(bar.id)).toBe(bar)
+      expect(col.get(bar.id)).toBe(bar)
     })
   })
 
   describe('#remove()', function () {
     it('removes an item of the collection', function () {
       const spy = jest.fn()
-      this.col.on('remove', spy)
+      col.on('remove', spy)
 
-      this.col.update('bar', 1)
-      expect(this.col.get('bar')).toBe(1) // Will be forgotten by de-duplication
-      this.col.remove('bar')
+      col.update('bar', 1)
+      expect(col.get('bar')).toBe(1) // Will be forgotten by de-duplication
+      col.remove('bar')
 
       // No sync events.
       expect(spy).not.toHaveBeenCalled()
 
       // Async event.
-      return eventToPromise(this.col, 'remove').then(function (removed) {
+      return eventToPromise(col, 'remove').then(function (removed) {
         expect(Object.keys(removed)).toEqual(['bar'])
         expect(removed.bar).toBeUndefined()
       })
     })
 
     it('throws an exception if the item does not exist', function () {
-      expect(() => this.col.remove('baz', true)).toThrowError(NoSuchItem)
+      expect(() => col.remove('baz', true)).toThrowError(NoSuchItem)
     })
 
     it('accepts an object with an id property', function () {
       const bar = { id: 'bar' }
 
-      this.col.remove(bar)
+      col.remove(bar)
 
-      expect(this.col.has(bar.id)).toBe(false)
+      expect(col.has(bar.id)).toBe(false)
     })
   })
 
   describe('#set()', function () {
     it('adds item if collection has not key', function () {
       const spy = jest.fn()
-      this.col.on('add', spy)
+      col.on('add', spy)
 
-      this.col.set('foo', true)
+      col.set('foo', true)
 
-      expect(this.col.get('foo')).toBe(true)
+      expect(col.get('foo')).toBe(true)
 
       // No sync events.
       expect(spy).not.toHaveBeenCalled()
 
       // Async events.
-      return eventToPromise(this.col, 'add').then(function (added) {
+      return eventToPromise(col, 'add').then(function (added) {
         expect(Object.keys(added)).toEqual(['foo'])
         expect(added.foo).toBe(true)
       })
@@ -173,17 +174,17 @@ describe('Collection', function () {
 
     it('updates item if collection has key', function () {
       const spy = jest.fn()
-      this.col.on('udpate', spy)
+      col.on('udpate', spy)
 
-      this.col.set('bar', 1)
+      col.set('bar', 1)
 
-      expect(this.col.get('bar')).toBe(1)
+      expect(col.get('bar')).toBe(1)
 
       // No sync events.
       expect(spy).not.toHaveBeenCalled()
 
       // Async events.
-      return eventToPromise(this.col, 'update').then(function (updated) {
+      return eventToPromise(col, 'update').then(function (updated) {
         expect(Object.keys(updated)).toEqual(['bar'])
         expect(updated.bar).toBe(1)
       })
@@ -192,34 +193,34 @@ describe('Collection', function () {
     it('accepts an object with an id property', function () {
       const foo = { id: 'foo' }
 
-      this.col.set(foo)
+      col.set(foo)
 
-      expect(this.col.get(foo.id)).toBe(foo)
+      expect(col.get(foo.id)).toBe(foo)
     })
   })
 
   describe('#unset()', function () {
     it('removes an existing item', function () {
-      this.col.unset('bar')
+      col.unset('bar')
 
-      expect(this.col.has('bar')).toBe(false)
+      expect(col.has('bar')).toBe(false)
 
-      return eventToPromise(this.col, 'remove').then(function (removed) {
+      return eventToPromise(col, 'remove').then(function (removed) {
         expect(Object.keys(removed)).toEqual(['bar'])
         expect(removed.bar).toBeUndefined()
       })
     })
 
     it('does not throw if the item does not exists', function () {
-      this.col.unset('foo')
+      col.unset('foo')
     })
 
     it('accepts an object with an id property', function () {
-      this.col.unset({id: 'bar'})
+      col.unset({id: 'bar'})
 
-      expect(this.col.has('bar')).toBe(false)
+      expect(col.has('bar')).toBe(false)
 
-      return eventToPromise(this.col, 'remove').then(function (removed) {
+      return eventToPromise(col, 'remove').then(function (removed) {
         expect(Object.keys(removed)).toEqual(['bar'])
         expect(removed.bar).toBeUndefined()
       })
@@ -229,12 +230,12 @@ describe('Collection', function () {
   describe('touch()', function () {
     it('can be used to signal an indirect update', function () {
       const foo = { id: 'foo' }
-      this.col.add(foo)
+      col.add(foo)
 
       return waitTicks().then(() => {
-        this.col.touch(foo)
+        col.touch(foo)
 
-        return eventToPromise(this.col, 'update', (items) => {
+        return eventToPromise(col, 'update', (items) => {
           expect(Object.keys(items)).toEqual(['foo'])
           expect(items.foo).toBe(foo)
         })
@@ -244,11 +245,11 @@ describe('Collection', function () {
 
   describe('clear()', function () {
     it('removes all items from the collection', function () {
-      this.col.clear()
+      col.clear()
 
-      expect(this.col.size).toBe(0)
+      expect(col.size).toBe(0)
 
-      return eventToPromise(this.col, 'remove').then((items) => {
+      return eventToPromise(col, 'remove').then((items) => {
         expect(Object.keys(items)).toEqual(['bar'])
         expect(items.bar).toBeUndefined()
       })
@@ -260,62 +261,60 @@ describe('Collection', function () {
       'add & update → add': [
         [
           ['add', 'foo', 0],
-          ['update', 'foo', 1]
+          ['update', 'foo', 1],
         ],
         {
           add: {
-            foo: 1
-          }
-        }
+            foo: 1,
+          },
+        },
       ],
 
       'add & remove → ∅': [
         [
           ['add', 'foo', 0],
-          ['remove', 'foo']
+          ['remove', 'foo'],
         ],
-        {}
+        {},
       ],
 
       'update & update → update': [
         [
           ['update', 'bar', 1],
-          ['update', 'bar', 2]
+          ['update', 'bar', 2],
         ],
         {
           update: {
-            bar: 2
-          }
-        }
+            bar: 2,
+          },
+        },
       ],
 
       'update & remove → remove': [
         [
           ['update', 'bar', 1],
-          ['remove', 'bar']
+          ['remove', 'bar'],
         ],
         {
           remove: {
-            bar: undefined
-          }
-        }
+            bar: undefined,
+          },
+        },
       ],
 
       'remove & add → update': [
         [
           ['remove', 'bar'],
-          ['add', 'bar', 0]
+          ['add', 'bar', 0],
         ],
         {
           update: {
-            bar: 0
-          }
-        }
-      ]
+            bar: 0,
+          },
+        },
+      ],
     }, ([operations, results], label) => {
       it(label, function () {
-        const {col} = this
-
         forEach(operations, ([method, ...args]) => {
           col[method](...args)
         })

packages/xo-collection/src/index.js

@@ -6,7 +6,7 @@ import NotImplemented from './not-implemented'
 import {
   ACTION_ADD,
   ACTION_UPDATE,
-  ACTION_REMOVE
+  ACTION_REMOVE,
 } from './collection'
 
 // ===================================================================
@@ -77,7 +77,7 @@ export default class Index {
     const {
       computeHash,
       _itemsByHash: itemsByHash,
-      _keysToHash: keysToHash
+      _keysToHash: keysToHash,
     } = this
 
     for (const key in items) {
@@ -104,7 +104,7 @@ export default class Index {
     const {
       computeHash,
       _itemsByHash: itemsByHash,
-      _keysToHash: keysToHash
+      _keysToHash: keysToHash,
     } = this
 
     for (const key in items) {
@@ -135,7 +135,7 @@ export default class Index {
   _onRemove (items) {
     const {
       _itemsByHash: itemsByHash,
-      _keysToHash: keysToHash
+      _keysToHash: keysToHash,
     } = this
 
     for (const key in items) {

packages/xo-collection/src/index.spec.js

@@ -3,8 +3,8 @@
 import eventToPromise from 'event-to-promise'
 import { forEach } from 'lodash'
 
-import Collection from '..'
-import Index from '../index'
+import Collection from './collection'
+import Index from './index'
 
 // ===================================================================
 
@@ -29,18 +29,18 @@ describe('Index', function () {
   let col, byGroup
   const item1 = {
     id: '2ccb8a72-dc65-48e4-88fe-45ef541f2cba',
-    group: 'foo'
+    group: 'foo',
   }
   const item2 = {
     id: '7d21dc51-4da8-4538-a2e9-dd6f4784eb76',
-    group: 'bar'
+    group: 'bar',
   }
   const item3 = {
     id: '668c1274-4442-44a6-b99a-512188e0bb09',
-    group: 'foo'
+    group: 'foo',
   }
   const item4 = {
-    id: 'd90b7335-e540-4a44-ad22-c4baae9cd0a9'
+    id: 'd90b7335-e540-4a44-ad22-c4baae9cd0a9',
   }
 
   beforeEach(function () {
@@ -61,19 +61,19 @@ describe('Index', function () {
       byGroup: {
         foo: {
           [item1.id]: item1,
-          [item3.id]: item3
+          [item3.id]: item3,
         },
         bar: {
-          [item2.id]: item2
-        }
-      }
+          [item2.id]: item2,
+        },
+      },
     })
   })
 
   it('works with added items', function () {
     const item5 = {
       id: '823b56c4-4b96-4f3a-9533-5d08177167ac',
-      group: 'baz'
+      group: 'baz',
     }
 
     col.add(item5)
@@ -83,15 +83,15 @@ describe('Index', function () {
         byGroup: {
           foo: {
             [item1.id]: item1,
-            [item3.id]: item3
+            [item3.id]: item3,
           },
           bar: {
-            [item2.id]: item2
+            [item2.id]: item2,
           },
           baz: {
-            [item5.id]: item5
-          }
-        }
+            [item5.id]: item5,
+          },
+        },
       })
     })
   })
@@ -99,7 +99,7 @@ describe('Index', function () {
   it('works with updated items', function () {
     const item1bis = {
       id: item1.id,
-      group: 'bar'
+      group: 'bar',
     }
 
     col.update(item1bis)
@@ -108,13 +108,13 @@ describe('Index', function () {
       expect(col.indexes).toEqual({
         byGroup: {
           foo: {
-            [item3.id]: item3
+            [item3.id]: item3,
           },
           bar: {
             [item1.id]: item1bis,
-            [item2.id]: item2
-          }
-        }
+            [item2.id]: item2,
+          },
+        },
       })
     })
   })
@@ -127,10 +127,10 @@ describe('Index', function () {
         byGroup: {
           foo: {
             [item1.id]: item1,
-            [item3.id]: item3
+            [item3.id]: item3,
           },
-          bar: {}
-        }
+          bar: {},
+        },
       })
     })
   })
@@ -139,7 +139,7 @@ describe('Index', function () {
     const item1bis = {
       id: item1.id,
       group: item1.group,
-      newProp: true
+      newProp: true,
     }
 
     col.update(item1bis)
@@ -149,12 +149,12 @@ describe('Index', function () {
         byGroup: {
           foo: {
             [item1.id]: item1bis,
-            [item3.id]: item3
+            [item3.id]: item3,
           },
           bar: {
-            [item2.id]: item2
-          }
-        }
+            [item2.id]: item2,
+          },
+        },
       })
     })
   })
@@ -170,9 +170,9 @@ describe('Index', function () {
           byGroup: {
             foo: {
               [item1.id]: item1,
-              [item3.id]: item3
-            }
-          }
+              [item3.id]: item3,
+            },
+          },
         })
       })
     })

packages/xo-collection/src/unique-index.js

@@ -5,7 +5,7 @@ import NotImplemented from './not-implemented'
 import {
   ACTION_ADD,
   ACTION_UPDATE,
-  ACTION_REMOVE
+  ACTION_REMOVE,
 } from './collection'
 
 // ===================================================================
@@ -66,7 +66,7 @@ export default class UniqueIndex {
     const {
       computeHash,
       _itemByHash: itemByHash,
-      _keysToHash: keysToHash
+      _keysToHash: keysToHash,
     } = this
 
     for (const key in items) {
@@ -85,7 +85,7 @@ export default class UniqueIndex {
     const {
       computeHash,
       _itemByHash: itemByHash,
-      _keysToHash: keysToHash
+      _keysToHash: keysToHash,
     } = this
 
     for (const key in items) {
@@ -110,7 +110,7 @@ export default class UniqueIndex {
   _onRemove (items) {
     const {
       _itemByHash: itemByHash,
-      _keysToHash: keysToHash
+      _keysToHash: keysToHash,
     } = this
 
     for (const key in items) {

packages/xo-collection/src/unique-index.spec.js

@@ -3,8 +3,8 @@
 import eventToPromise from 'event-to-promise'
 import { forEach } from 'lodash'
 
-import Collection from '..'
-import Index from '../unique-index'
+import Collection from './collection'
+import Index from './unique-index'
 
 // ===================================================================
 
@@ -29,14 +29,14 @@ describe('UniqueIndex', function () {
   let col, byKey
   const item1 = {
     id: '2ccb8a72-dc65-48e4-88fe-45ef541f2cba',
-    key: '036dee1b-9a3b-4fb5-be8a-4f535b355581'
+    key: '036dee1b-9a3b-4fb5-be8a-4f535b355581',
   }
   const item2 = {
     id: '7d21dc51-4da8-4538-a2e9-dd6f4784eb76',
-    key: '103cd893-d2cc-4d37-96fd-c259ad04c0d4'
+    key: '103cd893-d2cc-4d37-96fd-c259ad04c0d4',
   }
   const item3 = {
-    id: '668c1274-4442-44a6-b99a-512188e0bb09'
+    id: '668c1274-4442-44a6-b99a-512188e0bb09',
   }
 
   beforeEach(function () {
@@ -56,15 +56,15 @@ describe('UniqueIndex', function () {
     expect(col.indexes).toEqual({
       byKey: {
         [item1.key]: item1,
-        [item2.key]: item2
-      }
+        [item2.key]: item2,
+      },
     })
   })
 
   it('works with added items', function () {
     const item4 = {
       id: '823b56c4-4b96-4f3a-9533-5d08177167ac',
-      key: '1437af14-429a-40db-8a51-8a2f5ed03201'
+      key: '1437af14-429a-40db-8a51-8a2f5ed03201',
     }
 
     col.add(item4)
@@ -74,8 +74,8 @@ describe('UniqueIndex', function () {
         byKey: {
           [item1.key]: item1,
           [item2.key]: item2,
-          [item4.key]: item4
-        }
+          [item4.key]: item4,
+        },
       })
     })
   })
@@ -83,7 +83,7 @@ describe('UniqueIndex', function () {
   it('works with updated items', function () {
     const item1bis = {
       id: item1.id,
-      key: 'e03d4a3a-0331-4aca-97a2-016bbd43a29b'
+      key: 'e03d4a3a-0331-4aca-97a2-016bbd43a29b',
     }
 
     col.update(item1bis)
@@ -92,8 +92,8 @@ describe('UniqueIndex', function () {
       expect(col.indexes).toEqual({
         byKey: {
           [item1bis.key]: item1bis,
-          [item2.key]: item2
-        }
+          [item2.key]: item2,
+        },
       })
     })
   })
@@ -104,8 +104,8 @@ describe('UniqueIndex', function () {
     return waitTicks().then(() => {
       expect(col.indexes).toEqual({
         byKey: {
-          [item1.key]: item1
-        }
+          [item1.key]: item1,
+        },
       })
     })
   })
@@ -114,7 +114,7 @@ describe('UniqueIndex', function () {
     const item1bis = {
       id: item1.id,
       key: item1.key,
-      newProp: true
+      newProp: true,
     }
 
     col.update(item1bis)
@@ -123,8 +123,8 @@ describe('UniqueIndex', function () {
       expect(col.indexes).toEqual({
         byKey: {
           [item1.key]: item1bis,
-          [item2.key]: item2
-        }
+          [item2.key]: item2,
+        },
       })
     })
   })

packages/xo-collection/src/view.example.js

@@ -1,7 +1,7 @@
 import { forEach } from 'lodash'
 
-import Collection from '..'
-import View from '../view'
+import Collection from './collection'
+import View from './view'
 
 // ===================================================================
 
@@ -11,18 +11,18 @@ users.getKey = (user) => user.name
 
 // Inserts some data.
 users.add({
-  name: 'bob'
+  name: 'bob',
 })
 users.add({
   name: 'clara',
-  active: true
+  active: true,
 })
 users.add({
-  name: 'ophelia'
+  name: 'ophelia',
 })
 users.add({
   name: 'Steve',
-  active: true
+  active: true,
 })
 
 // -------------------------------------------------------------------
@@ -48,9 +48,9 @@ setTimeout(function () {
 
   users.set({
     name: 'ophelia',
-    active: true
+    active: true,
   })
   users.set({
-    name: 'Steve'
+    name: 'Steve',
   })
 }, 10)

packages/xo-collection/src/view.js

@@ -3,7 +3,7 @@ import { bind, forEach, iteratee as createCallback } from 'lodash'
 import Collection, {
   ACTION_ADD,
   ACTION_UPDATE,
-  ACTION_REMOVE
+  ACTION_REMOVE,
 } from './collection'
 
 // ===================================================================

packages/xo-collection/unique-index.js

@@ -1 +1 @@
-module.exports = require('./dist/unique-index')
+module.exports = require('./dist/unique-index') // eslint-disable-line node/no-missing-require

packages/xo-collection/view.js

@@ -1 +1 @@
-module.exports = require('./dist/view')
+module.exports = require('./dist/view') // eslint-disable-line node/no-missing-require

packages/xo-common/api-errors.js

@@ -1 +1 @@
-module.exports = require('./dist/api-errors')
+module.exports = require('./dist/api-errors') // eslint-disable-line node/no-missing-require

packages/xo-common/package.json

@@ -29,27 +29,21 @@
     "make-error": "^1.2.1"
   },
   "devDependencies": {
-    "babel-cli": "^6.18.0",
-    "babel-eslint": "^7.1.0",
-    "babel-plugin-lodash": "^3.2.9",
-    "babel-plugin-transform-runtime": "^6.15.0",
-    "babel-preset-env": "^1.0.0",
-    "babel-preset-stage-0": "^6.16.0",
-    "cross-env": "^3.1.3",
-    "dependency-check": "^2.6.0",
-    "rimraf": "^2.5.4",
-    "standard": "^8.5.0"
+    "babel-cli": "^6.24.1",
+    "babel-plugin-lodash": "^3.3.2",
+    "babel-plugin-transform-runtime": "^6.23.0",
+    "babel-preset-env": "^1.5.2",
+    "babel-preset-stage-3": "^6.24.1",
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.1"
   },
   "scripts": {
     "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
     "clean": "rimraf dist/",
-    "depcheck": "dependency-check ./package.json --entry api-errors.js",
     "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
-    "lint": "standard",
-    "posttest": "yarn run lint && yarn run depcheck",
     "prebuild": "yarn run clean",
-    "predev": "yarn run clean",
-    "prepublish": "yarn run build"
+    "predev": "yarn run prebuild",
+    "prepublishOnly": "yarn run build"
   },
   "babel": {
     "plugins": [
@@ -65,13 +59,7 @@
           }
         }
       ],
-      "stage-0"
+      "stage-3"
     ]
-  },
-  "standard": {
-    "ignore": [
-      "dist"
-    ],
-    "parser": "babel-eslint"
   }
 }

packages/xo-common/src/api-errors.js

@@ -12,7 +12,7 @@ class XoError extends BaseError {
     return {
       message: this.message,
       code: this.code,
-      data: this.data
+      data: this.data,
     }
   }
 }
@@ -28,44 +28,44 @@ const create = (code, getProps) => {
 // =============================================================================
 
 export const notImplemented = create(0, () => ({
-  message: 'not implemented'
+  message: 'not implemented',
 }))
 
 export const noSuchObject = create(1, (id, type) => ({
   data: { id, type },
-  message: 'no such object'
+  message: 'no such object',
 }))
 
 export const unauthorized = create(2, () => ({
-  message: 'not authenticated or not enough permissions'
+  message: 'not authenticated or not enough permissions',
 }))
 
 export const invalidCredentials = create(3, () => ({
-  message: 'invalid credentials'
+  message: 'invalid credentials',
 }))
 
 // Deprecated alreadyAuthenticated (4)
 
 export const forbiddenOperation = create(5, (operation, reason) => ({
   data: { operation, reason },
-  message: `forbidden operation: ${operation}`
+  message: `forbidden operation: ${operation}`,
 }))
 
 // Deprecated GenericError (6)
 
 export const noHostsAvailable = create(7, () => ({
-  message: 'no hosts available'
+  message: 'no hosts available',
 }))
 
 export const authenticationFailed = create(8, () => ({
-  message: 'authentication failed'
+  message: 'authentication failed',
 }))
 
 export const serverUnreachable = create(9, objectId => ({
   data: {
-    objectId
+    objectId,
   },
-  message: 'server unreachable'
+  message: 'server unreachable',
 }))
 
 export const invalidParameters = create(10, (message, errors) => {
@@ -76,22 +76,22 @@ export const invalidParameters = create(10, (message, errors) => {
 
   return {
     data: { errors },
-    message: message || 'invalid parameters'
+    message: message || 'invalid parameters',
   }
 })
 
 export const vmMissingPvDrivers = create(11, ({ vm }) => ({
   data: {
-    objectId: vm
+    objectId: vm,
   },
-  message: 'missing PV drivers'
+  message: 'missing PV drivers',
 }))
 
 export const vmIsTemplate = create(12, ({ vm }) => ({
   data: {
-    objectId: vm
+    objectId: vm,
   },
-  message: 'VM is a template'
+  message: 'VM is a template',
 }))
 
 // TODO: We should probably create a more generic error which gathers all incorrect state errors.
@@ -109,58 +109,58 @@ export const vmBadPowerState = create(13, ({ vm, expected, actual }) => ({
   data: {
     objectId: vm,
     expected,
-    actual
+    actual,
   },
-  message: `VM state is ${actual} but should be ${expected}`
+  message: `VM state is ${actual} but should be ${expected}`,
 }))
 
 export const vmLacksFeature = create(14, ({ vm, feature }) => ({
   data: {
     objectId: vm,
-    feature
+    feature,
   },
-  message: `VM lacks feature ${feature || ''}`
+  message: `VM lacks feature ${feature || ''}`,
 }))
 
 export const notSupportedDuringUpgrade = create(15, () => ({
-  message: 'not supported during upgrade'
+  message: 'not supported during upgrade',
 }))
 
 export const objectAlreadyExists = create(16, ({ objectId, objectType }) => ({
   data: {
     objectId,
-    objectType
+    objectType,
   },
-  message: `${objectType || 'object'} already exists`
+  message: `${objectType || 'object'} already exists`,
 }))
 
 export const vdiInUse = create(17, ({ vdi, operation }) => ({
   data: {
     objectId: vdi,
-    operation
+    operation,
   },
-  message: 'VDI in use'
+  message: 'VDI in use',
 }))
 
 export const hostOffline = create(18, ({ host }) => ({
   data: {
-    objectId: host
+    objectId: host,
   },
-  message: 'host offline'
+  message: 'host offline',
 }))
 
 export const operationBlocked = create(19, ({ objectId, code }) => ({
   data: {
     objectId,
-    code
+    code,
   },
-  message: 'operation blocked'
+  message: 'operation blocked',
 }))
 
 export const patchPrecheckFailed = create(20, ({ errorType, patch }) => ({
   data: {
     objectId: patch,
-    errorType
+    errorType,
   },
-  message: `patch precheck failed: ${errorType}`
+  message: `patch precheck failed: ${errorType}`,
 }))

packages/xo-lib/example.js

@@ -4,10 +4,10 @@ process.on('unhandledRejection', function (error) {
   console.log(error)
 })
 
-var Xo = require('./').default
+const Xo = require('./').default // eslint-disable-line node/no-missing-require
 
-var xo = new Xo({
-  url: 'localhost:9000'
+const xo = new Xo({
+  url: 'localhost:9000',
 })
 
 xo.open().then(function () {
@@ -19,7 +19,7 @@ xo.open().then(function () {
 }).then(function () {
   return xo.signIn({
     email: 'admin@admin.net',
-    password: 'admin'
+    password: 'admin',
   }).then(function () {
     console.log('connected as ', xo.user)
   }).catch(function (error) {
@@ -28,7 +28,7 @@ xo.open().then(function () {
 }).then(function () {
   return xo.signIn({
     email: 'tom',
-    password: 'tom'
+    password: 'tom',
   }).then(function () {
     console.log('connected as', xo.user)
 

packages/xo-lib/package.json

@@ -28,32 +28,24 @@
     "node": ">=4"
   },
   "dependencies": {
-    "jsonrpc-websocket-client": "^0.2.0",
+    "jsonrpc-websocket-client": "^0.3.0",
     "lodash": "^4.17.2",
     "make-error": "^1.0.4"
   },
   "devDependencies": {
     "babel-cli": "^6.24.1",
-    "babel-eslint": "^7.2.3",
-    "babel-plugin-lodash": "^3.2.11",
-    "babel-preset-env": "^1.5.1",
+    "babel-plugin-lodash": "^3.3.2",
+    "babel-preset-env": "^1.5.2",
     "babel-preset-stage-3": "^6.24.1",
-    "cross-env": "^5.0.0",
-    "dependency-check": "^2.8.0",
-    "jest": "^20.0.3",
-    "rimraf": "^2.6.1",
-    "standard": "^10.0.2"
+    "cross-env": "^5.1.3",
+    "rimraf": "^2.6.1"
   },
   "scripts": {
     "build": "cross-env NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
-    "commitmsg": "npm test",
     "dev": "cross-env NODE_ENV=development babel --watch --source-maps --out-dir=dist/ src/",
-    "dev-test": "jest --bail --watch",
-    "posttest": "standard && dependency-check ./package.json",
     "prebuild": "rimraf dist/",
-    "predev": "npm run prebuild",
-    "prepublish": "npm run build",
-    "test": "jest"
+    "predev": "yarn run prebuild",
+    "prepublishOnly": "yarn run build"
   },
   "babel": {
     "env": {
@@ -77,18 +69,5 @@
       ],
       "stage-3"
     ]
-  },
-  "jest": {
-    "testEnvironment": "node",
-    "roots": [
-      "<rootDir>/src"
-    ],
-    "testRegex": "\\.spec\\.js$"
-  },
-  "standard": {
-    "ignore": [
-      "dist"
-    ],
-    "parser": "babel-eslint"
   }
 }

packages/xo-lib/src/index.js

@@ -1,6 +1,6 @@
 import JsonRpcWebSocketClient, {
   OPEN,
-  CLOSED
+  CLOSED,
 } from 'jsonrpc-websocket-client'
 import { BaseError } from 'make-error'
 import { startsWith } from 'lodash'

packages/xo-remote-parser/package.json

@@ -27,27 +27,21 @@
     "lodash": "^4.13.1"
   },
   "devDependencies": {
-    "babel-cli": "^6.18.0",
-    "babel-eslint": "^7.1.1",
-    "babel-plugin-lodash": "^3.2.11",
-    "babel-preset-env": "^1.1.7",
-    "babel-preset-stage-3": "^6.17.0",
-    "cross-env": "^3.1.4",
+    "babel-cli": "^6.24.1",
+    "babel-plugin-lodash": "^3.3.2",
+    "babel-preset-env": "^1.5.2",
+    "babel-preset-stage-3": "^6.24.1",
+    "cross-env": "^5.1.3",
     "deep-freeze": "^0.0.1",
-    "dependency-check": "^2.7.0",
-    "jest": "^18.1.0",
-    "rimraf": "^2.5.4",
-    "standard": "^8.6.0"
+    "rimraf": "^2.6.1"
   },
   "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/",
-    "dev-test": "jest --bail --watch",
-    "posttest": "standard && dependency-check ./package.json",
     "prebuild": "rimraf dist/",
     "predev": "yarn run prebuild",
-    "prepublish": "yarn run build",
-    "test": "jest"
+    "prepare": "yarn run build",
+    "prepublishOnly": "yarn run build"
   },
   "babel": {
     "plugins": [
@@ -65,17 +59,5 @@
       ],
       "stage-3"
     ]
-  },
-  "jest": {
-    "testPathDirs": [
-      "<rootDir>/src"
-    ],
-    "testRegex": "\\.spec\\.js$"
-  },
-  "standard": {
-    "ignore": [
-      "dist"
-    ],
-    "parser": "babel-eslint"
   }
 }

packages/xo-remote-parser/src/index.spec.js

@@ -12,8 +12,8 @@ const data = deepFreeze({
     string: 'file:///var/lib/xoa/backup',
     object: {
       type: 'file',
-      path: '/var/lib/xoa/backup'
-    }
+      path: '/var/lib/xoa/backup',
+    },
   },
   SMB: {
     string: 'smb://Administrator:pas:sw@ord@toto\\\\192.168.100.225\\smb\0',
@@ -23,17 +23,17 @@ const data = deepFreeze({
       path: '',
       domain: 'toto',
       username: 'Administrator',
-      password: 'pas:sw@ord'
-    }
+      password: 'pas:sw@ord',
+    },
   },
   NFS: {
     string: 'nfs://192.168.100.225:/media/nfs',
     object: {
       type: 'nfs',
       host: '192.168.100.225',
-      path: '/media/nfs'
-    }
-  }
+      path: '/media/nfs',
+    },
+  },
 })
 
 const parseData = deepFreeze({
@@ -43,17 +43,17 @@ const parseData = deepFreeze({
     string: 'file://var/lib/xoa/backup',
     object: {
       type: 'file',
-      path: '/var/lib/xoa/backup'
-    }
+      path: '/var/lib/xoa/backup',
+    },
   },
   'nfs with missing leading slash': {
     string: 'nfs://192.168.100.225:media/nfs',
     object: {
       type: 'nfs',
       host: '192.168.100.225',
-      path: '/media/nfs'
-    }
-  }
+      path: '/media/nfs',
+    },
+  },
 })
 
 const formatData = deepFreeze({
@@ -63,9 +63,9 @@ const formatData = deepFreeze({
     string: 'file:///var/lib/xoa/backup',
     object: {
       type: 'local',
-      path: '/var/lib/xoa/backup'
-    }
-  }
+      path: '/var/lib/xoa/backup',
+    },
+  },
 })
 
 // -------------------------------------------------------------------

packages/xo-server-auth-github/.mocha.js

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

packages/xo-server-auth-github/.mocha.opts

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

packages/xo-server-auth-github/package.json

@@ -33,42 +33,28 @@
     "passport-github": "^1.1.0"
   },
   "devDependencies": {
-    "babel-cli": "^6.16.0",
-    "babel-eslint": "^7.0.0",
+    "babel-cli": "^6.24.1",
     "babel-plugin-transform-runtime": "^6.15.0",
-    "babel-preset-latest": "^6.16.0",
-    "babel-preset-stage-0": "^6.16.0",
-    "clarify": "^2.0.0",
-    "dependency-check": "^2.6.0",
-    "mocha": "^3.1.0",
-    "must": "^0.13.2",
-    "source-map-support": "^0.4.3",
-    "standard": "^8.2.0",
-    "trace": "^2.3.3"
+    "babel-preset-env": "^1.6.1"
   },
   "scripts": {
     "build": "NODE_ENV=production babel --source-maps --out-dir=dist/ src/",
-    "depcheck": "dependency-check ./package.json",
     "dev": "NODE_DEV=development babel --watch --source-maps --out-dir=dist/ src/",
-    "dev-test": "mocha --opts .mocha.opts --watch --reporter=min \"dist/**/*.spec.js\"",
-    "lint": "standard",
-    "posttest": "yarn run lint && yarn run depcheck",
-    "prepublish": "yarn run build",
-    "test": "mocha --opts .mocha.opts \"dist/**/*.spec.js\""
+    "prepublishOnly": "yarn run build"
   },
   "babel": {
     "plugins": [
       "transform-runtime"
     ],
     "presets": [
-      "latest",
-      "stage-0"
+      [
+        "env",
+        {
+          "targets": {
+            "node": 4
+          }
+        }
+      ]
     ]
-  },
-  "standard": {
-    "ignore": [
-      "dist"
-    ],
-    "parser": "babel-eslint"
   }
 }

packages/xo-server-auth-github/src/index.js

@@ -6,13 +6,13 @@ export const configurationSchema = {
   type: 'object',
   properties: {
     clientID: {
-      type: 'string'
+      type: 'string',
     },
     clientSecret: {
-      type: 'string'
-    }
+      type: 'string',
+    },
   },
-  required: ['clientID', 'clientSecret']
+  required: ['clientID', 'clientSecret'],
 }
 
 // ===================================================================

packages/xo-server-auth-github/src/index.spec.js

@@ -1,17 +0,0 @@
-/* eslint-env mocha */
-
-import expect from 'must'
-
-// ===================================================================
-
-import myLib from './'
-
-// ===================================================================
-
-describe.skip('myLib', () => {
-  it('does something', () => {
-    // TODO: some real tests.
-
-    expect(myLib).to.exists()
-  })
-})

packages/xo-server-auth-google/.npmignore

@@ -0,0 +1,24 @@
+/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__/

packages/xo-server-auth-google/README.md

@@ -0,0 +1,77 @@
+# xo-server-auth-google [![Build Status](https://travis-ci.org/vatesfr/xen-orchestra.png?branch=master)](https://travis-ci.org/vatesfr/xen-orchestra)
+
+> Google authentication plugin for XO-Server
+
+This plugin allows Google users to authenticate to Xen-Orchestra.
+
+The first time a user signs in, XO will create a new XO user with the
+same identifier.
+
+## Install
+
+Installation of the [npm package](https://npmjs.org/package/xo-server-auth-google):
+
+```
+> npm install --global xo-server-auth-google
+```
+
+## Usage
+
+> This plugin is based on [passport-google](https://google.com/jaredhanson/passport-google),
+> see [its documentation](https://google.com/jaredhanson/passport-google#configure-strategy)
+> for more information about the configuration.
+
+### Creating the Google project
+
+[Create a new project](https://console.developers.google.com/project):
+
+![](create-project.png)
+![](create-project-2.png)
+
+Enable the Google+ API:
+
+![](enable-google+-api.png)
+
+Add OAuth 2.0 credentials:
+
+![](add-oauth2-credentials.png)
+![](add-oauth2-credentials-2.png)
+
+### Add the plugin to XO-Server config
+
+Like all other xo-server plugins, it can be configured directly via
+the web iterface, see [the plugin documentation](https://xen-orchestra.com/docs/plugins.html).
+
+## Development
+
+```
+# Install dependencies
+> npm install
+
+# Run the tests
+> npm test
+
+# Continuously compile
+> npm run dev
+
+# Continuously run the tests
+> npm run dev-test
+
+# Build for production (automatically called by npm install)
+> npm run build
+```
+
+## 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
+
+AGPL3 © [Vates SAS](http://vates.fr)