function handleZoneFaultOK(zone) {
if (zones[zone] !== zoneStatus.FAULT_OK) {
logger.info('Zone ' + zone + ' changed to FAULT RESTORED');
zones[zone] = zoneStatus.FAULT_OK;
}
}
function(proc) {
logger.info('Created tunnel from ' +
this.deviceSerial_ + ':' + this.pacUrlPort_ + ' to :' +
this.pacServerPort_);
this.pacForwardProcess_ = proc;
}.bind(this));
function handleZoneTamper(zone) {
if (zones[zone] !== zoneStatus.TAMPER) {
logger.info('Zone ' + zone + ' changed to TAMPER');
zones[zone] = zoneStatus.TAMPER;
}
}
static * createStory(data){
//if user is logged. this param is add by api-gateway
if (data.loggedUser) {
data.userId = data.loggedUser.id;
if(data.hideUser === true) {
logger.info('Hide User. Removing name and email');
data.name = '';
data.email = '';
}
}
let story = yield cartoDBService.createStory(data);
logger.debug('Saving new story in cache', story);
let storyFormat = StoryService.formatStory(story);
yield new Story(storyFormat).save();
logger.debug('Checking if email is defined to send email');
if(data.loggedUser){
let language = 'en';
let user = null;
if (data.loggedUser) {
logger.info('Obtaining user', '/user/' + data.loggedUser.id);
try {
let result = yield ctRegisterMicroservice.requestToMicroservice({
uri: '/user/' + data.loggedUser.id,
method: 'GET',
json: true
});
user = yield deserializer(result);
if (user.language) {
logger.info('Setting user language to send email');
language = user.language.toLowerCase().replace(/_/g, '-');
}
} catch(e) {
logger.error('error obtaining user',e);
}
}
let template = `${config.get('mailStory.template')}-${language}`;
mailService.sendMail(template, {
name: storyFormat.name,
story_url: config.get('mailStory.myStories')
},[{
address: user.email
}]);
logger.info('Email sended to user with template', template);
}
logger.info('sending email to WRI');
let wriRecipients = config.get('wriMailStory.recipients').split(',');
wriRecipients = wriRecipients.map(function(mail){
return {
address: mail
};
});
mailService.sendMail(config.get('wriMailStory.template'), {
story_url: config.get('mailStory.urlDetail') + storyFormat.id
},wriRecipients);
return StorySerializer.serialize(storyFormat);
}
.listen(APP_PORT, () => {
logger.info(`
Server connected at "${APP_PORT}";
Environment "${NODE_ENV.toUpperCase()}";
`);
});
Agent.prototype.startJobRun_ = function(job) {
'use strict';
job.isCacheWarm = !!this.wdServer_;
logger.info('Running job %s run %d/%d cacheWarm=%s',
job.id, job.runNumber, job.runs, job.isCacheWarm);
this.scheduleCleanRunTempDir_();
if (!this.wdServer_) {
if (job.isReplay) {
if (job.runNumber === 0) {
this.webPageReplay_.scheduleStop(); // Force-stop WPR before we begin.
this.webPageReplay_.scheduleRecord();
} else {
this.webPageReplay_.scheduleReplay();
}
} else if (job.runNumber === 1) { // WPR not requested, just force-stop it.
process_utils.scheduleNoFault(
this.app_, 'Stop WPR just in case, ignore failures', function() {
this.webPageReplay_.scheduleStop();
}.bind(this));
}
this.startTrafficShaper_(job);
this.startWdServer_(job);
}
var script = job.task.script;
var url = job.task.url;
var pac;
if (script && !/new\s+(\S+\.)?Builder\s*\(/.test(script)) {
var urlAndPac = this.decodeUrlAndPacFromScript_(script);
url = urlAndPac.url;
pac = urlAndPac.pac;
script = undefined;
}
url = url.trim();
if (!((/^https?:\/\//i).test(url))) {
url = 'http://' + url;
}
this.scheduleNoFault_('Send IPC "run"', function() {
var isRecordingRun = 0 === job.runNumber;
var message = {
cmd: 'run',
options: {browserName: job.task.browser},
runNumber: job.runNumber,
exitWhenDone: job.isFirstViewOnly || job.isCacheWarm || isRecordingRun,
// Suppress video capture on WPR recording.
captureVideo: job.captureVideo && !isRecordingRun,
// Suppress packet capture on WPR recording.
capturePackets: job.capturePackets && !isRecordingRun,
// Suppress JPEG conversion on WPR recording.
pngScreenShot: !!job.task.pngScreenShot || isRecordingRun,
imageQuality: job.task.imageQuality,
// Suppress Timeline capture on WPR recording.
captureTimeline: !!job.task.timeline && !isRecordingRun,
timelineStackDepth: job.task.timelineStackDepth,
script: script,
url: url,
pac: pac,
timeout: this.client_.jobTimeout,
runTempDir: this.runTempDir_
};
Object.getOwnPropertyNames(this.flags_).forEach(function(flagName) {
if (!message[flagName]) {
message[flagName] = this.flags_[flagName];
}
}.bind(this));
this.wdServer_.send(message);
}.bind(this));
};
this.wdServer_.on('exit', function(code, signal) {
logger.info('wd_server child process exit code %s signal %s', code, signal);
this.wdServer_ = undefined;
}.bind(this));
proc.stdout.on('data', function(data) {
logger.info('WD STDOUT: %s', data);
});
static * runSubcriptionQuery(subscription, queryType) {
logger.info('Iterate over datasetsQuery of each subs');
const queryData = [];
for (let j = 0; j < subscription.datasetsQuery.length; j++) {
try {
const datasetQuery = subscription.datasetsQuery[j];
// for each subs, each dataset query -> get dataset, get geostoreId from area and finally exec the desired query
const dataset = yield DatasetService.getDataset(datasetQuery.id);
if (!dataset) {
logger.error('Error getting dataset of subs');
continue;
}
// geostore from different sources
let geostoreId = null;
if (subscription.params.area) {
geostoreId = yield DatasetService.getGeostoreIdByArea(subscription.params.area);
} else if (subscription.params.geostore) {
geostoreId = subscription.params.geostore;
} else {
geostoreId = yield DatasetService.getGeostoreIdByParams(subscription.params);
}
if (!geostoreId) {
logger.error('Error getting geostore of area');
continue;
}
const result = yield DatasetService.executeQuery(dataset.subscribable[datasetQuery.type][queryType], datasetQuery.lastSentDate, new Date(), geostoreId, dataset.tableName, datasetQuery.threshold);
// for data endpoint
if (queryType === 'dataQuery') {
const queryDataObject = {};
queryDataObject[`${datasetQuery.id}`] = {
type: datasetQuery.type,
timestamp: datasetQuery.lastSentDate,
data: result.data
};
queryData.push(queryDataObject);
continue; // not sending emails if dataQuery
}
if (!result) {
logger.error('Error processing subs query');
continue;
} else {
logger.debug('Result: ', result);
try {
if (result.data && result.data.length === 1 && result.data[0].value && result.data[0].value > 0) {
// getting metadata first
const metadata = yield DatasetService.getMetadata(datasetQuery.id, subscription.application, subscription.language);
// sending mail
if (subscription.resource.type === 'EMAIL') {
const areaName = subscription.params.area ? yield DatasetService.getAreaName(subscription.params.area) : '';
const data = {
subject: subscription.name ? subscription.name : `${datasetQuery.type} in ${areaName} above ${datasetQuery.threshold}`,
datasetName: dataset.name,
datasetId: datasetQuery.id,
datasetSummary: metadata[0].attributes.info.functions,
areaId: subscription.params.area ? subscription.params.area : '',
areaName: areaName,
alertName: subscription.name ? subscription.name : `${datasetQuery.type} in ${areaName} above ${datasetQuery.threshold}`,
alertType: datasetQuery.type,
alertBeginDate: datasetQuery.lastSentDate.toISOString().slice(0, 10),
alertEndDate: new Date().toISOString().slice(0, 10),
alertResult: result.data[0].value
};
logger.debug('Sending mail with data', data );
let template = 'dataset';
if (subscription.env && subscription.env !== 'production') {
template += `-${subscription.env}`;
}
MailService.sendMail(template, data, [{ address: subscription.resource.content }], 'rw'); // sender='rw'
} else {
// @TODO resource.type === 'WEBHOOK'?
}
// update subs
if (dataset.mainDateField) {
subscription.datasetsQuery[j].lastSentDate = yield DatasetService.getLastDateFromDataset(dataset.slug, dataset.mainDateField);
} else {
subscription.datasetsQuery[j].lastSentDate = new Date();
}
subscription.datasetsQuery[j].historical = subscription.datasetsQuery[j].historical.concat([{
value: result.data[0].value,
date: new Date()
}]);
yield subscription.save();
logger.debug('Finished subscription');
}
} catch (e) {
logger.error(e);
continue;
}
}
} catch (e) {
logger.error(e);
}
}
if (queryType === 'dataQuery') {
return queryData;
}
}
_.each(users, user => {
if (!user.push || !user.push.token) return;
logger.info('Sending push to user', user.id, user.firstName, user.lastName);
push.send(MESSAGE, user.push.token, user.push.type);
});
static * getSubnational() {
logger.info('Obtaining subnational data');
let data = yield CartoDBService.getSubnational(this.params.iso, this.params.id1, this.query.alertQuery, this.query.period);
this.body = QuiccAlertsSerializer.serialize(data);
}
function handleZoneFault(zone) {
if (zones[zone] !== zoneStatus.FAULT) {
logger.info('Zone ' + zone + ' changed to FAULT');
zones[zone] = zoneStatus.FAULT;
}
}
function handleZoneAlarmOK(zone) {
if (zones[zone] !== zoneStatus.ALARM_OK) {
logger.info('Zone ' + zone + ' changed to ALARM RESTORED');
zones[zone] = zoneStatus.ALARM_OK;
}
}
BrowserAndroidChrome.prototype.onChildProcessExit = function() {
'use strict';
logger.info('chromedriver exited, resetting WD server URL');
this.serverUrl_ = undefined;
};
spawnStub.callback = function(proc, command) {
logger.info('Stub spawn: %s', command);
if ('kill' === command) {
numKilled += 1;
}
};
static * latest() {
logger.info('Obtaining latest data');
let data = yield CartoDBService.latest(this.query.limit);
this.body = QuiccAlertsSerializer.serializeLatest(data);
}
static * wdpa() {
logger.info('Obtaining wpda data with id %s', this.params.id);
let data = yield CartoDBService.getWdpa(this.params.id, this.query.alertQuery, this.query.period);
this.body = QuiccAlertsSerializer.serialize(data);
}
this.proxyProcess_.on('exit', function(code, signal) {
logger.info('Proxy EXIT code %s signal %s', code, signal);
this.proxyProcess_ = undefined;
this.devToolsUrl_ = undefined;
}.bind(this));
(responses, done) => {
logger.info(`Processed ${responses.length} responses`);
let usersIds = _.chain(responses).pluck('userId').unique().value();
User.listIndex('id', usersIds, done);
},
request.execute(function(resp) {
logger.info("Prediction response " + JSON.stringify(resp));
if (predictedCallback) {
predictedCallback(resp)
}
});
static async get(ctx){
logger.info('Obtaining all films');
ctx.body = films;
}
request.execute(function(resp) {
logger.info("Prediction response " + JSON.stringify(resp));
});
//load custom validator
app.use(validate());
//load routes
loader.loadRoutes(app);
//Instance of http module
var server = require('http').Server(app.callback());
// get port of environment, if not exist obtain of the config.
// In production environment, the port must be declared in environment variable
var port = process.env.PORT || config.get('service.port');
server.listen(port, function () {
const microserviceClient = require('vizz.microservice-client');
microserviceClient.register({
id: config.get('service.id'),
name: config.get('service.name'),
dirConfig: path.join(__dirname, '../microservice'),
dirPackage: path.join(__dirname, '../../'),
logger: logger,
app: app
});
if (process.env.CT_REGISTER_MODE && process.env.CT_REGISTER_MODE === 'auto') {
microserviceClient.autoDiscovery(config.get('service.name'));
}
});
logger.info('Server started in port:' + port);
static* getIFLNational() {
logger.info('Obtaining ifl national data');
const thresh = this.query.thresh || '30';
let data = yield CartoDBService.getIFLNational(this.params.iso, thresh);
this.body = UMDIFLSerializer.serialize(data);
}
proc.on('exit', function(code, signal) {
logger.info('WD EXIT code %s signal %s', code, signal);
this.childProcess_ = undefined;
this.serverUrl_ = undefined;
this.devToolsUrl_ = undefined;
}.bind(this));
}).then(function(){
logger.info('All correct!!!');
process.exit(0);
}, function(e){
function handleZoneAlarm(zone) {
if (zones[zone] !== zoneStatus.ALARM) {
logger.info('Zone ' + zone + ' changed to ALARM');
zones[zone] = zoneStatus.ALARM;
}
}
function handleZoneOK(zone) {
if (zones[zone] !== zoneStatus.OK) {
logger.info('Zone ' + zone + ' changed to OK');
zones[zone] = zoneStatus.OK;
}
}
function handleZoneOpen(zone) {
if (zones[zone] !== zoneStatus.OPEN) {
logger.info('Zone ' + zone + ' changed to OPEN');
zones[zone] = zoneStatus.OPENl
}
}
/**
* Constructs a Chrome Mobile controller for Android.
*
* @param {webdriver.promise.ControlFlow} app the ControlFlow for scheduling.
* @param {Object} args browser options:
* #param {string} runNumber test run number. Install the apk on run 1.
* #param {string=} runTempDir the directory to store per-run files like
* screenshots, defaults to ''.
* #param {boolean} isCacheWarm true for repeat view, false for first view.
* Determines if browser cache should be cleared.
* #param {Object.<string>} flags options:
* #param {string} deviceSerial the device to drive.
* #param {string=} captureDir capture script dir, defaults to ''.
* #param {string=} checknet 'yes' to enable isReady network check.
* #param {string=} chrome Chrome.apk to install, defaults to None.
* #param {string=} chromeActivity activity without the '.Main' suffix,
* defaults to 'com.google.android.apps.chrome'.
* #param {string=} devToolsPort DevTools port, defaults to dynamic
* selection.
* #param {string=} maxtemp maximum isReady temperature.
* #param {string=} videoCard the video card identifier, defaults to None.
* #param {Object.<string>} task options:
#param {string=} addCmdLine additional chrome command-line flags.
* #param {string=} browser browser name, defaults to 'Chrome'.
* #param {string=} pac PAC content, defaults to None.
* @constructor
*/
function BrowserAndroidChrome(app, args) {
'use strict';
browser_base.BrowserBase.call(this, app);
logger.info('BrowserAndroidChrome(%j)', args);
this.deviceSerial_ = args.flags['deviceSerial'];
this.workDir_ = args.workDir || '';
var lastInstall = undefined;
this.device_status_file_ = 'device_status_' + this.deviceSerial_ + '.json';
try {
lastInstall = fs.readFileSync(path.join(this.workDir_, LAST_INSTALL_FILE));
} catch(e) {}
this.apk_packages_ = args.task['apk_info'] ? args.task.apk_info['packages'] : undefined;
this.shouldUninstall_ = true;
this.shouldInstall_ =
args.customBrowser && (args.customBrowser != lastInstall);
if (this.shouldInstall_)
logger.debug('Browser install for "' + args.customBrowser +
'" needed. Last install: "' + lastInstall + '"');
this.chrome_ = args.customBrowser || args.flags.chrome; // Chrome.apk.
this.chromedriver_ = args.flags.chromedriver;
this.supportsTracing = true;
this.isBlackBox = false;
this.videoFlags = undefined;
this.browserConfig_ = undefined;
this.activityFlags_ = undefined;
this.browserPackage_ = args.task.customBrowser_package ||
this.browserPackage_ || 'com.android.chrome';
this.browserActivity_ = args.task.customBrowser_activity ||
args.chromeActivity || this.browserActivity_ ||
'com.google.android.apps.chrome.Main';
if (args.task['customBrowser_type'] !== undefined && BLACK_BOX_BROWSERS[args.task['customBrowser_type']] !== undefined)
args.task.browser = args.task['customBrowser_type'];
if (args.task.browser) {
var browserName = args.task.browser;
var separator = browserName.lastIndexOf('-');
if (separator >= 0) {
browserName = browserName.substr(separator + 1).trim();
}
logger.debug('Looking for browser "' + browserName + '"');
this.browserPackage_ = args.task.customBrowser_package || KNOWN_BROWSERS[browserName] || this.browserPackage_ ;
if (BLACK_BOX_BROWSERS[browserName] != undefined) {
this.browserPackage_ = args.task.customBrowser_package || BLACK_BOX_BROWSERS[browserName].package;
this.browserActivity_ = BLACK_BOX_BROWSERS[browserName].activity;
this.blank_page_ = args.flags.blankPage ||
'http://api.webpagetest.org/blank.html';
this.isBlackBox = true;
this.supportsTracing = false;
this.browserConfig_ = BLACK_BOX_BROWSERS[browserName];
if (BLACK_BOX_BROWSERS[browserName]['videoFlags'] != undefined)
this.videoFlags = BLACK_BOX_BROWSERS[browserName].videoFlags;
if (BLACK_BOX_BROWSERS[browserName]['activityFlags'] != undefined)
this.activityFlags_ = BLACK_BOX_BROWSERS[browserName]['activityFlags'];
}
}
this.blank_page_ = this.blank_page_ || args.startURL || 'about:blank';
this.flagsFile_ = args.task.customBrowser_flagsFile ||
args.flagsFile || '/data/local/chrome-command-line';
this.devToolsPort_ = args.flags.devToolsPort;
this.devToolsSocket_ = args.task.customBrowser_socket ||
args.devToolsSocket || DEVTOOLS_SOCKET;
this.devtoolsPortLock_ = undefined;
this.devToolsUrl_ = undefined;
this.hostsFile_ = args.task.hostsFile;
this.serverPort_ = args.flags.serverPort;
this.serverPortLock_ = undefined;
this.serverUrl_ = undefined;
this.pac_ = args.task.pac;
this.pacFile_ = undefined;
this.maxTemp = args.flags.maxtemp ? parseFloat(args.flags.maxtemp) : 0;
this.checkNet = 'yes' === args.flags.checknet;
this.rndis = args.flags['rndis'] !== undefined ? args.flags['rndis'] : undefined;
if (args.flags['rndis444'] !== undefined)
this.rndis = args.flags['rndis444'];
this.deviceVideoPath_ = undefined;
this.recordProcess_ = undefined;
function toDir(s) {
return (s ? (s[s.length - 1] === '/' ? s : s + '/') : '');
}
var captureDir = toDir(args.flags.captureDir);
this.adb_ = new adb.Adb(this.app_, this.deviceSerial_);
this.videoFile_ = undefined;
this.pcap_ = new packet_capture_android.PacketCaptureAndroid(this.app_, args);
this.runTempDir_ = args.runTempDir || '';
this.useXvfb_ = undefined;
this.chromeFlags_ = CHROME_FLAGS.slice();
this.additionalFlags_ = args.task.addCmdLine;
if (args.task.ignoreSSL) {
this.chromeFlags_.push('--ignore-certificate-errors');
}
this.isCacheWarm_ = args.isCacheWarm;
this.remoteNetlog_ = undefined;
this.netlogEnabled_ = args.task['netlog'] ? true : false;
this.lastVideoSize_ = 0;
this.videoStarted_ = false;
this.videoIdleCount_ = 0;
this.osVersion = undefined;
this.browserVersion = undefined;
}