shutdown: function(projects, auth) {
projects = Lang.isArray(projects) ? projects : [projects];
var defered = deferred = D(),
last = projects.length - 1;
function release(index) {
if (index === last) {
if (!auth) {
DeployR.new('/r/user/logout')
.error(function(err) {
defered.reject(false);
})
.end(function(res) {
defered.resolve(true);
});
} else {
defered.resolve(true);
}
}
}
projects.forEach(function(project, index) {
DeployR.new('/r/project/close')
.data({ project: project })
.error(function(err) {
release(index);
})
.end(function(res) {
release(index);
});
});
return defered.promise;
},
, execTestPromise = function execTestPromise(testFilename, testName, environment){
var execDefer = D();
testList.startTest(testName, environment);
childProcess.exec(
frameworkAdapter.getCmd(environment, testFilename)
, function(err, stdout, stderr){
try{
var status = err ? 'failed' : 'ok'
, now = new Date()
, test = testList.cache[testName].tests[environment]
;
test.out = (stdout || stderr).toString('utf8').replace(/\[[0-9;]+m/g,'');
test.status = status;
test.endTime = now;
test.duration = (test.endTime.getTime() - test.startTime.getTime())/1000 + 's';
testList.setTestResult(testName, environment, test);
execDefer.resolve(test);
} catch(e) {
execDefer.reject(e);
}
}
);
return execDefer.promise;
}
, getAllSince: function(what, since, params){
since.toISOString && (since = since.toISOString());
params || (params = {} );
params.sort = 'updated_on:desc';
params.limit || (params.limit=100);
var self = this
, d = D()
, res = []
, getNext = function getNext(data){
var fulfilled=false;
data[what].forEach(function(v){
if( since >= v.updated_on ){
fulfilled=true;
}
fulfilled || res.push(v);
});
if( (!fulfilled) && (data.total_count > (data.limit+data.offset)) ){
params.offset = data.limit+data.offset;
params.limit = data.limit;
return self.get(what, params).success(getNext).rethrow(d.reject);
}
return d.resolve(res);
};
self.get(what, params).success(getNext).rethrow(d.reject);
return d.promise;
}
pipeline: function(chains) {
var deployr = this,
deferred = D(),
q = new Queue(),
results = [],
errors = [],
NOOP = null, // NOOP errors|results for [a] batch request chain
orig = {
sticky: globalOptions.sticky,
cookies: globalOptions.cookies
};
// make a copy
chains = chains.slice(0);
// turn sticky session for these request (hacky)
deployr.configure( { sticky: true });
function add() {
q.add(function() {
chains.shift().drain()
.then(function(chain) {
results.push(chain);
errors.push(NOOP);
if (q.isEmpty()) {
deployr.configure(orig); // reset
deferred.resolve({ results: results, errors: errors });
}
q.take();
}, function(err) {
results.push(NOOP);
errors.push(err);
// rejections are only met when they [all] fail
if (q.isEmpty() && results.length === 0) {
deployr.configure(orig); // reset
deferred.reject(errors);
}
q.take();
});
}, null, true);
}
// convert to a seq queue for better handling
for(var i = 0; i < chains.length; i++) { add(); }
// start: dequeue first item and run it
q.take();
return deferred.promise;
},
release: function(projects, auth) {
projects = Lang.isArray(projects) ? projects : [projects];
var self = this,
deferred = D(),
empty = !projects || !projects[0],
count = 0,
last = !empty ? projects.length - 1 : count,
cookies = this.getCookies();
function logout(index) {
if (index === last) {
if (!auth) {
DeployR.new('/r/user/logout')
.share(cookies)
.error(function() {
deferred.reject(false);
})
.end(function() {
deferred.resolve(true);
})
.ensure(function() {
self.destroy();
});
} else {
deferred.resolve(true);
self.destroy();
}
}
}
if (!empty) {
projects.forEach(function(project) {
DeployR.new('/r/project/close')
.data({ project: project })
.share(cookies)
.end()
.ensure(function() {
logout(count);
count++;
});
});
} else {
logout(count);
}
return deferred.promise;
},
initialize: function initialize(api, link) {
Emitter.initialize.call(this, {});
var opts = globalOptions;
if (!apis[api]) { throw new Error('Invalid API "' + api + '"'); }
this.api = merge({ 'call': api }, apis[api]);
this.link = link || {};
this.q = this.link.queue || new Queue();
this.deferred = this.link.deferred || D();
this.cookies = this.link.cookies;
this.logger = Logger.get(api, Logger.OFF); // transaction-level logging
this.params = {};
this.inputs = []; // rinputs list
this.outputs = []; // routput object list
this.rstream = false;
this.delayed = false;
this.file = null;
this.filter = null;
// preset deployr's assigned response format for `this` api
this.data({ format: this.api.format });
// wrap superagent for the heavly lifting
this.req =
request[this.api.method.toLowerCase()](opts.host + '/deployr' + api);
this.req.timeout(20 * 60 * 1000); // default timeout --> 20 minutes
// All CORS deployr calls require sticky sessions
if (win && globalOptions.cors) { this.req.withCredentials(); }
if (this.api.upload) {
// If the env is the Browser there is no need to manually set the
// Content-Type. The browser will automatically set the
// "multipart/form-data; boundary=..." value. If the env is Node we need
// to set it manually.
if (!win) { this.req.type('multipart/form-data'); }
} else {
this.req.type('form');
}
},
pipeline: function(chains) {
var deferred = D(),
q = new Queue(),
results = [],
errors = [],
NOOP = null; // NOOP errors|results for [a] batch request chain
// make a copy
chains = chains.slice(0);
function add() {
q.add(function() {
chains.shift().drain()
.then(function(chain) {
results.push(chain);
errors.push(NOOP);
if (q.isEmpty()) {
deferred.resolve({ results: results, errors: errors });
}
q.take();
}, function(err) {
results.push(NOOP);
errors.push(err);
// rejections are only met when they [all] fail
if (q.isEmpty() && results.length === 0) { deferred.reject(errors); }
q.take();
});
}, null, true);
}
// convert to a seq queue for better handling
for(var i = 0; i < chains.length; i++) { add(); }
// start: dequeue first item and run it
q.take();
return deferred.promise;
},
, request: function(method, path, params, reqParams){
//- console.log(arguments)
var self = this
, d = D()
, options
, req
, keyPass = keyPassphrases[this.keyPassId];
reqParams.tryCount = reqParams.tryCount ? reqParams.tryCount : 0;
reqParams.maxTryCount = reqParams.maxTryCount ? self.maxTryCount : reqParams.maxTryCount;
reqParams.maxDelay = reqParams.maxDelay ? self.maxDelay : reqParams.maxDelay;
if (! (this.apiKey && this.host)) {
d.reject('Error: apiKey and host must be configured.');
return d.promise;
}
params || (params = {});
path.slice(0, 1) !== '/' && (path = '/' + path);
self.pathPrefix && (path = self.pathPrefix + path);
options = {
host: self.host
, port: self.port
, path: method === 'GET' ? self.generatePath(path, params) : path
, method: method
, headers: {
'X-Redmine-API-Key': self.apiKey
}
, agent: false // required for ssl options to work
};
self.basicAuth && (options.auth = self.basicAuth);
self.sslCaCert && (options.ca = self.sslCaCert);
self.sslClientCert && (options.cert = self.sslClientCert);
keyPass.key && (options.key = keyPass.key);
keyPass.passphrase && (options.passphrase = keyPass.passphrase);
req = (self.protocol==='https' ? https : http).request(options, function(res){
var body='';
res.setEncoding('utf8');
res.on('data', function(chunk) {
body += chunk;
});
res.on('end', function() {
try {
var data = JSON.parse(body || res.statusCode);
d.resolve(data);
}catch(e){
d.reject("Error: Broken json in response");
}
});
if ( !~([200,201]).indexOf(res.statusCode) ) {
console.log('STATUSCODE REJECTIONS', res.statusCode);
d.reject('Server returns stats code: ' + res.statusCode);
return;
}
});
req.on('error', function(e){
console.log('Error: request error', e);
d.reject('ERROR_REQUEST');
});
req.setHeader('Content-Type', 'application/json');
if (method !== 'GET') {
var body = JSONStringify(params);
req.setHeader('Content-Length', body.length);
req.setHeader('Content-Type', 'application/json');
req.write(body);
}
req.end();
return d.promise.error(function(e){
if ( e.message === 'ERROR_REQUEST' && reqParams.tryCount > reqParams.maxTryCount ){
console.log('retry previoys request');
return D.wait( Math.min(8 << reqParams.tryCount, reqParams.maxDelay)).then(function(){
reqParams.tryCount++;
return self.request(method, path, params, reqParams);
});
}
console.log('ERROR', e, req);
throw e;
});
}