Crazyradio.prototype.write = function(data, timeout)
{
var self = this,
deferred = P.defer();
var d = domain.create();
d.on('error', function(err)
{
deferred.reject(err);
});
d.run(function()
{
self.outputStream().write(data, function(err)
{
if (err)
deferred.reject(err);
else
deferred.resolve('OK');
});
});
return deferred.promise;
};
CrazyDriver.prototype.fetchParameters = function()
{
var self = this;
this.parametersDeferred = P.defer();
this.requestTOC(Protocol.Ports.PARAM);
return this.parametersDeferred.promise;
};
Copter.prototype.land = function()
{
var self = this,
deferred = P.defer();
this.copterStates.land();
var thrustStep = 1000;
var stepMS = 250;
if (this.flightTimer)
clearInterval(this.flightTimer);
function landCurve()
{
var thrust = self.thrust - thrustStep;
if (thrust <= MIN_THRUST)
thrust = MIN_THRUST;
// console.log('landing; thrust:', thrust);
self.goal.thrust = thrust;
self.thrust = thrust;
if (thrust === MIN_THRUST)
{
self.copterStates.landed();
deferred.resolve(self.copterStates.currentState());
}
}
this.hoverTimer = setInterval(landCurve, stepMS);
return deferred.promise;
};
function (srpSession) {
var k = P.defer()
if (!this.srpPw) {
session = srpSession
keyStretch.derive(Buffer(this.email, 'hex'), Buffer(this.password), session.passwordStretching.salt)
.then(
function (result) {
this.srp = {}
this.srp.type = 'SRP-6a/SHA256/2048/v1'
this.srpPw = result.srpPw.toString('hex')
this.unwrapBKey = result.unwrapBKey.toString('hex')
this.passwordSalt = session.passwordStretching.salt
k.resolve(srpSession)
}.bind(this),
function (err) {
k.reject(err)
}
)
} else {
k.resolve(srpSession)
}
return k.promise
}.bind(this)
CrazyDriver.prototype.setpoint = function(roll, pitch, yaw, thrust)
{
var self = this,
deferred = P.defer();
var packet = new Crazypacket();
packet.port = Protocol.Ports.COMMANDER;
packet.writeFloat(roll)
.writeFloat(-pitch)
.writeFloat(yaw)
.writeUnsignedShort(thrust)
.endPacket();
return this.radio.sendPacket(packet)
.then(function(item)
{
return item;
})
.fail(function(err)
{
console.log('failure in setpoint');
console.log(err);
});
};
CrazyDriver.prototype.startTelemetry = function()
{
this.telemetryDeferred = P.defer();
this.radio.addListener('logging', this.telemetry.handlePacket.bind(this.telemetry));
this.requestTOC();
return this.telemetryDeferred.promise;
};
function getVideoById(id) {
var defer = P.defer();
dloader.getVideoById(id).then(function(path) {
defer.resolve(path);
}).fail(function(err) {
defer.reject(err);
});
return defer.promise;
}
exports.findChannel = function(bt, address)
{
var deferred = P.defer();
bt.findSerialPortChannel(address, function(channel)
{
deferred.resolve(channel);
});
return deferred.promise;
};
window.Promise = function (callback) {
var deferred = p.defer();
try {
callback(deferred.resolve.bind(deferred), deferred.reject.bind(deferred));
} catch (e) {
deferred.reject(e);
}
return deferred.promise;
};
p.jQueryXHR = function (jQueryDeferred) {
var defer = p.defer();
jQueryDeferred.then(function (data/*,textStatus, jqXHR*/) {
defer.resolve(data);
}, function (jqXHR/*, textStatus, errorThrown*/) {
defer.reject(jqXHR);
});
return defer.promise;
};
function hkdf(km, info, salt, len) {
var d = P.defer()
var df = new HKDF('sha256', salt, km)
df.derive(
kw(info),
len,
function(key) {
d.resolve(key)
}
)
return d.promise
}
function waitForCode() {
var d = P.defer()
function loop() {
if (!emailCode) {
return setTimeout(loop, 10)
}
d.resolve(emailCode)
emailCode = null
}
loop()
return d.promise
}
function refreshList() {
var defer = P.defer();
exec('node core/index.js', (error, stdout, stderr) => {
if (error) {
error.stderr = stderr;
defer.reject(error);
}
else
defer.resolve(stdout);
});
return defer.promise;
}
/** Derive a key from an email and password pair
*
* @param {Buffer} email The email hex buffer of the user
* @param {Buffer} password The password of the user
* @param {String} saltHex The salt to derive hkdf as a hex string
* @return p.promise object - It will resolve with
* {Buffer} srpPw srp password
* {Buffer} unwrapBKey unwrapBKey
* or fail with {object} err
*/
function derive(email, password, saltHex) {
var p = P.defer()
if (!password || !email || !saltHex) {
p.reject('Bad password, salt or email input')
return p.promise
}
var salt = Buffer(saltHex, 'hex')
// derive the first key from pbkdf2
pbkdf2
.derive(password, KWE('first-PBKDF', email))
.then(
function(K1) {
// request a hash from scrypt based on the first key
return scrypt.hash(K1, KW("scrypt"), SCRYPT_HELPER)
}
)
.then(
function (K2) {
// combine the K2 hex string and a password UTF8 into a bit array
var scryptPassword = Buffer.concat([
Buffer(K2, 'hex'),
password
])
// derive the second key from pbkdf2
return pbkdf2.derive(scryptPassword, KWE('second-PBKDF', email))
}
)
.then(
function (stretchedPw) {
var input = new Buffer (stretchedPw, 'hex')
var lengthHkdf = 2 * 32
return hkdf(input, 'mainKDF', salt, lengthHkdf)
}
)
.done(
function (hkdfResult) {
var hkdfResultHex = hkdfResult.toString('hex')
var srpPw = Buffer(hkdfResultHex.substring(0,64), 'hex')
var unwrapBKey = Buffer(hkdfResultHex.substring(64,128), 'hex')
p.resolve({ srpPw: srpPw, unwrapBKey: unwrapBKey })
},
function (err) {
p.reject(err)
}
)
return p.promise
}
exports.connect = function(bt, address, channel)
{
var deferred = P.defer();
bt.connect(address, channel, function()
{
deferred.resolve();
}, function()
{
deferred.reject(new Error('failed to connect to ' + address + '@' + channel));
});
return deferred.promise;
};
function getVideos(index) {
var defer = P.defer();
fs.readdir(__dirname + '/videos', function(err, files) {
if (err)
defer.reject(err);
else {
if (index)
defer.resolve(files[index]);
else
defer.resolve(files);
}
});
return defer.promise;
}
function waitForCode(email) {
var d = P.defer()
function loop() {
var code
if (!emailCodes[email]) {
return setTimeout(loop, 10)
}
code = emailCodes[email]
emailCodes[email] = null
d.resolve(code)
}
loop()
return d.promise
}
function wrapperFile(algo, fname)
{
if (typeof fname !== 'string')
return P.reject(new Error('You must pass a string filename as input.'));
var deferred = P.defer();
blake2.b2_file(algo, fname, function(err, result)
{
if (err) deferred.reject(err);
else deferred.resolve(result);
});
return deferred.promise;
}
function wrapper(algo, buffer)
{
if (!Buffer.isBuffer(buffer))
return P.reject(new Error('You must pass a buffer as input.'));
var deferred = P.defer();
blake2.b2_buffer(algo, buffer, function(err, result)
{
if (err) deferred.reject(err);
else deferred.resolve(result);
});
return deferred.promise;
}
Crazyradio.prototype.statusRequest = function()
{
var self = this,
deferred = P.defer();
this.device.controlTransfer(usb.LIBUSB_ENDPOINT_IN, 0x06, 0, 0, 128, function(err, data)
{
if (err)
return deferred.reject(err);
deferred.resolve(data);
});
return deferred.promise;
};
Copter.prototype.takeoff = function()
{
var self = this,
deferred = P.defer();
console.log('takeoff2()');
this.copterStates.takeoff();
function stopThrustingUp()
{
self.copterStates.stabilize();
deferred.resolve('OK');
}
this.flightTimer = setTimeout(stopThrustingUp, 2000);
return deferred.promise;
};
exports.write = function(bt, data)
{
if (!Buffer.isBuffer(data))
data = new Buffer(data);
var deferred = P.defer();
bt.write(data, function(err, written)
{
if (err)
return deferred.reject(err);
deferred.resolve(written);
});
return deferred.promise;
};
function getMusicById(id) {
var defer = P.defer();
request('https://www.googleapis.com/youtube/v3/videos?part=snippet&id=' + id + '&key=' + conf.apiKey,
function(err, response, res) {
if (err)
defer.reject(err);
else {
res = JSON.parse(res);
var musicSnippet = res.items[0].snippet;
musicSnippet.resourceId = {};
musicSnippet.resourceId.videoId = id;
getMusic(musicSnippet).then(function(res) {
defer.resolve(res);
});
}
});
return defer.promise;
}
Connection.prototype.start = function start(callback)
{
var self = this;
if (this.isReady())
return callback();
var deferred = P.defer(),
promise = deferred.promise;
if (this.password)
promise = promise.then(function() { return self.client.authenticateWith(self.password); });
this.client.once('ready', deferred.resolve).
once('error', deferred.reject);
self.client.connect().then(function() { return promise; }).then(function() { callback(null); }, callback).done();
};
Crazyradio.prototype.usbReceiveVendor = function(request, value, index, length)
{
var self = this,
deferred = P.defer();
this.device.controlTransfer(TYPE_VENDOR | usb.LIBUSB_ENDPOINT_IN, request, value, index, length, function(err, data)
{
if (err)
{
console.log('usbReceiveVendor error:', err);
return deferred.reject(err);
}
deferred.resolve(data);
});
return deferred.promise;
};
Crazyradio.prototype.usbSendVendor = function(request, value, index, data)
{
var self = this,
deferred = P.defer();
this.device.controlTransfer(TYPE_VENDOR, request, value, index, data, function(err, indata)
{
if (err)
{
console.log('usbSendVendor', err);
console.log(TYPE_VENDOR, request, value, index, data);
return deferred.reject(err);
}
// console.log('successful usbSendVendor', request);
deferred.resolve('OK');
});
return deferred.promise;
};
Mailer.prototype.send = function (message) {
log.trace({ op: 'mailer.send', email: message && message.to })
var d = P.defer()
this.mailer.sendMail(
message,
function (err, status) {
log.trace(
{
op: 'mailer.send.1',
err: err && err.message,
status: status && status.message,
id: status && status.messageId
}
)
return err ? d.reject(err) : d.resolve(status)
}
)
return d.promise
}
Crazyradio.prototype.close = function()
{
var self = this,
deferred = P.defer();
if (this.pingTimer)
clearTimeout(this.pingTimer);
this.interface.release(function(err)
{
if (err) deferred.reject(err);
this.device = null;
this.interface = null;
this.inEndpoint = null;
this.outEndpoint = null;
deferred.resolve('OK');
});
return deferred.promise;
};
p = p.then((function(i) { return function() {
var userid = "loady" + i + "@restmail.lcip.org";
var password = "******";
var salt = "AAAAAA";
var client = new Client();
var d = P.defer();
client.setupCredentials(userid, password, salt).then(
(function(userid, client, d) { return function() {
credentials[userid] = {
srp: client.srp,
email: client.email,
srpPw: client.srpPw,
unwrapBKey: client.unwrapBKey,
passwordSalt: client.passwordSalt
}
d.resolve(true);
};})(userid, client, d)
);
return d.promise;
};})(i));
function getVideo(videoSnippet) {
var defer = P.defer();
fs.exists(__dirname + '/videos/', function(exists) {
if (!exists) {
fs.mkdir(__dirname + '/videos/', function() {
getVideo(videoSnippet);
});
return;
}
var url = videoSnippet.resourceId.videoId;
var title = videoSnippet.title.replace(/ /g, '_').split('');
title = title.map(function(el) {
if (el.charCodeAt(0) < 48 || (el.charCodeAt(0) > 57 && el.charCodeAt(0) < 65) || el.charCodeAt(0) > 122)
return '';
else
return el;
});
title = title.join().replace(/,/g, '');
console.log(title);
var extension = '';
var video = youtubedl('http://www.youtube.com/watch?v=' + url,
// Optional arguments passed to youtube-dl.
['-f best'],
// Additional options can be given for calling `child_process.execFile()`.
{ cwd: __dirname,
maxBuffer: 250000*1024});
// Will be called when the download starts.
video.on('info', function(info) {
extension = info._filename.match(/\..{3,4}$/)[0];
console.log('Download started');
console.log('filename: ' + info._filename);
console.log('size: ' + info.size);
video.pipe(fs.createWriteStream(__dirname + '/videos/' + title + extension));
});
video.on('end', function() {
defer.resolve('/videos/' + title + extension);
});
});
return defer.promise;
}