Browse Source

joyent/node-triton#173 Add support for listing and getting triton nfs volumes

joyent/node-triton#174 Add support for creating triton nfs volumes
joyent/node-triton#175 Add support for deleting triton NFS volumes
Reviewed by: Trent Mick <trentm@gmail.com>
Approved by: Trent Mick <trentm@gmail.com>
tags/5.3.0
Julien Gilli 3 years ago
parent
commit
dc1b6c75b7
24 changed files with 1893 additions and 72 deletions
  1. +13
    -1
      CHANGES.md
  2. +6
    -0
      etc/triton-bash-completion-types.sh
  3. +18
    -0
      lib/cli.js
  4. +147
    -0
      lib/cloudapi2.js
  5. +153
    -52
      lib/common.js
  6. +5
    -1
      lib/do_image/do_list.js
  7. +5
    -1
      lib/do_instance/do_list.js
  8. +5
    -1
      lib/do_network/do_list.js
  9. +5
    -1
      lib/do_package/do_list.js
  10. +200
    -0
      lib/do_volume/do_create.js
  11. +157
    -0
      lib/do_volume/do_delete.js
  12. +79
    -0
      lib/do_volume/do_get.js
  13. +151
    -0
      lib/do_volume/do_list.js
  14. +53
    -0
      lib/do_volume/index.js
  15. +30
    -0
      lib/do_volumes.js
  16. +272
    -7
      lib/tritonapi.js
  17. +68
    -0
      lib/volumes.js
  18. +3
    -2
      package.json
  19. +6
    -1
      test/integration/cli-subcommands.test.js
  20. +103
    -0
      test/integration/cli-volumes-size.test.js
  21. +251
    -0
      test/integration/cli-volumes.test.js
  22. +11
    -1
      test/integration/helpers.js
  23. +60
    -4
      test/unit/common.test.js
  24. +92
    -0
      test/unit/parseVolumeSize.test.js

+ 13
- 1
CHANGES.md View File

@@ -7,7 +7,19 @@ Known issues:

## not yet released

