function do_delete(subcmd, opts, args, cb) {
if (opts.help) {
this.do_help('help', {}, [subcmd], cb);
return;
} else if (args.length !== 1) {
cb(new errors.UsageError('incorrect number of args'));
return;
}
var uuid = args[0];
var MOCKCLOUD;
vasync.waterfall([
function (next) {
common.createMockCloudClient(function (err, client) {
MOCKCLOUD = client;
next();
});
},
function (next) {
MOCKCLOUD.del('/servers/' + uuid, onDelete);
function onDelete(err, req, res, info) {
next(err);
}
}
], function (err) {
cb(err);
});
}
ModelWaitlist.prototype.deleteAllTickets = function (callback) {
var self = this;
vasync.waterfall([
function (wfcb) {
ModelWaitlist.getMoray().deleteMany(
buckets.waitlist_tickets.name,
'(server_uuid=' + self.uuid + ')',
function (delError) {
wfcb(delError);
return;
});
},
function (wfcb) {
ModelWaitlist.getMoray().deleteMany(
buckets.waitlist_queues.name,
'(server_uuid=' + self.uuid + ')',
function (delError) {
wfcb(delError);
return;
});
}
],
function (err) {
callback(err);
});
};
exports.getDeliverableUpdates = function (req, res, next) {
this.log = log.child({ action: 'getDeliverableUpdates' });
var self = this;
async.waterfall([
function(cb) { // authenticate with node API
apiCommon.passport.authenticate('bearer', { session: false }, function(err, user) {
if (err) { return cb(err); }
if (!user) { return cb(null, null); }
return cb(null, user);
})(req, res, next);
},
function(user, cb) { // get data from DB
if (user) {
if (req.params.ids) {
let fields = [req.params.ids];
dbDeliverableUpdate.getDeliverableUpdatesWithIds(fields, function (err, result) {
if (err) {
self.log.error(err, 'getDeliverableUpdatesWithIds');
return cb(err);
}
return cb(null, result);
});
} else if (req.params.quarter) {
let fields = { quarter : req.params.quarter };
dbDeliverableUpdate.getDeliverableUpdates(fields, function (err, result) {
if (err) {
self.log.error(err, 'getDeliverableUpdates');
return cb(err);
}
return cb(null, result);
});
}
} else {
self.log.warn('Not logged in');
return cb(null, null);
}
},
function(result, cb) { // format data for return
let deliverableUpdates = { deliverableUpdates: [] };
for (var i in result) {
let deliverableUpdateD = result[i];
let deliverableUpdateF = { id: deliverableUpdateD.id,
updateDate: deliverableUpdateD.updateDate,
deliveryDate: deliverableUpdateD.deliveryDate,
status: deliverableUpdateD.status,
commentary: deliverableUpdateD.commentary };
deliverableUpdates.deliverableUpdates[i] = deliverableUpdateF;
}
return cb(null, deliverableUpdates);
}
],
function(err, result) {
if (err) {
self.log.error(err);
return next(err);
}
res.send(200, result);
next();
});
};
exports.getUser = function (req, res, next) {
this.log = log.child({ action: 'getUser' });
var self = this;
async.waterfall([
function(cb) { // get data from DB
let userR = { user: {} };
self.log.info({params: req.params});
let fields = [ req.params.id ];
dbUser.getUser(fields, function (err, result) {
if (err) {
self.log.error(err, 'getUser');
return cb(err);
}
let userD = result[0];
self.log.info({user: userD});
let userF = { id: userD.id,
name: userD.name };
userR.user = userF;
return cb(null, userR);
});
},
],
function(err, result) {
if (err) {
self.log.error(err);
return next(err);
}
res.send(200, result);
next();
});
};
test('commit upload: commit content md5 match', function (t) {
var self = this;
vasync.waterfall([
function (callback) {
self.createUpload(self.path, null, function (err) {
if (ifErr(t, err, 'created upload')) {
callback(err);
} else {
callback(null);
}
});
},
function (callback) {
self.writeTestObject(self.uploadId, 0, function (err, res) {
if (ifErr(t, err, 'uploaded part')) {
callback(err);
} else {
t.ok(res);
t.checkResponse(res, 204);
callback(null, res.headers.etag);
}
});
},
function (etag, callback) {
self.commitUpload(self.uploadId, [etag], function (err, res) {
if (ifErr(t, err, 'commited upload')) {
callback(err);
} else {
t.ok(res);
t.ok(res.headers);
t.ok(res.headers['computed-md5']);
if (res === undefined || res.headers == undefined) {
callback(new Error('commit upload missing res'));
return;
}
callback(null, res.headers['computed-md5']);
}
});
},
function (computedMd5, callback) {
self.client.info(self.path, function (err, info) {
if (ifErr(t, err, 'got object info')) {
callback(err);
} else {
t.ok(info, 'failed to get object info');
if (info) {
var headers = info.headers || {};
t.equal(computedMd5, helper.TEXT_MD5);
t.equal(computedMd5, headers['content-md5']);
}
callback(null);
}
});
}
], function () {
t.end();
});
});
"releaseVersion": function releaseVersion(key, version, releaseDate, cb) {
//convert date to a string in format YYYY-MM-DD
var releaseDateStr =
releaseDate.getFullYear() + "-" +
("" + (releaseDate.getMonth() + 1)).slice(-2) + "-" +
("0" + releaseDate.getDate()).slice(-2);
vasync.waterfall([
function getProjectVersions(callback) {
oauthRest({
"config": config,
"query": "project/" + key + "/versions"
}, callback);
},
function getIssuesUnresolvedCount(versions, callback) {
var versionObj = _.find(versions, function matchVersion(v) {
return v.name === version;
});
if (versionObj) {
oauthRest({
"config": config,
"query": "version/" + versionObj.id + "/unresolvedIssueCount"
}, function getVersionCallback(err, data) {
data = data || {};
versionObj.issuesUnresolvedCount = data.issuesUnresolvedCount;
callback(err, versionObj);
});
} else {
callback("Version " + version + " not found in project " + key);
}
},
function releaseIfZeroIssuesUnresolved(versionObj, callback) {
if (versionObj.issuesUnresolvedCount === 0) {
oauthRest({
"config": config,
"query": "version/" + versionObj.id,
"method": "put",
"postData": {
"released": true,
"releaseDate": releaseDateStr
}
},
function getVersionCallback(err) {
if (!err) {
versionObj.released = true;
versionObj.releaseDate = releaseDateStr;
}
callback(err, versionObj);
});
} else {
//Note: versionObj.released will remain false
callback(null, versionObj);
}
}
], cb);
},
exports.putUser = function (req, res, next) {
this.log = log.child({ action: 'putUser' });
var self = this;
async.waterfall([
function(cb) { // authenticate with node API
apiCommon.passport.authenticate('bearer', { session: false }, function(err, user) {
if (err) { return cb(err); }
if (!user) { return cb(null, null); }
return cb(null, user);
})(req, res, next);
},
function(user, cb) { // get existing user password
if (user) {
let fields = [ user.name ];
dbUser.getUserPassword(fields, function (err, result) {
if (err) {
self.log.error(err, 'getUser');
return cb(err);
}
return cb(null, result[0]);
});
} else {
self.log.warn('Not logged in');
return cb(null, null);
}
},
function(user, cb) { // update DB
if (req.params.user.newPassword1 !== req.params.user.newPassword2) {
var error = new apiCommon.restify.WrongAcceptError("New passwords don't match");
return cb(error, null);
}
if (req.params.user.newPassword1 === req.params.user.oldPassword) {
var error = new apiCommon.restify.WrongAcceptError("New password can't be the same as old password");
return cb(error, null);
}
let fields = [ { password: req.params.user.newPassword1,
resetPassword: false },
req.params.id ];
dbUser.putUser(fields, user, function (err, result) {
if (err) {
self.log.error(err, 'putUser');
return cb(err);
}
return cb(null, null);
});
},
],
function(err, result) {
if (err) {
return next(err);
}
req.params.user.id = req.params.id;
res.send(200, {user: req.params.user});
next();
});
};
test('copy a file into stopped container', function (tt) {
var cliVer = process.env.DOCKER_CLI_VERSION;
if (cliVer && semver.lt(cliVer, '1.8.0')) {
tt.skip('Docker copy out not supported in client ' + cliVer);
tt.end();
return;
}
tt.plan(15);
var fnbase = '/var/tmp';
var fn = 'copy-in.test';
var localfn = fnbase + '/' + fn;
var remotefn = fnbase + '/' + fn;
var hash;
vasync.waterfall([
function (next) {
createCopyInFile(tt, localfn, function (err, sha1) {
tt.ifErr(err, 'creating copy in file (stopped container)');
hash = sha1;
next();
});
},
function (next) {
stopContainer(tt, CONTAINER_NAME_NGINX2, function (err) {
tt.ifErr(err, 'error stopping container');
next();
});
},
function (next) {
copyFileIn(tt, localfn, remotefn, CONTAINER_NAME_NGINX2,
function (err) {
tt.ifErr(err, 'copying file in');
next();
});
},
function (next) {
startContainer(tt, CONTAINER_NAME_NGINX2, function (err) {
tt.ifErr(err, 'error stopping container');
next();
});
},
function (next) {
checkFileCopiedIn(tt, remotefn, CONTAINER_NAME_NGINX2, hash,
function (err) {
tt.ifErr(err, 'checking file copied in');
next();
});
}
], function (err) {
tt.end();
});
});
self.initAdm(opts, function () {
adm = self.madm_adm;
log = self.madm_log;
vasync.waterfall(funcs, function (err) {
if (err)
fatal(err.message);
self.finiAdm();
callback();
});
});
tt.test('docker build from alpine image (cross registry)', function (t) {
var dockerImageId;
var tarStream;
vasync.waterfall([
function createTar(next) {
var fileAndContents = {
'Dockerfile': 'FROM ' + imageName + '\n'
+ 'LABEL something=true\n'
};
tarStream = createTarStream(fileAndContents);
next();
},
function buildContainer(next) {
h.buildDockerContainer({
dockerClient: DOCKER_ALICE_HTTP,
params: {
'rm': 'true' // Remove container after it's built.
},
test: t,
tarball: tarStream
}, onbuild);
function onbuild(err, result) {
t.ifErr(err, 'build should not error on post');
var output = result.body;
var hasSuccess = output.indexOf('Successfully built') >= 0;
t.ok(hasSuccess,
'output should contain: Successfully built');
if (hasSuccess) {
var reg = new RegExp('Successfully built (\\w+)');
dockerImageId = output.match(reg)[1];
} else {
t.fail('Output: ' + output);
}
next();
}
},
function removeBuiltImage(next) {
t.ok(dockerImageId, 'Got the docker image id');
DOCKER_ALICE.del('/images/' + dockerImageId, next);
}
], function allDone(err) {
t.ifErr(err);
t.end();
});
});
tape.test('client close actually closes sockets', function (t) {
var server, nhandles, client;
server = net.createServer(12345);
vasync.waterfall([
function startServer(callback) {
server.listen(callback);
},
function createClient(callback) {
nhandles = process._getActiveHandles().length;
client = moray.createClient({
'log': helper.createLogger(),
'host': server.address().address,
'port': server.address().port,
'maxConnections': 1
});
client.on('connect', callback);
},
function closeClient(callback) {
t.ok(nhandles < process._getActiveHandles().length,
'handle count increased');
client.on('close', function () {
/*
* Sockets are destroyed in the context where this event is
* fired, but it may take another tick for them to disappear
* from the list of active handles.
*/
setImmediate(callback);
});
client.close();
},
function closeServer(callback) {
t.equal(nhandles, process._getActiveHandles().length,
'handle count decreased');
server.on('close', function () {
/* See above. */
setImmediate(callback);
});
server.close();
}
], function (err) {
t.error(err);
t.deepEqual([], process._getActiveHandles().filter(function (h) {
return (h !== process.stderr && h !== process.stdout);
}));
t.end();
});
});
function initializeFixtures(callback) {
vasync.waterfall([
function createDir(next) {
cli.exec(sprintf('mkdir -p %s', directoryName),
function (err, stdout, stderr) {
tt.ifErr(err, 'creating test directory');
tt.comment('created ' + directoryName);
next(err);
});
}
],
function (err) {
tt.ifErr(err);
callback(err);
});
}
tt.test('docker build from alpine image (same registry)', function (t) {
var tarStream;
vasync.waterfall([
function createTar(next) {
var fileAndContents = {
'Dockerfile': 'FROM ' + imageName + '\n'
+ 'LABEL something=true\n'
};
tarStream = createTarStream(fileAndContents);
next();
},
function buildContainer(next) {
h.buildDockerContainer({
dockerClient: DOCKER_ALICE_HTTP,
params: {
't': newTagName,
'rm': 'true' // Remove container after it's built.
},
test: t,
tarball: tarStream
}, onbuild);
function onbuild(err, result) {
t.ifErr(err, 'build should not error on post');
var msg = result.body;
var hasSuccess = msg.indexOf('Successfully built') >= 0;
t.ok(hasSuccess, 'output contains Successfully built');
// Delete the built image.
if (hasSuccess) {
DOCKER_ALICE.del('/images/' + escape(newTagName), next);
} else {
next();
}
}
}
], function allDone(err) {
t.ifErr(err);
t.end();
});
});
tt.test('docker create', function (t) {
t.plan(10);
var uuid;
vasync.waterfall([
function (next) {
// Create VMAPI client
h.createVmapiClient(function (err, client) {
t.error(err);
vmapi = client;
next(err);
});
},
function (next) {
// Create Docker client
h.createDockerRemoteClient(function (err, client) {
docker = client;
next(err);
});
},
function (next) {
h.createDockerContainer({
vmapiClient: vmapi,
dockerClient: docker,
test: t
}, oncreate);
function oncreate(err, result) {
t.error(err);
uuid = result.vm.uuid;
next();
}
},
function (next) {
// Cheat
exec('vmadm destroy ' + uuid, function (err, stdout, stderr) {
t.error(err, 'vmadm destroy should succeed');
next(err);
});
}
], function (err) {
t.error(err);
t.end();
});
});
exports.getDeliverableUpdate = function (req, res, next) {
this.log = log.child({ action: 'getDeliverableUpdate' });
var self = this;
async.waterfall([
function(cb) { // authenticate with node API
apiCommon.passport.authenticate('bearer', { session: false }, function(err, user) {
if (err) { return cb(err); }
if (!user) { return cb(null, null); }
return cb(null, user);
})(req, res, next);
},
function(user, cb) { // get data from DB
let deliverableUpdate = { deliverableUpdate: {} };
if (user) {
let fields = [ req.params.id ];
dbDeliverableUpdate.getDeliverableUpdate(fields, function (err, result) {
if (err) {
self.log.error(err, 'getDeliverableUpdate');
return cb(err);
}
let deliverableUpdateD = result[0];
let deliverableUpdateF = { id: deliverableUpdateD.id,
updateDate: deliverableUpdateD.updateDate,
deliveryDate: deliverableUpdateD.deliveryDate,
status: deliverableUpdateD.status,
commentary: deliverableUpdateD.commentary };
deliverableUpdate.deliverableUpdate = deliverableUpdateF;
return cb(null, deliverableUpdate);
});
} else {
self.log.warn('Not logged in');
return cb(null, deliverableUpdate);
}
},
],
function(err, result) {
if (err) {
self.log.error(err);
return next(err);
}
res.send(200, result);
next();
});
};
MockAgent.prototype.start = function () {
var self = this;
vasync.waterfall([
function (next) {
self.loadSDCConfig(next);
},
function (next) {
self.loadState(next);
},
function (next) {
self.monitorMockCNs();
next();
},
function (next) {
self.startHttpServer(next);
}
], function (err) {
});
};
exports.putDeliverableUpdate = function (req, res, next) {
this.log = log.child({ action: 'putDeliverableUpdate' });
var self = this;
async.waterfall([
function(cb) { // authenticate with node API
apiCommon.passport.authenticate('bearer', { session: false }, function(err, user) {
if (err) { return cb(err); }
if (!user) { return cb(null, null); }
return cb(null, user);
})(req, res, next);
},
function(user, cb) { // update DB
if (user) {
// get just the date portion
req.params.deliverableUpdate.updateDate = moment(req.params.deliverableUpdate.updateDate).format('YYYY-MM-DD');
req.params.deliverableUpdate.deliveryDate = moment(req.params.deliverableUpdate.deliveryDate).format('YYYY-MM-DD');
let fields = [ req.params.deliverableUpdate,
req.params.id ];
dbDeliverableUpdate.putDeliverableUpdate(fields, user, function (err, result) {
if (err) {
self.log.error(err, 'putDeliverableUpdate');
return cb(err);
}
return cb(null, null);
});
} else {
self.log.warn('Not logged in');
return cb(null, null);
}
},
],
function(err, result) {
if (err) {
self.log.error(err);
return next(err);
}
req.params.deliverableUpdate.id = req.params.id;
res.send(200, {deliverableUpdate: req.params.deliverableUpdate});
next();
});
};
function del_blog_post(req, res){
var post_id = req.query.id;
var selector = {};
var options = {};
var col;
console.log("Request coming in to delete the Blog post %s", post_id);
vasync.waterfall([function f1(callback) {
selector[post_attr.ID] = post_id;
col = blogdb.collection('blog_post');
col.deleteOne(selector, options, function(err, result) {
if (err)
callback(err);
else
callback();
});
}, function f2(callback) {
// Delete all the comments associated with the post_id
console.log("Deleting comments releated to post %s", post_id);
selector = {};
selector[comm_attr.POST_ID] = post_id;
col = blogdb.collection('comments');
col.deleteMany(selector, options, function(err, result) {
if (err)
callback(err);
else
callback();
});
}], function(err, result) {
if (err) {
res.write(JSON.stringify({success: false, error: ui_err_msg.MSG_DEL_ERR}));
res.end();
console.log(err);
return;
} else {
res.write(JSON.stringify({success:true, data: ui_msg.MSG_DELETE}, null, " "));
console.log(result);
res.end();
}
});
}
tt.test('docker build from alpine image (cross registry)', function (t) {
var tarStream;
vasync.waterfall([
function createTar(next) {
var fileAndContents = {
'Dockerfile': 'FROM ' + imageName + '\n'
+ 'LABEL something=true\n'
};
tarStream = createTarStream(fileAndContents);
next();
},
function buildContainer(next) {
h.buildDockerContainer({
dockerClient: DOCKER_ALICE_HTTP,
params: {
'rm': 'true' // Remove container after it's built.
},
test: t,
tarball: tarStream
}, onbuild);
function onbuild(err, result) {
t.ifErr(err, 'build should not error on post');
var msg = result.body;
t.ok(msg.indexOf('different registries') >= 0,
'expected a "different registries" error message');
next();
}
}
], function allDone(err) {
t.ifErr(err);
t.end();
});
});
test('copy a file out of stopped container', function (tt) {
tt.plan(9);
var fnbase = '/var/tmp';
var fn = 'copyout.test';
var remotefn = fnbase + '/' + fn;
var hash;
vasync.waterfall([
function (next) {
createCopyOutFile(tt, remotefn, CONTAINER_NAME_NGINX2,
function (err, sha1) {
tt.ifErr(err, 'creating copy out file');
hash = sha1;
next();
});
},
function (next) {
stopContainer(tt, CONTAINER_NAME_NGINX2,
function (err) {
tt.ifErr(err, 'stopping copy out container');
next();
});
},
function (next) {
copyFileOut(tt, remotefn, fn, CONTAINER_NAME_NGINX2,
function (err, sha1) {
tt.ifErr(err, 'copying file out');
tt.equal(sha1, hash);
next();
});
}
], function (err) {
tt.end();
});
});
function MockAgentLoadSDCConfig(callback) {
var self = this;
vasync.waterfall([
function (cb) {
getMetadata('sdc:dns_domain', function (e, val) {
if (!e) {
self.sdc_config.dns_domain = val;
}
cb(e);
});
}, function (cb) {
getMetadata('sdc:datacenter_name', function (e, val) {
if (!e) {
log.info('datacenter = %s', val);
self.sdc_config.datacenter_name = val;
}
cb(e);
});
}
], function (err) {
callback(err);
});
};
function listContainers(opts, callback) {
var dockerClient = opts.dockerClient;
var t = opts.test;
var containers;
vasync.waterfall([
function (next) {
// Post create request
dockerClient.get(
'/v1.16/containers/json'
+ (opts.all ? '?all=1' : ''), onget);
function onget(err, res, req, body) {
t.error(err);
containers = body;
next(err);
}
}
],
function (err) {
t.error(err);
callback(err, containers);
});
}
test('copy a file out of running container', function (tt) {
tt.plan(7);
var fnbase = '/var/tmp';
var fn = 'copyout.test';
var remotefn = fnbase + '/' + fn;
var hash;
vasync.waterfall([
function (next) {
createCopyOutFile(tt, remotefn, CONTAINER_NAME_NGINX,
function (err, sha1) {
tt.ifErr(err, 'creating copy out file');
hash = sha1;
tt.comment('hash was ' + hash);
next();
});
},
function (next) {
copyFileOut(tt, remotefn, fn, CONTAINER_NAME_NGINX,
function (err) {
tt.ifErr(err, 'copying file out');
next();
});
},
function (next) {
checkFileCopiedOut(tt, remotefn, hash, CONTAINER_NAME_NGINX,
function (err) {
tt.ifErr(err, 'copying file out');
next();
});
}
], function (err) {
tt.end();
});
});
PartnerAccountUserMapping.findAccount = function findAccount(token, next) {
var Account = PartnerAccountUserMapping.app.models.PartnerAccount;
vasync.waterfall([
function getMapping(cb) {
PartnerAccountUserMapping.find({"where": {"userModelId": token.userId}}, cb);
},
function getAccounts(result, cb) {
if (result.length === 1) {
Account.find({"where": {"id": result[0].partnerAccountId}}, cb);
} else {
cb(null, []);
}
}
], function end(err, result){
if (err) {
return next(err);
}
debug('> findAccount processed successfully');
if (result.length === 1) {
return next(err, [result]);
}
return next(err, result);
});
};
exports.archiveDeliverableUpdate = function (req, res, next) {
this.log = log.child({ action: 'archiveDeliverableUpdate' });
var self = this;
async.waterfall([
function(cb) { // authenticate with node API
apiCommon.passport.authenticate('bearer', { session: false }, function(err, user) {
if (err) { return cb(err); }
if (!user) { return cb(null, null); }
return cb(null, user);
})(req, res, next);
},
function(user, cb) { // update DB
if (user) {
let fields = [ req.params.id ];
dbDeliverableUpdate.archiveDeliverableUpdate(fields, user, function (err, result) {
if (err) {
self.log.error(err, 'archiveDeliverableUpdate');
return cb(err);
}
return cb(null, null);
});
} else {
self.log.warn('Not logged in');
return cb(null, null);
}
},
],
function(err, result) {
if (err) {
self.log.error(err);
return next(err);
}
res.send(200, {});
next();
});
};
"deleteVersion": function deleteVersion(key, version, cb) {
vasync.waterfall([
function getProjectVersions(callback) {
oauthRest({
"config": config,
"query": "project/" + key + "/versions"
}, callback);
},
function getVersionAndDelete(versions, callback) {
var versionObj = _.find(versions, function matchVersion(v) {
return v.name === version;
});
if (versionObj) {
oauthRest({
"config": config,
"query": "version/" + versionObj.id,
"method": "delete"
}, callback);
} else {
callback("Version " + version + " not found in project " + key);
}
}
], cb);
},
function replacefile(opts, callback) {
mod_assert.object(opts, 'opts');
mod_assert.string(opts.src, 'opts.src');
mod_assert.string(opts.dst, 'opts.dst');
mod_assert.func(callback, 'callback');
mod_vasync.waterfall([ function (next) {
/*
* Unlink the destination file.
*/
mod_fs.unlink(opts.dst, function (err) {
if (err) {
if (err.code === 'ENOENT') {
/*
* The file did not exist already.
*/
next();
return;
}
next(new VE(err, 'unlink destination file'));
return;
}
next();
});
}, function (next) {
/*
* Read source file.
*/
mod_fs.readFile(opts.src, { encoding: null }, function (err, data) {
if (err) {
next(new VE(err, 'read source file'));
return;
}
next(null, data);
});
}, function (data, next) {
mod_assert.ok(Buffer.isBuffer(data), 'data (Buffer)');
mod_assert.func(next, 'next');
/*
* Write destination file.
*/
var mode = parseInt('0644', 8);
mod_fs.writeFile(opts.dst, data, { mode: mode, flag: 'wx' },
function (err) {
if (err) {
next(new VE(err, 'write destination file'));
return;
}
next();
});
} ], function (err) {
if (err) {
callback(new VE(err, 'replace file "%s" with contents of "%s"',
opts.dst, opts.src));
return;
}
callback();
});
}
vasync.waterfall([
function _createConfig(callback) {
var config = {};
assert.func(callback, 'callback');
// This first function exists because the first function in the
// waterfall is "special" in that it doesn't get a first arg. So all we
// do here is create the config the other functions will add to.
callback(null, config);
},
loadConfig,
loadSdcConfig,
loadSysinfo
], function _waterfallComplete(err, config) {
var vmagent;
assert.ifError(err, 'Failed to load configuration');
assert.object(config, 'config');
assert.uuid(config.server_uuid, 'config.server_uuid');
assert.string(config.vmapi_url, 'config.vmapi_url');
assert.optionalNumber(config.periodic_interval);
assert.ok(!config.log, 'config.log must not be set');
logger.info({config: config}, 'loaded vm-agent configuration');
// Pass along our logger
config.log = logger;
// Start the agent with our fresh config
vmagent = new VmAgent(config);
vmagent.start();
});
this.login = function f_auth_login($user, $pw, $autoLogin) {
$autoLogin = $autoLogin || false;
log.info('LOGIN TRY: ' + $user + ' from ' + libs.SFFM.getIP($requestState.request));
var defer = q.defer();
async.waterfall([
function ($cb) {
_getIDFromUser($user).done(function ($id) {
$user = $id;
$cb();
}, function ($e) {
if ($e === SHPS_ERROR_NO_ROWS) {
_getIDFromMail($user).done(function ($id) {
$user = $id;
$cb();
}, $cb);
}
else {
$cb($e);
}
});
},
function ($cb) {
/* ASVS V2 2.20 VERTICAL PROTECTION */
_delayBruteforce($user).done(function () {
$cb();
}, $cb);
},
function ($cb) {
/* ASVS V2 2.20 HORIZONTAL PROTECTION */
_delayBruteforce($pw).done(function () {
$cb();
}, $cb);
},
function ($cb) {
libs.sql.newSQL('usermanagement', $requestState).done(function ($sql) {
$cb(null, $sql);
}, $cb);
},
function ($sql, $cb) {
var alt = '';
if ($autoLogin && libs.SFFM.isHTTPS($requestState.request)) {
alt = $requestState.COOKIE.getCookie(SHPS_COOKIE_AUTOLOGINTOKEN) || '0';
}
var tblU = $sql.openTable('user');
$sql.query()
.get(tblU.col('*'))
.fulfilling()
.or(function ($sqb) {
return $sqb.eq(tblU.col('ID'), $user);
}, function ($sqb) {
return $sqb.eq(tblU.col('autoLoginToken'), alt);
})
.execute()
.done(function ($rows) {
$sql.free();
if ($rows.length <= 0) {
$cb(new Error(SHPS_ERROR_NO_ROWS, false));
}
else {
var ur = $rows[0];
if ($rows.length > 1) {
var i = 0;
var l = $rows.length;
while (i < l) {
if ($rows[i].autoLoginToken === alt) {
ur = $rows[i];
break;
}
i++;
}
}
// ASVS V2 3.16
var lastSID = _isLoggedInFromDBRecord(ur);
if (lastSID !== false && lastSID !== _session.toString()) {
_session.closeSession(lastSID);
}
if (alt !== '' && alt === ur.autoLoginToken/* && check IP range */) {
var newToken = _session.genNewSID();
$requestState.COOKIE.setCookie(SHPS_COOKIE_AUTOLOGINTOKEN, newToken, $requestState.config.securityConfig.autoLoginTimeout.value, true);
libs.sql.newSQL('usermanagement', $requestState).done(function ($sql) {
$sql.openTable('user').update({
autoLoginToken: newToken,
lastIP: libs.SFFM.getIP($requestState.request),
lastActivity: Date.now() / 1000
})
.eq(tblU.col('ID'), ur.ID)
.execute()
.done($sql.free, $sql.free);
});
$cb(null, true);
return;
}
if (ur.isLocked) {
$cb(null, false);
return;
}
_checkPassword($user, $pw, ur.password, ur.salt).done(function ($cpR) {
if ($cpR) {
$requestState.SESSION = oa($requestState.SESSION, ur);
var newToken = _session.genNewSID();
$requestState.COOKIE.setCookie(SHPS_COOKIE_AUTOLOGINTOKEN, newToken, $requestState.config.securityConfig.autoLoginTimeout.value, true);
libs.sql.newSQL('usermanagement', $requestState).done(function ($sql) {
$sql.openTable('user').update({
autoLoginToken: newToken,
lastIP: libs.SFFM.getIP($requestState.request),
lastActivity: Date.now() / 1000
})
.eq(tblU.col('ID'), ur.ID)
.execute()
.done($sql.free, $sql.free);
});
}
$cb(null, $cpR);
}, $cb);
}
}, $cb);
},
], function ($err, $res) {
if ($err) {
defer.reject(new Error($err));
}
else {
defer.resolve($res);
}
});
return defer.promise;
};
tt.test('docker build own alpine image', function (t) {
var dockerImageId = null;
var tarStream;
vasync.waterfall([
function createTar(next) {
var fileAndContents = {
'Dockerfile': 'FROM ' + imageName1 + '\n'
+ 'LABEL sdcdockertest_conflict=yes\n'
};
tarStream = createTarStream(fileAndContents);
next();
},
function buildContainer(next) {
h.buildDockerContainer({
dockerClient: DOCKER_ALICE_HTTP,
params: {
'rm': 'true' // Remove container after it's built.
},
test: t,
tarball: tarStream
}, onbuild);
function onbuild(err, result) {
t.ifError(err, 'built successfully');
next(err, result);
}
},
function checkResults(result, next) {
if (!result || !result.body) {
next(new Error('build generated no output!?'));
return;
}
var output = result.body;
var hasSuccess = output.indexOf('Successfully built') >= 0;
t.ok(hasSuccess, 'output should contain: Successfully built');
if (hasSuccess) {
var reg = new RegExp('Successfully built (\\w+)');
dockerImageId = output.match(reg)[1];
} else {
t.fail('Output: ' + output);
}
next();
},
function removeBuiltImage(next) {
t.ok(dockerImageId, 'got the built docker image id');
DOCKER_ALICE.del('/images/' + dockerImageId, next);
}
], function allDone(err) {
t.ifErr(err);
t.end();
});
});