constructor(source, defer, initFn) {
super(source, defer);
this.type = 'segmented';
// segmented request specific state
this._initFn = initFn;
this._desiredSize = null;
this._maxSegments = config.get('courier:maxSegmentCount');
this._direction = 'desc';
this._sortFn = null;
this._queueCreated = false;
this._handle = new SegmentedHandle(this);
this._hitWindow = null;
// prevent the source from changing between requests,
// all calls will return the same promise
this._getFlattenedSource = _.once(this._getFlattenedSource);
}
describe('integration', () => {
const getGraphqlSchema = once(() => createGraphqlSchema(PG_CONFIG, SCHEMA_NAME))
readdirSync(TEST_FIXTURES).forEach(fileName => {
if (path.extname(fileName) === '.graphql') {
const name = path.basename(fileName, '.graphql')
it(name, async () => {
const graphqlSchema = await getGraphqlSchema()
const graphQLPath = path.resolve(TEST_FIXTURES, fileName)
const jsonPath = path.resolve(TEST_FIXTURES, `${name}.json`)
const expectedData = JSON.parse(readFileSync(jsonPath, 'utf8'))
const client = await pg.connectAsync(PG_CONFIG)
// Begin a block.
await client.queryAsync('begin')
const data = await graphql(
graphqlSchema,
readFileSync(graphQLPath),
null,
{ client }
)
// End the block by rolling it back so mutations are not saved.
await client.queryAsync('rollback')
// Make sure to release our client!
client.end()
/* eslint-disable no-console */
if (data.errors)
data.errors.forEach(error => console.error(error.stack))
/* eslint-enable no-console */
assert.deepEqual(data, expectedData)
})
}
})
})
exports.open = function(callback) {
callback = callback || function(error, results) {
if (error)
console.log("ERROR opening SPI:", error);
else
console.log("READY: " + results);
};
SPI = fs.createWriteStream((process.env.NO_SPI ? '/dev/null' : '/dev/spidev0.0'), {flags: 'w', encoding: 'ascii'});
callback = _.once(callback || function() {});
SPI.once('open', function() {
SPI.write(RESET); // start it
callback(null, 'lightstrip ready', SPI);
});
SPI.once('error', function(e) {
callback(e);
});
SPI.on('error', function(e) {
console.log("lightstrip: SPI error!", e.toString());
});
SPI.on('drain', function(e) {
console.log('lightstrip: SPI buffer drained. Things can start writing again.');
waitForDrain = false;
});
// We're going to proxy the WriteStream's .write method with a function that basically ignores (drops) additional
// write requests until the frame or buffer backpressure subsides.
var realWrite = SPI.write;
SPI.write = function writeProxy(buffer, callback) {
if (skippingFrame || waitForDrain)
return false;
var completed = realWrite.call(SPI, buffer, callback);
if (!completed) {
skippingFrame = true; // ignore future pixel writes until backpressure is resolved
waitForDrain = true; // unlocked only on the drain event.
console.log('lightstrip: SPI buffer filled. Ignoring everything until buffer drained!');
}
return completed;
};
};
constructor(settings) {
this.name = pkg.name;
this.version = pkg.version;
this.build = pkg.build || false;
this.rootDir = rootDir;
this.settings = settings || {};
this.ready = constant(this.mixin(
require('./config/setup'), // sets this.config, reads this.settings
require('./http'), // sets this.server
require('./logging'),
require('./status'),
// find plugins and set this.plugins
require('./plugins/scan'),
// tell the config we are done loading plugins
require('./config/complete'),
// setup this.uiExports and this.bundles
require('../ui'),
// ensure that all bundles are built, or that the
// lazy bundle server is running
require('../optimize'),
// finally, initialize the plugins
require('./plugins/initialize'),
() => {
if (this.config.get('server.autoListen')) {
this.ready = constant(resolve());
return this.listen();
}
}
));
this.listen = once(this.listen);
}
gulp.task('watch', function () {
var doWatch = _.once(function () {
// separate watcher for browserification
gulp.watch('./client/**', [ 'browserify' ]);
// watcher for restarting app
var nodemonOpts = {
script: 'index.js',
ext: 'js hbs',
env: { 'NODE_ENV': 'development' },
ignore: [
'./node_modules/**',
'./client/**'
],
nodeArgs: ['--debug']
};
nodemon(nodemonOpts)
.on('restart', function () {
gutil.log('watcher restarted server');
});
});
gulp.start('clean', 'bootstrap-copy', 'browserify', doWatch);
});
QUnit.test('`lodash ' + command +'`', function(assert) {
var counter = 0,
dirs = _.includes(command, 'c.js'),
done = assert.async(),
expected = /(\w+)(?=\.js$)/.exec(command)[0];
var start = _.after(2, _.once(function() {
if (dirs) {
fs.rmrfSync(outputPath);
}
process.chdir(cwd);
done();
}));
process.chdir(__dirname);
build(command.split(' '), function(data) {
var basename = path.basename(data.outputPath, '.js');
assert.strictEqual(basename, expected + (counter++ ? '.min' : ''), command);
start();
});
});
function(chunk, enc, cb) {
const cbOnce = _.once(cb);
try {
request({
url: config.stateServerUrl,
qs: { apiKey: config.apiKey },
json: true,
method: 'POST',
body: formattedPacket
})
.then(result => console.log('request result: ' + result) && result)
.then(cbOnce);
} catch (e) {
console.error('Error saving to DB');
console.error(e);
cbOnce();
}
},
var defaultListeners = function(child, args, callback) {
callback = callback || function(err) { console.error(err); };
callback = _.once(callback);
if (args.encodingStderr !== 'buffer') child.stderr.setEncoding(args.encodingStderr || 'utf8');
if (args.encodingStdout) child.stdout.setEncoding(args.encodingStdout);
//else if (args.printStdout && !args.encodingStdout) child.stdout.setEncoding('utf8');
//if (args.printStdout) child.stdout.pipe(process.stdout);
if (args.encodingStderr !== 'buffer') child.stderr.pipe(process.stderr);
//child.stdin.on('finish', function() {});
child.stdin.on('error', function(err) {
callback(err);
});
child.on('error', function(err) {
callback(err);
});
};
QUnit.test('`lodash ' + command +'`', function(assert) {
var done = assert.async(),
start = _.after(2, _.once(done));
build(command.split(' '), function(data) {
var actualId,
basename = path.basename(data.outputPath, '.js'),
context = createContext('amd');
context.define = function(id, factory) {
actualId = id;
context._ = factory();
};
context.define.amd = {};
vm.runInContext(data.source, context);
assert.strictEqual(actualId, expectedId, basename);
assert.ok(_.isFunction(context._), basename);
start();
});
});
function run(task) {
running += 1;
task(_.once(function (err, data) {
if (err) {
console.error(err);
failures.push(err);
} else {
results.push(data);
}
bar.tick();
waiting -= 1;
running -= 1;
if (waiting <= 0) {
// console.log('fin!', failures, results);
console.log('Took', (Date.now() - start)/1000/60, 'minutes');
return done(failures, results);
}
process.nextTick(function () {
advance();
});
}));
}
var createGetRemixWhiteboardActivities = module.exports.createGetRemixWhiteboardActivities = function(ctx, asset, metadata, callback) {
var done = _.after(asset.users.length, callback);
var errorCallback = _.once(callback);
_.each(asset.users, function(user) {
// If the user is among the asset creators, skip activity creation for that user only.
if (user.id === ctx.user.id) {
return done();
}
ActivitiesAPI.createActivity(ctx.course, user, 'get_remix_whiteboard', asset.id, CollabosphereConstants.ACTIVITY.OBJECT_TYPES.ASSET, metadata, ctx.user, function(err) {
if (err) {
log.error({
'err': err,
'user': user.id,
'asset': asset.id
}, 'Failed to create a get_remix_whiteboard activity');
return errorCallback(err);
}
return done();
});
});
};
setupWatching(extraPaths, extraIgnores) {
const chokidar = require('chokidar');
const { fromRoot } = require('../../utils');
const watchPaths = [
fromRoot('src/core_plugins'),
fromRoot('src/server'),
fromRoot('src/ui'),
fromRoot('src/utils'),
fromRoot('x-pack/common'),
fromRoot('x-pack/plugins'),
fromRoot('x-pack/server'),
fromRoot('x-pack/webpackShims'),
fromRoot('config'),
...extraPaths
].map(path => resolve(path));
this.watcher = chokidar.watch(uniq(watchPaths), {
cwd: fromRoot('.'),
ignored: [
/[\\\/](\..*|node_modules|bower_components|public|__[a-z0-9_]+__|coverage)[\\\/]/,
/\.test\.js$/,
...extraIgnores
]
});
this.watcher.on('add', this.onWatcherAdd);
this.watcher.on('error', this.onWatcherError);
this.watcher.on('ready', once(() => {
// start sending changes to workers
this.watcher.removeListener('add', this.onWatcherAdd);
this.watcher.on('all', this.onWatcherChange);
this.log.good('watching for changes', `(${this.addedCount} files)`);
this.startCluster();
}));
}
function prodWorker(done) {
const callback = _.once(done);
if (!worker) {
return process.nextTick(() => callback('noworker'));
}
const timeout = setTimeout(() => callback('timeout'), 1000);
onWorkerReady(() => {
clearTimeout(timeout);
// send a message to the worker to start bundling js
worker.send('production');
worker.on('message', message => {
if (message === 'done') {
worker.kill();
callback();
}
});
});
worker.on('close', () => callback('noworker'));
}
Utils.parseBody = function(stream, options, callback) {
callback = _.once(callback);
var data = '';
stream.setEncoding('utf8');
stream.on('data', function(str) {
data += str;
});
stream.on('error', function(err) {
callback(err);
});
stream.on('end', function() {
utils.JSON.parse(data, options, function(err, request) {
if(err) return callback(err);
callback(null, request);
});
});
};
checkEmptyState = (() => {
const showNotification = _.debounce(_.once(() => {
const info = $('<p>').text(i18n('filteRedditEmptyNotificationInfo'));
const toggle = $('<button>').text(i18n('filteRedditEmptyNotificationToggleShowReason'))
.click(() => { this.toggleDisplayReasons(); });
Notifications.showNotification({
moduleID: FilteReddit.module.moduleID,
notificationID: 'everyThingHidden',
header: i18n('filteRedditEmptyNotificationHeader'),
message: $('<div>').append(info).append(toggle).get(0),
closeDelay: Infinity,
});
}), 3000);
return () => {
if (Array.from(this.things).filter(v => v.isVisible()).length) {
showNotification.cancel();
} else if (!this.displayReasons) {
showNotification();
}
};
})();
QUnit.test('`lodash exports=amd' + (command ? ' ' + command + '`' : '` using the default `moduleId`'), function(assert) {
var done = assert.async(),
start = _.after(2, _.once(done));
build(['template=' + path.join(templatePath, '*.jst'), 'exports=amd'].concat(command || []), function(data) {
var actualId,
basename = path.basename(data.outputPath, '.js'),
context = createContext('amd');
context.define = function(requires, factory) {
factory(_);
actualId = requires[0];
};
context.define.amd = {};
vm.runInContext(data.source, context);
assert.strictEqual(actualId, expectedId, basename);
delete _.templates;
start();
});
});
constructor(uiExports, spec) {
this.uiExports = uiExports;
this.spec = spec || {};
this.id = this.spec.id;
if (!this.id) {
throw new Error('Every app must specify it\'s id');
}
this.main = this.spec.main;
this.title = this.spec.title;
this.description = this.spec.description;
this.icon = this.spec.icon;
this.hidden = this.spec.hidden;
this.autoloadOverrides = this.spec.autoload;
this.templateName = this.spec.templateName || 'uiApp';
// once this resolves, no reason to run it again
this.getModules = _.once(this.getModules);
// variables that are injected into the browser, must serialize to JSON
this.getInjectedVars = this.spec.injectVars || _.noop;
}
QUnit.test('`lodash modularize include=partial exports=node`', function(assert) {
var done = assert.async();
var start = _.once(function() {
process.chdir(cwd);
done();
});
setup();
build(['modularize', 'include=partial', 'exports=node', '-o', outputPath], function() {
emptyObject(require.cache);
var modulePath = path.join(outputPath, 'partial');
var lodash = {};
lodash.partial = require(modulePath);
assert.deepEqual(lodash.partial.placeholder, {}, 'should have a `placeholder` property');
testMethod(assert, lodash, 'partial');
start();
});
});
checkEmptyState = (() => {
const showNotification = _.debounce(_.once(() => {
const info = $('<p>').text(i18n('filteRedditEmptyNotificationInfo'));
const toggle = $('<button>').text(i18n('filteRedditEmptyNotificationToggleShowReason'))
.click(() => { this.toggleShowFilterReason(); });
Notifications.showNotification({
moduleID: FilteReddit.module.moduleID,
notificationID: 'everyThingHidden',
header: i18n('filteRedditEmptyNotificationHeader'),
message: $('<div>').append(info).append(toggle).get(0),
closeDelay: Infinity,
});
}), 4000);
return _.throttle(() => {
if (this.getFiltered().length !== this.things.size) {
showNotification.cancel();
} else if (!this.showFilterReason) {
showNotification();
}
}, 100, { leading: false });
})();
Utils.parseStream = function(stream, options, onRequest) {
var onError = _.once(onRequest);
var onSuccess = _.partial(onRequest, null);
var result = JSONStream.parse();
result.on('data', function(data) {
// apply reviver walk function to prevent stringify/parse again
if(_.isFunction(options.reviver)) {
data = Utils.walk({'': data}, '', options.reviver);
}
onSuccess(data);
});
result.on('error', onError);
stream.on('error', onError);
stream.pipe(result);
};
return function (callback) {
var filename = browser + '-' + name + '.png';
var target = path.join(dict.get('currentPath'), filename);
var driver = wd.remote();
callback = _.once(callback);
driver.init({browserName: browser}, function (err) {
if (err) {
return callback(err);
}
driver.get(url, function (err) {
if (err) {
return callback(err);
}
driver.saveScreenshot(target, function (err) {
if (err) {
return callback(err);
}
driver.quit();
callback();
});
});
});
};
next(null, function(flowScope, message, content, cb) {
debug('Running uploadToS3 middleware')
var done = _.once(cb)
if (!flowScope.qs3.hasOwnProperty('s3id')) return cb(new Error('An s3 id is required'))
debug('Uploading %d bytes to bucket: %s and key: %s', message.content.length, config.bucket, flowScope.qs3.s3id)
s3Client.putObject({
Bucket: config.bucket,
Key: flowScope.qs3.s3id,
Body: message.content,
ContentDisposition: message.properties.headers.contentDisposition,
ContentType: message.properties.contentType
}, function(err) {
err ? done(recoverable(err)) : done()
}).on('error', function(err) {
debug('Error uploading message to bucket: %s and key: %s', config.bucket, flowScope.qs3.s3id)
done(recoverable(err))
})
})
QUnit.test('module aliases for `exports=node`', function(assert) {
var done = assert.async();
var start = _.once(function() {
process.chdir(cwd);
done();
});
setup();
build(['modularize', 'exports=node', '-o', outputPath], function() {
emptyObject(require.cache);
var lodash = require(outputPath);
_.each(categories, function(category) {
var funcNames = mapping.category[_.capitalize(category)],
object = require(path.join(outputPath, category));
_.each(funcNames, function(funcName) {
var aliases = _.without(getAliases(funcName), 'wrapperLodash');
_.each(aliases, function(alias) {
var objects = [(category == 'seq' ? lodash.prototype : lodash), object];
_.each(objects, function(object, index) {
var value = (!index && alias == 'toIterator')
? object[Symbol.iterator]
: object[alias];
assert.ok(_.isFunction(value), '`' + alias + '` is an alias of `' + funcName + '`');
});
});
});
});
start();
});
});
return function(req, res, next){
next = _.once(next);
var cbf = function(err, data){
if(err){
next(err);
return;
}
if(res.headersSent){
err = new Error('the header has been sent');
err.msg = '该请求已经发送';
console.error(err);
return;
}
if(data){
if(template){
res.locals.TEMPLATE = template;
render(res, template, data, next);
}else{
if(_.isObject(data)){
json(res, data, next);
}else{
response(res, data, next);
}
}
}else{
res.send('');
}
};
var d = domain.create();
d.on('error', function(err){
next(err);
});
d.run(function(){
handler(req, res, cbf);
});
};
/**
* Load msgs not send and send it back or throw it do deadQueue
*/
function processFailures() {
var now = Date.now();
var cb = _.once(function () {
setTimeout(processFailures, properties.sendTimeout + 1000); // 1000 is to avoid running again before all responses were processed
});
var stream = db.createReadStream({end: {time: now - properties.sendTimeout}});
stream.on('data', function (data) {
if (queueConcurrentSend > properties.maxQueueConcurrentSend) {
stream.pause();
}
if ((data.value.sendAt + properties.sendTimeout) < now) { // if we need to re-send
if (data.key.time + properties.maxTimeout < now) { // too old, send to dead queue
queueConcurrentSend++;
internalSend(cid, properties.deadQueue, data.key, data.value.msg, function () {
queueConcurrentSend--;
if (queueConcurrentSend === (properties.maxQueueConcurrentSend/2)) stream.resume();
});
} else {
internalSend(data.value.msg.from, data.value.msg.to, data.key, data.value.msg, function () {
queueConcurrentSend--;
if (queueConcurrentSend === (properties.maxQueueConcurrentSend/2)) stream.resume();
});
}
}
});
stream.on('error', function (err) {
logger.warn('Read stream error : ', err);
cb();
});
stream.on('end', cb);
stream.on('close', cb);
}
return (options, callback) => {
options = options || {};
if (!options.appGuid && options.name && api.actualDeploymentConfig) {
var a = _.find(api.actualDeploymentConfig.apps, { name: options.name });
if (a) {
options.appGuid = a.guid;
}
}
if (!options.appGuid) {
return callback(new Error('Please provide an appGuid! \n' + JSON.stringify(options, null, 2)));
}
options.startTimeout = options.startTimeout || 120; //seconds
var timer;
const clb = _.once((err, res) => {
clearTimeout(timer);
if (err) return callback(err);
callback(null, res);
});
timer = setTimeout(() => {
clb(new Error(`Starting for app ${options.name || options.appGuid} took longer than ${options.startTimeout} seconds!`));
}, 1000 * options.startTimeout);
options.onReady = () => {
api.startApp({ appGuid: options.appGuid, name: options.name }, (err) => {
if (err) {
debug(err);
api.startApp({ appGuid: options.appGuid, name: options.name }, _.noop);
}
});
};
api.tailAppLogsAndWaitFor(options, clb);
};
var attrs = function() {
// we need to iterate the class hierarchy ourselves because we've defined
// specific requirements around the preferring attributes that are defined
// later. _.keysIn and for/in will not get us the desired order.
var hierarchy = function(cls) { // jscs:ignore jsDoc
var result = [];
while (cls) { result.unshift(cls); cls = cls.__super__; }
return result;
};
// return the function with the value locked in
return _.once(function() {
var regex = /(.*)Attr$/;
return _(hierarchy(this))
.map('__class__.prototype') // get all prototypes
.map(_.keys).flatten() // get all keys
.invoke('match', regex).map(0).filter() // find attrs
.reverse() // reverse to prefer later attrs in unique
.uniq(_.propertyOf(this.__class__.prototype)) // unique based on dbattr
.invoke('match', regex).map(1) // get the real attr name
.reverse().value(); // return to normal order
});
};
QUnit.test('`lodash settings=...' + (command ? ' ' + command : '') + '`', function(assert) {
var done = assert.async(),
start = _.after(2, _.once(done));
build(['template=' + path.join(templatePath, '*.tpl'), 'settings={interpolate:/{{([\\s\\S]+?)}}/}'].concat(command || []), function(data) {
var actualId,
basename = path.basename(data.outputPath, '.js'),
context = createContext('amd');
context.define = function(requires, factory) {
factory(_);
actualId = requires[0];
};
context.define.amd = {};
vm.runInContext(data.source, context);
assert.strictEqual(actualId, expectedId, basename);
assert.strictEqual(_.templates.f({ 'name': 'mustache' }), 'hall\xe5 mustache!', basename);
delete _.templates;
start();
});
});
return fromNode(cb => {
const timeout = setTimeout(() => {
cb(new Error('Server timedout waiting for the optimizer to become ready'));
}, config.get('optimize.lazyProxyTimeout'));
const waiting = once(() => {
server.log(['info', 'optimize'], 'Waiting for optimizer completion');
});
if (!process.connected) return;
process.send(['WORKER_BROADCAST', { optimizeReady: '?' }]);
process.on('message', (msg) => {
switch (get(msg, 'optimizeReady')) {
case true:
clearTimeout(timeout);
cb();
break;
case false:
waiting();
break;
}
});
});
importObj.getStream = function(source, callback) {
var stream, response, callback = _.once(callback);
stream = response = needle.get(source.url, {
follow_max: 4, open_timeout: 5000,
headers: { "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.99 Safari/537.36" }
}).on("headers", function(headers) {
var filename = headers["content-disposition"] || url.parse(source.url).pathname;
var detectedType = "generic";
if (headers["content-type"] && headers["content-type"].match("xml")) detectedType = "xmlRss";
if (headers["content-type"] && headers["content-type"].match("json")) detectedType = "json";
if (filename.match(".txt.gz$")) detectedType = "dump";
if (["json", "xmlRss"].indexOf(detectedType) == -1) stream = stream.pipe(gunzip()).pipe(gunzip()); // Some sources can be gunzipped twice (one for request, another for being a .txt.gz)
stream.on("end", function() { response.end() }); // make sure response is closed
callback(null, stream, detectedType);
}).on("error", function(e) { callback(e) })
.on("end", function() {
// TODO: we can check statusCode / etc?
callback(new Error("empty response / couldn't detect type"));
importObj.emit('linkError', source);
})
};