(nothing yet)
- [joyent/node-triton#173], [joyent/node-triton#174] and
[joyent/node-triton#175] Add support for creating and managing NFS shared
volumes. New `triton volume` commands are available:

* `triton volume create` to create NFS shared volumes
* `triton volume list` to list existing volumes
* `triton volume get` to get information about a given volume
* `triton volume delete` to delete one or more volumes

Use `triton volume --help` to get help on all of these commands.

Note that these commands are hidden for now. They will be made visible by
default once the server-side support for volumes is shipped in Triton.

## 5.2.1


+ 6
- 0
etc/triton-bash-completion-types.sh View File

@@ -133,6 +133,12 @@ function complete_tritonnetwork {
compgen $compgen_opts -W "$candidates" -- "$word"
}

function complete_tritonvolume {
local word="$1"
candidates=$(_complete_tritondata volumes)
compgen $compgen_opts -W "$candidates" -- "$word"
}

function complete_tritonfwrule {
local word="$1"
candidates=$(_complete_tritondata fwrules)

+ 18
- 0
lib/cli.js View File

@@ -463,6 +463,21 @@ CLI.prototype._emitCompletions = function _emitCompletions(type, cb) {
next();
});
break;
case 'volumes':
tritonapi.cloudapi.listVolumes({}, function (err, vols) {
if (err) {
next(err);
return;
}
completions = [];
vols.forEach(function (vol) {
completions.push(vol.name);
completions.push(vol.id);
});
arg.completions = completions.join('\n') + '\n';
next();
});
break;
case 'affinityrules':
/*
* We exclude ids, in favour of just inst names here. The only
@@ -695,6 +710,9 @@ CLI.prototype.do_cloudapi = require('./do_cloudapi');
CLI.prototype.do_badger = require('./do_badger');
CLI.prototype.do_rbac = require('./do_rbac');

// Volumes
CLI.prototype.do_volumes = require('./do_volumes');
CLI.prototype.do_volume = require('./do_volume');


//---- mainline

+ 147
- 0
lib/cloudapi2.js View File

@@ -2300,7 +2300,154 @@ CloudApi.prototype.setRoleTags = function setRoleTags(opts, cb) {
});
};

/**
* Get a volume by id.
*
* @param {Object} opts
* - id {UUID} Required. The volume id.
* @param {Function} cb of the form `function (err, volume, res)`
*/
CloudApi.prototype.getVolume = function getVolume(opts, cb) {
assert.object(opts, 'opts');
assert.uuid(opts.id, 'opts.id');

var endpoint = format('/%s/volumes/%s', this.account, opts.id);
this._passThrough(endpoint, cb);
};

/**
* List the account's volumes.
*
* @param {Object} options
* @param {Function} callback - called like `function (err, volumes)`
*/
CloudApi.prototype.listVolumes = function listVolumes(options, cb) {
var endpoint = format('/%s/volumes', this.account);
this._passThrough(endpoint, options, cb);
};

/**
* Create a volume for the account.
*
* @param {Object} options
* - name {String} Optional: the name of the volume to be created
* - size {Number} Optional: a number representing the size of the volume
* to be created in mebibytes.
* - networks {Array} Optional: an array that contains the uuids of all the
* networks that should be reachable from the newly created volume
* - type {String}: the type of the volume. Currently, only "tritonnfs" is
* supported.
* @param {Function} callback - called like `function (err, volume, res)`
*/
CloudApi.prototype.createVolume = function createVolume(options, cb) {
assert.object(options, 'options');
assert.optionalString(options.name, 'options.name');
assert.optionalNumber(options.size, 'options.size');
assert.optionalArrayOfUuid(options.networks, 'options.networks');
assert.string(options.type, 'options.type');
assert.func(cb, 'cb');

this._request({
method: 'POST',
path: format('/%s/volumes', this.account),
data: {
name: options.name,
size: options.size,
networks: (options.networks ? options.networks : undefined),
type: options.type
}
}, function (err, req, res, body) {
cb(err, body, res);
});
};

/**
* Delete an account's volume.
*
* @param {String} volumeUuid
* @param {Function} callback - called like `function (err, volume, res)`
*/
CloudApi.prototype.deleteVolume = function deleteVolume(volumeUuid, cb) {
assert.uuid(volumeUuid, 'volumeUuid');
assert.func(cb, 'cb');

this._request({
method: 'DELETE',
path: format('/%s/volumes/%s', this.account, volumeUuid)
}, function (err, req, res, body) {
cb(err, res);
});
};


/**
* Wait for a volume to go one of a set of specfic states.
*
* @param {Object} options
* - {String} id - machine UUID
* - {Array of String} states - desired state
* - {Number} interval (optional) - time in ms to poll
* - {Number} timeout (optional) - time in ms after which "callback" is
* called with an error object if the volume hasn't yet transitioned to
* one of the states in "opts.states".
* @param {Function} callback - called when state is reached or on error
*/
CloudApi.prototype.waitForVolumeStates =
function waitForVolumeStates(opts, callback) {
var self = this;
assert.object(opts, 'opts');
assert.uuid(opts.id, 'opts.id');
assert.arrayOfString(opts.states, 'opts.states');
assert.optionalNumber(opts.interval, 'opts.interval');
assert.optionalNumber(opts.timeout, 'opts.timeout');
assert.func(callback, 'callback');

var interval = (opts.interval === undefined ? 1000 : opts.interval);
if (opts.timeout !== undefined) {
interval = Math.min(interval, opts.timeout);
}
assert.ok(interval > 0, 'interval must be a positive number');

var startTime = process.hrtime();
var timeout = opts.timeout;

poll();

function poll() {
self.getVolume({
id: opts.id
}, function (err, vol, res) {
var elapsedTime;
var timedOut = false;

if (err) {
callback(err, null, res);
return;
}
if (opts.states.indexOf(vol.state) !== -1) {
callback(null, vol, res);
return;
} else {
if (timeout !== undefined) {
elapsedTime = common.monotonicTimeDiffMs(startTime);
if (elapsedTime > timeout) {
timedOut = true;
}
}

if (timedOut) {
callback(new errors.TimeoutError(format('timeout waiting '
+ 'for state changes on volume %s (elapsed %ds)',
opts.id, Math.round(elapsedTime / 1000))));
return;
} else {
setTimeout(poll, interval);
return;
}
}
});
}
};

// --- Exports


+ 153
- 52
lib/common.js View File

@@ -126,34 +126,125 @@ function jsonStream(arr, stream) {
}

/**
* given an array of key=value pairs, break them into an object
* Parses the string "kv" of the form 'key=value' and returns an object that
* represents it with the form {'key': value}. If "key"" in the "kv" string is
* not included in the list "validKeys", it throws an error. It also throws an
* error if the string "kv" is malformed.
*
* @param {Array} kvs - an array of key=value pairs
* @param {Array} valid (optional) - an array to validate pairs
* By default, converts the values as if they were JSON representations of JS
* types, e.g the string 'false' is converted to the boolean primitive "false".
*
* @param {String} kv
* @param {String[]} validKeys: Optional
* @param {Object} options: Optional
* - @param disableTypeConversions {Boolean} Optional. If true, then no
* type conversion of values is performed, and all values are returned as
* strings.
* - @param typeHintFromKey {Object} Optional. Type hints for input keys.
* E.g. if parsing 'foo=false' and `typeHintFromKey={foo: 'string'}`,
* then we do NOT parse it to a boolean `false`.
* - @param failOnEmptyValue {Boolean} Optional - If true, throws an error
* if a given key's value is the empty string. Default is false.
*/
function _parseKeyValue(kv, validKeys, options) {
assert.string(kv, 'kv');
assert.optionalArrayOfString(validKeys, 'validKeys');
assert.optionalObject(options, 'options');
options = options || {};
assert.optionalBool(options.disableTypeConversions,
'options.disableTypeConversions');
assert.optionalObject(options.typeHintFromKey, 'options.typeHintFromKey');
assert.optionalBool(options.failOnEmptyValue, 'options.failOnEmptyValue');

var idx = kv.indexOf('=');
if (idx === -1) {
throw new errors.UsageError(format('invalid key=value: "%s"', kv));
}
var k = kv.slice(0, idx);
var typeHint;
var v = kv.slice(idx + 1);

if (validKeys && validKeys.indexOf(k) === -1) {
throw new errors.UsageError(format(
'invalid key: "%s" (must be one of "%s")',
k, validKeys.join('", "')));
}

if (v === '' && options.failOnEmptyValue) {
throw new Error(format('key "%s" must have a value', k));
}

if (options.disableTypeConversions !== true) {
if (options.typeHintFromKey !== undefined) {
typeHint = options.typeHintFromKey[k];
}

if (typeHint === 'string') {
// Leave `v` a string.
/* jsl:pass */
} else if (v === '') {
v = null;
} else {
try {
v = JSON.parse(v);
} catch (e) {
/* pass */
}
}
}

return {
key: k,
value: v
};
}


/**
* given an array of key=value pairs, break them into a JSON predicate
*
* TODO: merge this with objFromKeyValueArgs !
* @param {Array} kvs - an array of key=value pairs
* @param {Object[]} validKeys - an array of objects representing valid keys
* that can be used in the first argument "kvs".
* @param {String} compositionType - the way each key/value pair will be
* combined to form a JSON predicate. Valid values are 'or' and 'and'.
*/
function kvToObj(kvs, valid) {
function jsonPredFromKv(kvs, validKeys, compositionType) {
assert.arrayOfString(kvs, 'kvs');
assert.optionalArrayOfString(valid, 'valid');

var o = {};
for (var i = 0; i < kvs.length; i++) {
var kv = kvs[i];
var idx = kv.indexOf('=');
if (idx === -1)
throw new errors.UsageError(format(
'invalid filter: "%s" (must be of the form "field=value")',
kv));
var k = kv.slice(0, idx);
var v = kv.slice(idx + 1);
if (valid && valid.indexOf(k) === -1)
throw new errors.UsageError(format(
'invalid filter name: "%s" (must be one of "%s")',
k, valid.join('", "')));
o[k] = v;
assert.arrayOfString(validKeys, 'validKeys');
assert.string(compositionType, 'string');
assert.ok(compositionType === 'or' || compositionType === 'and',
'compositionType');

var keyName;
var predicate = {};
var parsedKeyValue;
var parsedKeyValues;
var parseOpts = {
disableDotted: true,
validKeys: validKeys,
failOnEmptyValue: true
};

if (kvs.length === 0) {
return predicate;
}

if (kvs.length === 1) {
parsedKeyValue = _parseKeyValue(kvs[0], validKeys, parseOpts);
predicate.eq = [parsedKeyValue.key, parsedKeyValue.value];
} else {
predicate[compositionType] = [];
parsedKeyValues = objFromKeyValueArgs(kvs, parseOpts);

for (keyName in parsedKeyValues) {
predicate[compositionType].push({
eq: [keyName, parsedKeyValues[keyName]]
});
}
}
return o;

return predicate;
}

/**
@@ -1034,6 +1125,10 @@ function tildeSync(s) {
* - @param typeHintFromKey {Object} Optional. Type hints for input keys.
* E.g. if parsing 'foo=false' and `typeHintFromKey={foo: 'string'}`,
* then we do NOT parse it to a boolean `false`.
* - @param validKeys {String[]} Optional. List of valid keys. By default
* all keys are valid.
* - @param failOnEmptyValue {Boolean} Optional. If true, then a key with a
* value that is the empty string throws an error. Default is false.
*/
function objFromKeyValueArgs(args, opts)
{
@@ -1041,45 +1136,31 @@ function objFromKeyValueArgs(args, opts)
assert.optionalObject(opts, 'opts');
opts = opts || {};
assert.optionalBool(opts.disableDotted, 'opts.disableDotted');
assert.optionalBool(opts.disableTypeConversions,
'opts.disableTypeConversions');
assert.optionalObject(opts.typeHintFromKey, opts.typeHintFromKey);
var typeHintFromKey = opts.typeHintFromKey || {};
assert.optionalArrayOfString(opts.validKeys, 'opts.validKeys');
assert.optionalBool(opts.failOnEmptyValue, 'opts.failOnEmptyValue');

var obj = {};
args.forEach(function (arg) {
var kv = strsplit(arg, '=', 2);
if (kv.length < 2) {
throw new TypeError(format('invalid key=value argument: "%s"',
arg));
}

var k = kv[0];
var t = typeHintFromKey[k];

var v = kv[1];
if (t === 'string') {
// Leave `v` a string.
/* jsl:pass */
} else if (v === '') {
v = null;
} else {
try {
v = JSON.parse(v);
} catch (e) {
/* pass */
}
}
var parsedKeyValue = _parseKeyValue(arg, opts.validKeys, {
typeHintFromKey: opts.typeHintFromKey,
disableTypeConversions: opts.disableTypeConversions,
failOnEmptyValue: opts.failOnEmptyValue
});

if (opts.disableDotted) {
obj[k] = v;
obj[parsedKeyValue.key] = parsedKeyValue.value;
} else {
var dotted = strsplit(k, '.', 2);
var dotted = strsplit(parsedKeyValue.key, '.', 2);
if (dotted.length > 1) {
if (!obj[dotted[0]]) {
obj[dotted[0]] = {};
}
obj[dotted[0]][dotted[1]] = v;
obj[dotted[0]][dotted[1]] = parsedKeyValue.value;
} else {
obj[k] = v;
obj[parsedKeyValue.key] = parsedKeyValue.value;
}
}
});
@@ -1087,6 +1168,25 @@ function objFromKeyValueArgs(args, opts)
return obj;
}

/**
* Returns the time difference between the current time and the time
* represented by "relativeTo" in milliseconds. It doesn't use the built-in
* `Date` class internally, and instead uses a node facility that uses a
* monotonic clock. Thus, the time difference computed is not subject to time
* drifting due to e.g changes in the wall clock system time.
*
* @param {arrayOfNumber} relativeTo: an array representing the starting time as
* returned by `process.hrtime()` from which to compute the
* time difference.
*/
function monotonicTimeDiffMs(relativeTo) {
assert.arrayOfNumber(relativeTo, 'relativeTo');

var diff = process.hrtime(relativeTo);
var ms = (diff[0] * 1e3) + (diff[1] / 1e6); // in milliseconds
return ms;
}


/*
* Parse the given line into an argument vector, e.g. for use in sending to
@@ -1200,7 +1300,6 @@ module.exports = {
zeroPad: zeroPad,
boolFromString: boolFromString,
jsonStream: jsonStream,
kvToObj: kvToObj,
longAgo: longAgo,
isUUID: isUUID,
humanDurationFromMs: humanDurationFromMs,
@@ -1226,6 +1325,8 @@ module.exports = {
deepEqual: deepEqual,
tildeSync: tildeSync,
objFromKeyValueArgs: objFromKeyValueArgs,
argvFromLine: argvFromLine
argvFromLine: argvFromLine,
jsonPredFromKv: jsonPredFromKv,
monotonicTimeDiffMs: monotonicTimeDiffMs
};
// vim: set softtabstop=4 shiftwidth=4:

+ 5
- 1
lib/do_image/do_list.js View File

@@ -54,7 +54,11 @@ function do_list(subcmd, opts, args, callback) {

var listOpts;
try {
listOpts = common.kvToObj(args, validFilters);
listOpts = common.objFromKeyValueArgs(args, {
disableDotted: true,
validKeys: validFilters,
disableTypeConversions: true
});
} catch (e) {
callback(e);
return;

+ 5
- 1
lib/do_instance/do_list.js View File

@@ -61,7 +61,11 @@ function do_list(subcmd, opts, args, callback) {

var listOpts;
try {
listOpts = common.kvToObj(args, validFilters);
listOpts = common.objFromKeyValueArgs(args, {
disableDotted: true,
validKeys: validFilters,
disableTypeConversions: true
});
} catch (e) {
callback(e);
return;

+ 5
- 1
lib/do_network/do_list.js View File

@@ -48,7 +48,11 @@ function do_list(subcmd, opts, args, callback) {
var sort = opts.s.split(',');
var filters;
try {
filters = common.kvToObj(args, validFilters);
filters = common.objFromKeyValueArgs(args, {
disableDotted: true,
validKeys: validFilters,
disableTypeConversions: true
});
} catch (e) {
callback(e);
return;

+ 5
- 1
lib/do_package/do_list.js View File

@@ -63,7 +63,11 @@ function do_list(subcmd, opts, args, callback) {

var listOpts;
try {
listOpts = common.kvToObj(args, validFilters);
listOpts = common.objFromKeyValueArgs(args, {
disableDotted: true,
validKeys: validFilters,
disableTypeConversions: true
});
} catch (e) {
callback(e);
return;

+ 200
- 0
lib/do_volume/do_create.js View File

@@ -0,0 +1,200 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

/*
* Copyright 2017 Joyent, Inc.
*
* `triton volume create ...`
*/

var assert = require('assert-plus');
var format = require('util').format;
var vasync = require('vasync');

var common = require('../common');
var distractions = require('../distractions');
var errors = require('../errors');
var mod_volumes = require('../volumes');

function do_create(subcmd, opts, args, cb) {
var self = this;

if (opts.help) {
this.do_help('help', {}, [subcmd], cb);
return;
}

if (args.length !== 0) {
cb(new errors.UsageError('incorrect number of args'));
return;
}

vasync.pipeline({arg: {cli: this.top}, funcs: [
function validateVolumeSize(ctx, next) {
if (opts.size === undefined) {
next();
return;
}

try {
ctx.size = mod_volumes.parseVolumeSize(opts.size);
} catch (parseSizeErr) {
next(parseSizeErr);
return;
}

next();
},
common.cliSetupTritonApi,
function createVolume(ctx, next) {
var createVolumeParams = {
type: 'tritonnfs',
name: opts.name,
network: opts.network,
size: ctx.size
};

if (opts.type) {
createVolumeParams.type = opts.type;
}

self.top.tritonapi.createVolume(createVolumeParams,
function onRes(volCreateErr, volume) {
if (!volCreateErr && !opts.json) {
console.log('Creating volume %s (%s)', volume.name,
volume.id);
}
ctx.volume = volume;
next(volCreateErr);
});
},
function maybeWait(ctx, next) {
var distraction;
var waitTimeout = opts.wait_timeout === undefined ?
undefined : opts.wait_timeout * 1000;

if (!opts.wait) {
next();
return;
}

if (process.stderr.isTTY && opts.wait.length > 1) {
distraction = distractions.createDistraction(opts.wait.length);
}

self.top.tritonapi.cloudapi.waitForVolumeStates({
id: ctx.volume.id,
states: ['ready', 'failed'],
timeout: waitTimeout
}, function onWaitDone(waitErr, volume) {
if (distraction) {
distraction.destroy();
}

if (waitErr) {
next(waitErr);
return;
}

assert.object(volume, 'volume');

if (opts.json) {
console.log(JSON.stringify(volume));
} else if (volume.state === 'ready') {
console.log('Created volume %s (%s)', volume.name,
volume.id);
} else {
next(new Error(format('failed to create volume %s (%s)',
volume.name, volume.id)));
return;
}

next();
});
}
]}, cb);
}

do_create.options = [
{
names: ['help', 'h'],
type: 'bool',
help: 'Show this help.'
},
{
group: 'Create options'
},
{
names: ['name', 'n'],
helpArg: 'NAME',
type: 'string',
help: 'Volume name. If not given, one will be generated server-side.'
},
{
names: ['type', 't'],
helpArg: 'TYPE',
type: 'string',
help: 'Volume type. Default and currently only supported type is ' +
'"tritonnfs".'
},
{
names: ['size', 's'],
type: 'string',
helpArg: 'SIZE',
help: 'The size of the volume to create, in the form ' +
'`<integer><unit>`, e.g. `20G`. <integer> must be > 0. Supported ' +
'units are `G` or `g` for gibibytes and `M` or `m` for mebibytes.' +
' If a size is not specified, the newly created volume will have ' +
'a default size corresponding to the smallest size available.',
completionType: 'tritonvolumesize'
},
{
names: ['network', 'N'],
type: 'string',
helpArg: 'NETWORK',
help: 'A network (ID, name or short id) to which the newly created ' +
'volume will be attached. By default, the newly created volume ' +
'will be attached to the account\'s default fabric network.',
completionType: 'tritonnetwork'
},
{
group: 'Other options'
},
{
names: ['json', 'j'],
type: 'bool',
help: 'JSON stream output.'
},
{
names: ['wait', 'w'],
type: 'arrayOfBool',
help: 'Wait for the creation to complete. Use multiple times for a ' +
'spinner.'
},
{
names: ['wait-timeout'],
type: 'positiveInteger',
help: 'The number of seconds to wait before timing out with an error.'
}
];

do_create.synopses = ['{{name}} {{cmd}} [OPTIONS]'];

do_create.help = [
/* BEGIN JSSTYLED */
'Create a volume.',
'',
'{{usage}}',
'',
'{{options}}',
'Note: Currently this dumps prettified JSON by default. That might change',
'in the future. Use "-j" to explicitly get JSON output.'
/* END JSSTYLED */
].join('\n');

do_create.completionArgtypes = ['tritonvolume', 'none'];

module.exports = do_create;

+ 157
- 0
lib/do_volume/do_delete.js View File

@@ -0,0 +1,157 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

/*
* Copyright 2017 Joyent, Inc.
*
* `triton volume delete ...`
*/

var assert = require('assert-plus');
var format = require('util').format;
var vasync = require('vasync');

var common = require('../common');
var distractions = require('../distractions');
var errors = require('../errors');


function do_delete(subcmd, opts, args, cb) {
var self = this;

if (opts.help) {
self.do_help('help', {}, [subcmd], cb);
return;
} else if (args.length < 1) {
cb(new errors.UsageError('missing VOLUME arg(s)'));
return;
}

var context = {
volumeIds: args,
cli: this.top
};

vasync.pipeline({arg: context, funcs: [
common.cliSetupTritonApi,
function confirm(ctx, next) {
var promptMsg;

if (opts.yes) {
next();
return;
}

if (ctx.volumeIds.length === 1) {
promptMsg = format('Delete volume %s? [y/n] ',
ctx.volumeIds[0]);
} else {
promptMsg = format('Delete %d volumes? [y/n] ',
ctx.volumeIds.length);
}

common.promptYesNo({msg: promptMsg},
function onPromptAnswered(answer) {
if (answer !== 'y') {
console.error('Aborting');
/*
* Early abort signal.
*/
next(true);
} else {
next();
}
});
},
function deleteVolumes(ctx, next) {
vasync.forEachParallel({
func: function doDeleteVolume(volumeId, done) {
if (opts.wait === undefined) {
console.log('Deleting volume %s', volumeId);
}

self.top.tritonapi.deleteVolume({
id: volumeId,
wait: opts.wait && opts.wait.length > 0,
waitTimeout: opts.wait_timeout * 1000
}, function onVolDeleted(volDelErr) {
if (!volDelErr) {
if (opts.wait !== undefined) {
console.log('Deleted volume %s', volumeId);
}
} else {
console.error('Error when deleting volume %s: %s',
volumeId, volDelErr);
}

done(volDelErr);
});
},
inputs: ctx.volumeIds
}, next);
}
]}, function onDone(err) {
if (err === true) {
/*
* Answered 'no' to confirmation to delete.
*/
err = null;
}

if (err) {
cb(err);
return;
}

cb();
});
}

do_delete.options = [
{
names: ['help', 'h'],
type: 'bool',
help: 'Show this help.'
},
{
group: 'Other options'
},
{
names: ['wait', 'w'],
type: 'arrayOfBool',
help: 'Wait for the deletion to complete. Use multiple times for a ' +
'spinner.'
},
{
names: ['wait-timeout'],
type: 'positiveInteger',
default: 120,
help: 'The number of seconds to wait before timing out with an error. '
+ 'The default is 120 seconds.'
},
{
names: ['yes', 'y'],
type: 'bool',
help: 'Answer yes to confirmation to delete.'
}
];

do_delete.synopses = ['{{name}} {{cmd}} [OPTIONS] VOLUME [VOLUME ...]'];

do_delete.help = [
'Deletes a volume.',
'',
'{{usage}}',
'',
'{{options}}',
'',
'Where VOLUME is a volume id (full UUID), exact name, or short id.'
].join('\n');

do_delete.completionArgtypes = ['tritonvolume'];
do_delete.aliases = ['rm'];

module.exports = do_delete;

+ 79
- 0
lib/do_volume/do_get.js View File

@@ -0,0 +1,79 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

/*
* Copyright 2017 Joyent, Inc.
*
* `triton volume get ...`
*/

var format = require('util').format;

var common = require('../common');
var errors = require('../errors');

function do_get(subcmd, opts, args, callback) {
if (opts.help) {
this.do_help('help', {}, [subcmd], callback);
return;
} else if (args.length !== 1) {
return callback(new errors.UsageError(format(
'incorrect number of args (%d)', args.length)));
}

var tritonapi = this.top.tritonapi;
common.cliSetupTritonApi({cli: this.top}, function onSetup(setupErr) {
if (setupErr) {
callback(setupErr);
}
tritonapi.getVolume(args[0], function onRes(err, volume) {
if (err) {
return callback(err);
}

if (opts.json) {
console.log(JSON.stringify(volume));
} else {
console.log(JSON.stringify(volume, null, 4));
}
callback();
});
});
}

do_get.options = [
{
names: ['help', 'h'],
type: 'bool',
help: 'Show this help.'
},
{
names: ['json', 'j'],
type: 'bool',
help: 'JSON stream output.'
}
];

do_get.synopses = ['{{name}} {{cmd}} [OPTIONS] VOLUME'];

do_get.help = [
/* BEGIN JSSTYLED */
'Get a volume.',
'',
'{{usage}}',
'',
'{{options}}',
'',
'Where VOLUME is a volume id (full UUID), exact name, or short id.',
'',
'Note: Currently this dumps prettified JSON by default. That might change',
'in the future. Use "-j" to explicitly get JSON output.'
/* END JSSTYLED */
].join('\n');

do_get.completionArgtypes = ['tritonvolume', 'none'];

module.exports = do_get;

+ 151
- 0
lib/do_volume/do_list.js View File

@@ -0,0 +1,151 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

/*
* Copyright 2017 Joyent, Inc.
*
* `triton volume list ...`
*/

var assert = require('assert-plus');
var format = require('util').format;
var jsprim = require('jsprim');
var tabula = require('tabula');
var VError = require('verror');

var common = require('../common');
var errors = require('../errors');

var validFilters = [
'name',
'size',
'state',
'owner',
'type'
];

// columns default without -o
var columnsDefault = 'shortid,name,size,type,state,age';

// columns default with -l
var columnsDefaultLong = 'id,name,size,type,state,created';

// sort default with -s
var sortDefault = 'created';

function do_list(subcmd, opts, args, callback) {
var self = this;

if (opts.help) {
this.do_help('help', {}, [subcmd], callback);
return;
}

var columns = columnsDefault;
if (opts.o) {
columns = opts.o;
} else if (opts.long) {
columns = columnsDefaultLong;
}
columns = columns.split(',');

var sort = opts.s.split(',');

var filterPredicate;
var listOpts;

if (args) {
try {
filterPredicate = common.jsonPredFromKv(args, validFilters, 'and');
} catch (e) {
callback(new VError(e, 'invalid filters'));
return;
}
}

if (jsprim.deepEqual(filterPredicate, {})) {
filterPredicate = { ne: ['state', 'failed'] };
}

if (filterPredicate) {
listOpts = {
predicate: JSON.stringify(filterPredicate)
};
}

common.cliSetupTritonApi({cli: this.top}, function onSetup(setupErr) {
if (setupErr) {
callback(setupErr);
}
self.top.tritonapi.cloudapi.listVolumes(listOpts,
function onRes(listVolsErr, volumes, res) {
var now;

if (listVolsErr) {
return callback(listVolsErr);
}

if (opts.json) {
common.jsonStream(volumes);
} else {
now = new Date();
for (var i = 0; i < volumes.length; i++) {
var created;
var volume = volumes[i];

created = new Date(volume.create_timestamp);

volume.shortid = volume.id.split('-', 1)[0];
volume.created = volume.create_timestamp;
volume.age = common.longAgo(created, now);
}

tabula(volumes, {
skipHeader: opts.H,
columns: columns,
sort: sort
});
}
callback();
});
});
}

do_list.options = [
{
names: ['help', 'h'],
type: 'bool',
help: 'Show this help.'
}
].concat(common.getCliTableOptions({
includeLong: true,
sortDefault: sortDefault
}));

do_list.synopses = ['{{name}} {{cmd}} [OPTIONS] [FILTERS]'];

do_list.help = [
/* BEGIN JSSTYLED */
'List volumes.',
,
'{{usage}}',
'',
'{{options}}',
'Filters:',
' FIELD=VALUE Equality filter. Supported fields: name, type,',
' size, and state',
'',
'Fields (most are self explanatory, "*" indicates a field added client-side',
'for convenience):',
' shortid* A short ID prefix.',
' age* Approximate time since created, e.g. 1y, 2w.',
''
/* END JSSTYLED */
].join('\n');

do_list.aliases = ['ls'];

module.exports = do_list;

+ 53
- 0
lib/do_volume/index.js View File

@@ -0,0 +1,53 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

/*
* Copyright 2017 Joyent, Inc.
*
* `triton volume ...`
*/

var Cmdln = require('cmdln').Cmdln;
var util = require('util');

function VolumeCLI(top) {
this.top = top;
Cmdln.call(this, {
name: top.name + ' volume',
/* BEGIN JSSTYLED */
desc: [
'List and manage Triton volumes.'
].join('\n'),
/* END JSSTYLED */
helpOpts: {
minHelpCol: 24 /* line up with option help */
},
helpSubcmds: [
'help',
'list',
'get',
'create',
'delete'
]
});
}
util.inherits(VolumeCLI, Cmdln);

VolumeCLI.prototype.init = function init(opts, args, cb) {
this.log = this.top.log;
Cmdln.prototype.init.apply(this, arguments);
};

VolumeCLI.prototype.do_list = require('./do_list');
VolumeCLI.prototype.do_get = require('./do_get');
VolumeCLI.prototype.do_create = require('./do_create');
VolumeCLI.prototype.do_delete = require('./do_delete');

VolumeCLI.aliases = ['vol'];

VolumeCLI.hidden = true;

module.exports = VolumeCLI;

+ 30
- 0
lib/do_volumes.js View File

@@ -0,0 +1,30 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

/*
* Copyright 20167 Joyent, Inc.
*
* `triton volumes ...` bwcompat shortcut for `triton volumes list ...`.
*/

var targ = require('./do_volume/do_list');

function do_volumes(subcmd, opts, args, callback) {
this.handlerFromSubcmd('volume').dispatch({
subcmd: 'list',
opts: opts,
args: args
}, callback);
}

do_volumes.help = 'A shortcut for "triton volumes list".\n' + targ.help;
do_volumes.aliases = ['vols'];
do_volumes.hidden = true;
do_volumes.options = targ.options;
do_volumes.completionArgtypes = targ.completionArgtypes;
do_volumes.synopses = targ.synopses;

module.exports = do_volumes;

+ 272
- 7
lib/tritonapi.js View File

@@ -5,7 +5,7 @@
*/

/*
* Copyright 2016 Joyent, Inc.
* Copyright 2017 Joyent, Inc.
*/

/* BEGIN JSSTYLED */
@@ -113,6 +113,7 @@ var auth = require('smartdc-auth');
var EventEmitter = require('events').EventEmitter;
var fs = require('fs');
var format = require('util').format;
var jsprim = require('jsprim');
var mkdirp = require('mkdirp');
var once = require('once');
var path = require('path');
@@ -122,6 +123,7 @@ var restifyBunyanSerializers =
require('restify-clients/lib/helpers/bunyan').serializers;
var tabula = require('tabula');
var vasync = require('vasync');
var VError = require('verror');
var sshpk = require('sshpk');

var cloudapi = require('./cloudapi2');
@@ -185,6 +187,30 @@ function _stepInstId(arg, next) {
}

/**
* A function appropriate for `vasync.pipeline` funcs that takes a `arg.id`
* volume name, shortid or uuid, and determines the volume id (setting it
* as `arg.volId`).
*/
function _stepVolId(arg, next) {
assert.object(arg.client, 'arg.client');
assert.string(arg.id, 'arg.id');

if (common.isUUID(arg.id)) {
arg.volId = arg.id;
next();
} else {
arg.client.getVolume(arg.id, function onGetVolume(getVolErr, vol) {
if (getVolErr) {
next(getVolErr);
} else {
arg.volId = vol.id;
next();
}
});
}
}

/**
* A function appropriate for `vasync.pipeline` funcs that takes a `arg.package`
* package name, short id or uuid, and determines the package id (setting it
* as `arg.pkgId`). Also sets `arg.pkgName` so that we can use this to test when
@@ -2388,11 +2414,6 @@ TritonApi.prototype.rebootInstance = function rebootInstance(opts, cb) {
function randrange(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
function timeDiffMs(relativeTo) {
var diff = process.hrtime(relativeTo);
var ms = (diff[0] * 1e3) + (diff[1] / 1e6); // in milliseconds
return ms;
}

vasync.pipeline({arg: {client: self, id: opts.id}, funcs: [
_stepInstId,
@@ -2472,7 +2493,8 @@ TritonApi.prototype.rebootInstance = function rebootInstance(opts, cb) {

if (!theRecord) {
if (opts.waitTimeout) {
var elapsedMs = timeDiffMs(startTime);
var elapsedMs =
common.monotonicTimeDiffMs(startTime);
if (elapsedMs > opts.waitTimeout) {
next(new errors.TimeoutError(format('timeout '
+ 'waiting for instance %s reboot '
@@ -2676,6 +2698,249 @@ function _waitForInstanceUpdate(opts, cb) {
setImmediate(poll);
};

/**
* Creates a volume according to the parameters in "params" and calls the
* function "cb" when done.
*
* @param {Object} params
* - {String} type: Required. The type of the volume to create. The only
* valid value for now is "tritonnfs".
* - {String} name: Optional. The name of the volume to create. If not
* provided, a name will be automatically generated.
* - {String} network: Optional. The network name, short id or id on which
* the newly created volume will be reachable.
* - {Number} size: Optional. The desired size of the volume in mebibytes.
* If no size if provided, the volume will be created with the smallest
* possible size as outputted by CloudAPI's ListVolumeSizes endpoint.
* @param {Function} cb: `function (err, volume)`
*/
TritonApi.prototype.createVolume = function createVolume(params, cb) {
assert.object(params, 'params');
assert.string(params.type, 'params.type');
assert.optionalString(params.name, 'params.name');
assert.optionalString(params.network, 'params.network');
assert.optionalNumber(params.size, 'params.size');
assert.func(cb, 'cb');

var self = this;
var volumeCreated;

vasync.pipeline({arg: {client: self}, funcs: [
function doGetNetwork(arg, next) {
if (params.network === undefined || params.network === null) {
next();
return;
}

arg.client.getNetwork(params.network,
function onGetNetwork(getNetErr, net) {
if (getNetErr) {
next(getNetErr);
} else {
arg.networkId = net.id;
next();
}
});
},
function doCreateVolume(arg, next) {
var createVolParams = jsprim.deepCopy(params);
if (arg.networkId) {
createVolParams.networks = [arg.networkId];
}

arg.client.cloudapi.createVolume(createVolParams,
function onVolumeCreated(volCreateErr, volume) {
volumeCreated = volume;
next(volCreateErr);
});
}
]}, function done(err) {
cb(err, volumeCreated);
});
};

/**
* Get a volume by ID, exact name, or short ID, in that order.
*
* If there is more than one volume with that name, then this errors out.
*/
TritonApi.prototype.getVolume = function getVolume(id, cb) {
assert.string(id, 'id');
assert.func(cb, 'cb');

var shortId;
var self = this;
var volume;

vasync.pipeline({funcs: [
function tryUuid(_, next) {
var uuid;
if (common.isUUID(id)) {
uuid = id;
} else {
shortId = common.normShortId(id);
if (shortId && common.isUUID(shortId)) {
// E.g. a >32-char docker volume ID normalized to a UUID.
uuid = shortId;
} else {
next();
return;
}
}

self.cloudapi.getVolume({id: uuid}, function (err, vol) {
if (err) {
if (err.restCode === 'ResourceNotFound') {
err = new errors.ResourceNotFoundError(err,
format('volume with id %s was not found', uuid));
} else {
err = null;
}
}
volume = vol;
next(err);
});
},

function tryName(_, next) {
if (volume !== undefined) {
next();
return;
}

self.cloudapi.listVolumes({
predicate: JSON.stringify({
and: [
{ ne: ['state', 'failed'] },
{ eq: ['name', id] }
]
})
}, function (listVolumesErr, volumes) {
var err;

if (listVolumesErr) {
next(listVolumesErr);
return;
}

assert.arrayOfObject(volumes, 'volumes');

if (volumes.length === 1) {
volume = volumes[0];
} else if (volumes.length > 1) {
err = new errors.TritonError(format(
'volume name "%s" is ambiguous: matches %d volumes',
id, volumes.length));
}

next(err);
});
},

function tryShortId(_, next) {
if (volume !== undefined || !shortId) {
next();
return;
}

self.cloudapi.listVolumes({
predicate: JSON.stringify({
ne: ['state', 'failed']
})
}, function (listVolumesErr, volumes) {
var candidate;
var candidateIdx = 0;
var err;
var match;

if (!listVolumesErr) {
for (candidateIdx in volumes) {
candidate = volumes[candidateIdx];
if (candidate.id.slice(0, shortId.length) === shortId) {
if (match) {
err = (new errors.TritonError(
'instance short id "%s" is ambiguous',
shortId));
break;
} else {
match = candidate;
}
}
}
}

volume = match;
next(err);
});
}
]}, function getVolDone(err) {
if (err || volume) {
cb(err, volume);
} else {
cb(new errors.ResourceNotFoundError(format(
'no volume with id, name or short id "%s" was found', id)));
}
});
};

/**
* Deletes a volume by ID, exact name, or short ID, in that order.
*
* If there is more than one volume with that name, then this errors out.
*
* @param {Object} opts
* - {String} id: Required. The volume to delete's id, name or short ID.
* - {Boolean} wait: Optional. true if "cb" must be called once the volume
* is actually deleted, or deletion failed. If "false", "cb" will be
* called as soon as the deletion process is scheduled.
* - {Number} waitTimeout: Optional. if "wait" is true, represents the
* number of milliseconds after which to timeout (call `cb` with a
* timeout error) waiting.
* @param {Function} cb: `function (err)`
*/
TritonApi.prototype.deleteVolume = function deleteVolume(opts, cb) {
assert.string(opts.id, 'opts.id');
assert.optionalBool(opts.wait, 'opts.wait');
assert.optionalNumber(opts.waitTimeout, 'opts.waitTimeout');
assert.func(cb, 'cb');

var self = this;
var res;

vasync.pipeline({arg: {client: self, id: opts.id}, funcs: [
_stepVolId,

function doDelete(arg, next) {
self.cloudapi.deleteVolume(arg.volId,
function onVolDeleted(volDelErr, _, _res) {
res = _res;
next(volDelErr);
});
},

function waitForVolumeDeleted(arg, next) {
if (!opts.wait) {
next();
return;
}
self.cloudapi.waitForVolumeStates({
id: arg.volId,
states: ['failed'],
timeout: opts.waitTimeout
}, function onVolumeStateReached(err) {
if (VError.hasCauseWithName(err, 'VolumeNotFoundError')) {
// volume is gone, that's not an error
next();
return;
}
next(err);
});
}
]}, function onDeletionComplete(err) {
cb(err, null, res);
});
};

//---- exports

module.exports = {

+ 68
- 0
lib/volumes.js View File

@@ -0,0 +1,68 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

/*
* Copyright (c) 2017, Joyent, Inc.
*/

var assert = require('assert-plus');

function throwInvalidSize(size) {
assert.string(size, 'size');

throw new Error('size "' + size + '" is not a valid volume size');
}

/*
* Returns the number of MiBs (Mebibytes) represented by the string "size". That
* string has the following format: <integer><unit>. The integer must be > 0.
* Unit format suffixes are 'G' or 'g' for gibibytes and 'M' or 'm' for
* mebibytes.
*
* Examples:
* - the strings '100m' and '100M' represent 100 mebibytes
* - the strings '100g' and '100G' represent 100 gibibytes
*
* If "size" is not a valid size string, an error is thrown.
*/
function parseVolumeSize(size) {
assert.string(size, 'size');

var MIBS_IN_GB = 1024;

var MULTIPLIERS_TABLE = {
g: MIBS_IN_GB,
G: MIBS_IN_GB,
m: 1,
M: 1
};

var multiplier;
var multiplierSymbol;
var baseValue;

var matches = size.match(/^([1-9]\d*)(g|m|G|M)$/);
if (!matches) {
throwInvalidSize(size);
}

multiplierSymbol = matches[2];
if (multiplierSymbol) {
multiplier = MULTIPLIERS_TABLE[multiplierSymbol];
}

baseValue = Number(matches[1]);

if (isNaN(baseValue) || multiplier === undefined) {
throwInvalidSize(size);
}

return baseValue * multiplier;
}

module.exports = {
parseVolumeSize: parseVolumeSize
};

+ 3
- 2
package.json View File

@@ -11,7 +11,8 @@
"bunyan": "1.5.1",
"cmdln": "4.1.2",
"extsprintf": "1.0.2",
"getpass": "0.1.6",
"getpass": "0.1.6",
"jsprim": "1.4.0",
"lomstream": "1.1.0",
"mkdirp": "0.5.1",
"once": "1.3.2",
@@ -26,7 +27,7 @@
"strsplit": "1.0.0",
"tabula": "1.9.0",
"vasync": "1.6.3",
"verror": "1.6.0",
"verror": "1.10.0",
"which": "1.2.4",
"wordwrap": "1.0.0"
},

+ 6
- 1
test/integration/cli-subcommands.test.js View File

@@ -97,7 +97,12 @@ var subs = [
['rbac image-role-tags'],
['rbac network-role-tags'],
['rbac package-role-tags'],
['rbac role-tags']
['rbac role-tags'],
['volume', 'vol'],
['volume list', 'volume ls', 'volumes', 'vols'],
['volume delete', 'volume rm'],
['volume create'],
['volume get']
];

// --- Tests

+ 103
- 0
test/integration/cli-volumes-size.test.js View File

@@ -0,0 +1,103 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

/*
* Copyright (c) 2017, Joyent, Inc.
*/

/*
* Test volume create command's size parameter.
*/

var format = require('util').format;
var os = require('os');
var test = require('tape');
var vasync = require('vasync');

var common = require('../../lib/common');
var h = require('./helpers');

var FABRIC_NETWORKS = [];

var testOpts = {
skip: !h.CONFIG.allowWriteActions
};
test('triton volume create with non-default size...', testOpts, function (tt) {
var validVolumeName =
h.makeResourceName('node-triton-test-volume-create-non-default-' +
'size');
var validVolumeSize = '20g';
var validVolumeSizeInMib = 20 * 1024;

tt.comment('Test config:');
Object.keys(h.CONFIG).forEach(function (key) {
var value = h.CONFIG[key];
tt.comment(format('- %s: %j', key, value));
});

tt.test(' cleanup leftover resources', function (t) {
h.triton(['volume', 'delete', '-y', '-w', validVolumeName].join(' '),
function onDelVolume(delVolErr, stdout, stderr) {
// If there was nothing to delete, this will fail so that's the
// normal case. Too bad we don't have a --force option.
t.end();
});
});

tt.test(' triton volume create volume with non-default size',
function (t) {
h.triton([
'volume',
'create',
'--name',
validVolumeName,
'--size',
validVolumeSize,
'-w'
].join(' '), function (volCreateErr, stdout, stderr) {
t.equal(volCreateErr, null,
'volume creation should not error');
t.end();
});
});

tt.test(' check volume was created', function (t) {
h.safeTriton(t, ['volume', 'get', validVolumeName],
function onGetVolume(getVolErr, stdout) {
var volume;

t.equal(getVolErr, null,
'Getting volume should not error');

volume = JSON.parse(stdout);
t.equal(volume.size, validVolumeSizeInMib,
'volume size should be ' + validVolumeSizeInMib +
', got: ' + volume.size);
t.end();
});
});

tt.test(' delete volume', function (t) {
h.safeTriton(t, ['volume', 'delete', '-y', '-w', validVolumeName],
function onDelVolume(delVolErr, stdout) {
t.equal(delVolErr, null,
'Deleting volume should not error');
t.end();
});
});

tt.test(' check volume was deleted', function (t) {
h.triton(['volume', 'get', validVolumeName].join(' '),
function onGetVolume(getVolErr, stdout, stderr) {
t.ok(getVolErr,
'Getting volume ' + validVolumeName + 'after deleting it ' +
'should error');
t.notEqual(stderr.indexOf('ResourceNotFound'), -1,
'Getting volume ' + validVolumeName + 'should not find it');
t.end();
});
});
});

+ 251
- 0
test/integration/cli-volumes.test.js View File

@@ -0,0 +1,251 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/

/*
* Copyright 2017, Joyent, Inc.
*/

/*
* Test volume create command.
*/

var format = require('util').format;
var os = require('os');
var test = require('tape');
var vasync = require('vasync');

var common = require('../../lib/common');
var h = require('./helpers');

var FABRIC_NETWORKS = [];

var testOpts = {
skip: !h.CONFIG.allowWriteActions
};
test('triton volume create ...', testOpts, function (tt) {
var currentVolume;
var validVolumeName =
h.makeResourceName('node-triton-test-volume-create-default');

tt.comment('Test config:');
Object.keys(h.CONFIG).forEach(function (key) {
var value = h.CONFIG[key];
tt.comment(format('- %s: %j', key, value));
});

tt.test(' cleanup leftover resources', function (t) {
h.triton(['volume', 'delete', '-y', '-w', validVolumeName].join(' '),
function onDelVolume(delVolErr, stdout, stderr) {
// If there was nothing to delete, this will fail so that's the
// normal case. Too bad we don't have a --force option.
t.end();
});
});

tt.test(' triton volume create with invalid name', function (t) {
var invalidVolumeName =
h.makeResourceName('node-triton-test-volume-create-invalid-name-' +
'!foo!');
var expectedErrMsg = 'triton volume create: error (InvalidArgument): ' +
'Error: Invalid volume name: ' + invalidVolumeName;

h.triton([
'volume',
'create',
'--name',
invalidVolumeName
].join(' '), function (volCreateErr, stdout, stderr) {
t.ok(volCreateErr, 'create should have failed' +
(volCreateErr ? '' : ', but succeeded'));
t.equal(stderr.indexOf(expectedErrMsg), 0,
'stderr should include error message: ' + expectedErrMsg);
t.end();
});
});

tt.test(' triton volume create with invalid size', function (t) {
var invalidSize = 'foobar';
var expectedErrMsg = 'triton volume create: error: size "' +
invalidSize + '" is not a valid volume size';
var volumeName =
h.makeResourceName('node-triton-test-volume-create-invalid-size');

h.triton([
'volume',
'create',
'--name',
volumeName,
'--size',
invalidSize
].join(' '), function (volCreateErr, stdout, stderr) {
t.equal(stderr.indexOf(expectedErrMsg), 0,
'stderr should include error message: ' + expectedErrMsg);
t.end();
});
});

tt.test(' triton volume create with invalid type', function (t) {
var invalidType = 'foobar';
var volumeName =
h.makeResourceName('node-triton-test-volume-create-invalid-type');
var expectedErrMsg = 'triton volume create: error (InvalidArgument): ' +
'Error: Invalid volume type: ' + invalidType;

h.triton([
'volume',
'create',
'--name',
volumeName,
'--type',
invalidType
].join(' '), function (volCreateErr, stdout, stderr) {
t.equal(stderr.indexOf(expectedErrMsg), 0,
'stderr should include error message: ' + expectedErrMsg);
t.end();
});
});

tt.test(' triton volume create with invalid network', function (t) {
var volumeName =
h.makeResourceName('node-triton-test-volume-create-invalid-' +
'network');
var invalidNetwork = 'foobar';
var expectedErrMsg = 'no network with name or short id "' +
invalidNetwork + '" was found';

h.triton([
'volume',
'create',
'--name',
volumeName,
'--network',
invalidNetwork
].join(' '), function (volCreateErr, stdout, stderr) {
t.notEqual(stderr.indexOf(expectedErrMsg), -1,
'stderr should include error message: ' + expectedErrMsg +
', got: ' + volCreateErr);
t.end();
});
});

tt.test(' triton volume create valid volume', function (t) {
h.triton([
'volume',
'create',
'--name',
validVolumeName,
'-w'
].join(' '), function (volCreateErr, stdout, stderr) {
t.equal(volCreateErr, null,
'volume creation should not error');
t.end();
});
});

tt.test(' check volume was created', function (t) {
h.safeTriton(t, ['volume', 'get', validVolumeName],
function onGetVolume(getVolErr, stdout) {
t.equal(getVolErr, null,
'Getting volume should not error');
t.end();
});
});

tt.test(' delete volume', function (t) {
h.triton(['volume', 'delete', '-y', '-w', validVolumeName].join(' '),
function onDelVolume(delVolErr, stdout, stderr) {
t.equal(delVolErr, null,
'Deleting volume should not error');
t.end();
});
});

tt.test(' check volume was deleted', function (t) {
h.triton(['volume', 'get', validVolumeName].join(' '),
function onGetVolume(getVolErr, stdout, stderr) {
t.ok(getVolErr,
'Getting volume ' + validVolumeName + 'after deleting it ' +
'should error');
t.notEqual(stderr.indexOf('ResourceNotFound'), -1,
'Getting volume ' + validVolumeName + 'should not find it');
t.end();
});
});

// Test that we can create a volume with a valid fabric network and the
// volume ends up on that network.

tt.test(' find fabric network', function (t) {
h.triton(['network', 'list', '-j'].join(' '),
function onGetNetworks(getNetworksErr, stdout, stderr) {
var resultsObj;

t.ifErr(getNetworksErr, 'should succeed getting network list');

// turn the JSON lines into a JSON object
resultsObj = JSON.parse('[' + stdout.trim().replace(/\n/g, ',')
+ ']');

t.ok(resultsObj.length > 0,
'should find at least 1 network, found '
+ resultsObj.length);

FABRIC_NETWORKS = resultsObj.filter(function fabricFilter(net) {
// keep only those networks that are marked as fabric=true
return (net.fabric === true);
});

t.ok(FABRIC_NETWORKS.length > 0,
'should find at least 1 fabric network, found '
+ FABRIC_NETWORKS.length);

t.end();
});
});

tt.test(' triton volume on fabric network', function (t) {
h.triton([
'volume',
'create',
'--name',
'node-triton-test-volume-create-fabric-network',
'--network',
FABRIC_NETWORKS[0].id,
'-w',
'-j'
].join(' '), function (volCreateErr, stdout, stderr) {
t.ifErr(volCreateErr, 'volume creation should succeed');
t.comment('stdout: ' + stdout);
t.comment('stderr: ' + stderr);
currentVolume = JSON.parse(stdout);
t.end();
});
});

tt.test(' check volume was created', function (t) {
h.safeTriton(t, ['volume', 'get', currentVolume.name],
function onGetVolume(getVolErr, stdout) {
var volumeObj;

t.ifError(getVolErr, 'getting volume should succeed');

volumeObj = JSON.parse(stdout);
t.equal(volumeObj.networks[0], FABRIC_NETWORKS[0].id,
'expect network to match fabric we passed');

t.end();
});
});

tt.test(' delete volume', function (t) {
h.triton(['volume', 'delete', '-y', '-w', currentVolume.name].join(' '),
function onDelVolume(delVolErr, stdout, stderr) {
t.ifError(delVolErr, 'deleting volume should succeed');
t.end();
});
});

});

+ 11
- 1
test/integration/helpers.js View File

@@ -12,9 +12,10 @@
* Test helpers for the integration tests
*/

var error = console.error;
var assert = require('assert-plus');
var error = console.error;
var f = require('util').format;
var os = require('os');
var path = require('path');
var tabula = require('tabula');

@@ -488,6 +489,14 @@ function printConfig(t) {
});
}

/*
* Returns a string that represents a unique resource name for the host on which
* this function is called.
*/
function makeResourceName(prefix) {
assert.string(prefix, 'prefix');
return prefix + '-' + os.hostname();
}

// --- exports

@@ -508,6 +517,7 @@ module.exports = {
getResizeTestPkg: getResizeTestPkg,

jsonStreamParse: jsonStreamParse,
makeResourceName: makeResourceName,
printConfig: printConfig,

ifErr: testcommon.ifErr

+ 60
- 4
test/unit/common.test.js View File

@@ -116,7 +116,7 @@ test('jsonStream', function (t) {
t.end();
});

test('kvToObj', function (t) {
test('objFromKeyValueArgs', function (t) {
var arr = ['foo=1', 'bar=2', 'baz=3'];
var o = {
foo: '1',
@@ -126,21 +126,77 @@ test('kvToObj', function (t) {
var kv;

// no valid parameter
kv = common.kvToObj(arr);
kv = common.objFromKeyValueArgs(arr, {
disableDotted: true,
disableTypeConversions: true
});

t.deepEqual(kv, o);

// valid parameters
kv = common.kvToObj(arr, ['foo', 'bar', 'baz']);
kv = common.objFromKeyValueArgs(arr, {
validKeys: ['foo', 'bar', 'baz'],
disableDotted: true,
disableTypeConversions: true
});

t.deepEqual(kv, o);

// invalid parameters
t.throws(function () {
common.kvToObj(arr, ['uh-oh']);
common.objFromKeyValueArgs(arr, {
validKeys: ['uh-oh'],
disableDotted: true,
disableTypeConversions: true
});
});

t.end();
});

test('objFromKeyValueArgs failOnEmptyValue', function (t) {
var arr = ['foo='];
var err;