Close GH-2795: Rewrite cucumber test caching (and support logic). Fixes #2745
This commit is contained in:
Patrick Niklaus
committed by
Moritz Kobitzsch
Moritz Kobitzsch
parent
b2bc169547
commit
c1041e5a64
@@ -1,165 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
var builder = require('xmlbuilder');
|
||||
|
||||
var ensureDecimal = (i) => {
|
||||
if (parseInt(i) === i) return i.toFixed(1);
|
||||
else return i;
|
||||
};
|
||||
|
||||
class DB {
|
||||
constructor () {
|
||||
this.nodes = new Array();
|
||||
this.ways = new Array();
|
||||
this.relations = new Array();
|
||||
}
|
||||
|
||||
addNode (node) {
|
||||
this.nodes.push(node);
|
||||
}
|
||||
|
||||
addWay (way) {
|
||||
this.ways.push(way);
|
||||
}
|
||||
|
||||
addRelation (relation) {
|
||||
this.relations.push(relation);
|
||||
}
|
||||
|
||||
clear () {
|
||||
this.nodes = [];
|
||||
this.ways = [];
|
||||
this.relations = [];
|
||||
}
|
||||
|
||||
toXML (callback) {
|
||||
var xml = builder.create('osm', {'encoding':'UTF-8'});
|
||||
xml.att('generator', 'osrm-test')
|
||||
.att('version', '0.6');
|
||||
|
||||
this.nodes.forEach((n) => {
|
||||
var node = xml.ele('node', {
|
||||
id: n.id,
|
||||
version: 1,
|
||||
uid: n.OSM_UID,
|
||||
user: n.OSM_USER,
|
||||
timestamp: n.OSM_TIMESTAMP,
|
||||
lon: ensureDecimal(n.lon),
|
||||
lat: ensureDecimal(n.lat)
|
||||
});
|
||||
|
||||
for (var k in n.tags) {
|
||||
node.ele('tag')
|
||||
.att('k', k)
|
||||
.att('v', n.tags[k]);
|
||||
}
|
||||
});
|
||||
|
||||
this.ways.forEach((w) => {
|
||||
var way = xml.ele('way', {
|
||||
id: w.id,
|
||||
version: 1,
|
||||
uid: w.OSM_UID,
|
||||
user: w.OSM_USER,
|
||||
timestamp: w.OSM_TIMESTAMP
|
||||
});
|
||||
|
||||
w.nodes.forEach((k) => {
|
||||
way.ele('nd')
|
||||
.att('ref', k.id);
|
||||
});
|
||||
|
||||
for (var k in w.tags) {
|
||||
way.ele('tag')
|
||||
.att('k', k)
|
||||
.att('v', w.tags[k]);
|
||||
}
|
||||
});
|
||||
|
||||
this.relations.forEach((r) => {
|
||||
var relation = xml.ele('relation', {
|
||||
id: r.id,
|
||||
user: r.OSM_USER,
|
||||
timestamp: r.OSM_TIMESTAMP,
|
||||
uid: r.OSM_UID
|
||||
});
|
||||
|
||||
r.members.forEach((m) => {
|
||||
relation.ele('member', {
|
||||
type: m.type,
|
||||
ref: m.id,
|
||||
role: m.role
|
||||
});
|
||||
});
|
||||
|
||||
for (var k in r.tags) {
|
||||
relation.ele('tag')
|
||||
.att('k', k)
|
||||
.att('v', r.tags[k]);
|
||||
}
|
||||
});
|
||||
|
||||
callback(xml.end({ pretty: true, indent: ' ' }));
|
||||
}
|
||||
}
|
||||
|
||||
class Node {
|
||||
constructor (id, OSM_USER, OSM_TIMESTAMP, OSM_UID, lon, lat, tags) {
|
||||
this.id = id;
|
||||
this.OSM_USER = OSM_USER;
|
||||
this.OSM_TIMESTAMP = OSM_TIMESTAMP;
|
||||
this.OSM_UID = OSM_UID;
|
||||
this.lon = lon;
|
||||
this.lat = lat;
|
||||
this.tags = tags;
|
||||
}
|
||||
|
||||
addTag (k, v) {
|
||||
this.tags[k] = v;
|
||||
}
|
||||
}
|
||||
|
||||
class Way {
|
||||
constructor (id, OSM_USER, OSM_TIMESTAMP, OSM_UID) {
|
||||
this.id = id;
|
||||
this.OSM_USER = OSM_USER;
|
||||
this.OSM_TIMESTAMP = OSM_TIMESTAMP;
|
||||
this.OSM_UID = OSM_UID;
|
||||
this.tags = {};
|
||||
this.nodes = [];
|
||||
}
|
||||
|
||||
addNode (node) {
|
||||
this.nodes.push(node);
|
||||
}
|
||||
|
||||
setTags (tags) {
|
||||
this.tags = tags;
|
||||
}
|
||||
}
|
||||
|
||||
class Relation {
|
||||
constructor (id, OSM_USER, OSM_TIMESTAMP, OSM_UID) {
|
||||
this.id = id;
|
||||
this.OSM_USER = OSM_USER;
|
||||
this.OSM_TIMESTAMP = OSM_TIMESTAMP;
|
||||
this.OSM_UID = OSM_UID;
|
||||
this.members = [];
|
||||
this.tags = {};
|
||||
}
|
||||
|
||||
addMember (memberType, id, role) {
|
||||
this.members.push({type: memberType, id: id, role: role});
|
||||
}
|
||||
|
||||
addTag (k, v) {
|
||||
this.tags[k] = v;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
DB: DB,
|
||||
Node: Node,
|
||||
Way: Way,
|
||||
Relation: Relation
|
||||
};
|
||||
@@ -0,0 +1,184 @@
|
||||
'use strict';
|
||||
|
||||
const d3 = require('d3-queue');
|
||||
const fs = require('fs');
|
||||
const util = require('util');
|
||||
const path = require('path');
|
||||
const mkdirp = require('mkdirp');
|
||||
const hash = require('../lib/hash');
|
||||
const rimraf = require('rimraf');
|
||||
|
||||
module.exports = function() {
|
||||
this.initializeCache = (callback) => {
|
||||
this.getOSRMHash((err, osrmHash) => {
|
||||
if (err) return callback(err);
|
||||
this.osrmHash = osrmHash;
|
||||
callback();
|
||||
});
|
||||
};
|
||||
|
||||
// computes all paths for every feature
|
||||
this.setupFeatures = (features, callback) => {
|
||||
this.featureIDs = {};
|
||||
this.featureCacheDirectories = {};
|
||||
this.featureProcessedCacheDirectories = {};
|
||||
let queue = d3.queue();
|
||||
|
||||
function initializeFeature(feature, callback) {
|
||||
let uri = feature.getUri();
|
||||
|
||||
// setup cache for feature data
|
||||
hash.hashOfFile(uri, (err, hash) => {
|
||||
if (err) return callback(err);
|
||||
|
||||
// shorten uri to be realtive to 'features/'
|
||||
let featurePath = path.relative(path.resolve('./features'), uri);
|
||||
// bicycle/bollards/{HASH}/
|
||||
let featureID = path.join(featurePath, hash);
|
||||
let featureCacheDirectory = this.getFeatureCacheDirectory(featureID);
|
||||
let featureProcessedCacheDirectory = this.getFeatureProcessedCacheDirectory(featureCacheDirectory, this.osrmHash);
|
||||
this.featureIDs[uri] = featureID;
|
||||
this.featureCacheDirectories[uri] = featureCacheDirectory;
|
||||
this.featureProcessedCacheDirectories[uri] = featureProcessedCacheDirectory;
|
||||
|
||||
d3.queue(1)
|
||||
.defer(mkdirp, featureProcessedCacheDirectory)
|
||||
.defer(this.cleanupFeatureCache.bind(this), featureCacheDirectory, hash)
|
||||
.defer(this.cleanupProcessedFeatureCache.bind(this), featureProcessedCacheDirectory, this.osrmHash)
|
||||
.awaitAll(callback);
|
||||
});
|
||||
}
|
||||
|
||||
for (let i = 0; i < features.length; ++i) {
|
||||
queue.defer(initializeFeature.bind(this), features[i]);
|
||||
}
|
||||
queue.awaitAll(callback);
|
||||
};
|
||||
|
||||
this.cleanupProcessedFeatureCache = (directory, osrmHash, callback) => {
|
||||
let parentPath = path.resolve(path.join(directory, '..'));
|
||||
fs.readdir(parentPath, (err, files) => {
|
||||
let q = d3.queue();
|
||||
function runStats(path, callback) {
|
||||
fs.stat(path, (err, stat) => {
|
||||
if (err) return callback(err);
|
||||
callback(null, {file: path, stat: stat});
|
||||
});
|
||||
}
|
||||
files.map(f => { q.defer(runStats, path.join(parentPath, f)); });
|
||||
q.awaitAll((err, results) => {
|
||||
if (err) return callback(err);
|
||||
let q = d3.queue();
|
||||
results.forEach(r => {
|
||||
if (r.stat.isDirectory() && r.file.search(osrmHash) < 0) {
|
||||
q.defer(rimraf, r.file);
|
||||
}
|
||||
});
|
||||
q.awaitAll(callback);
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
this.cleanupFeatureCache = (directory, featureHash, callback) => {
|
||||
let parentPath = path.resolve(path.join(directory, '..'));
|
||||
fs.readdir(parentPath, (err, files) => {
|
||||
let q = d3.queue();
|
||||
files.filter(name => { return name !== featureHash;})
|
||||
.map((f) => { q.defer(rimraf, path.join(parentPath, f)); });
|
||||
q.awaitAll(callback);
|
||||
});
|
||||
};
|
||||
|
||||
this.setupFeatureCache = (feature) => {
|
||||
let uri = feature.getUri();
|
||||
this.featureID = this.featureIDs[uri];
|
||||
this.featureCacheDirectory = this.featureCacheDirectories[uri];
|
||||
this.featureProcessedCacheDirectory = this.featureProcessedCacheDirectories[uri];
|
||||
};
|
||||
|
||||
this.setupScenarioCache = (scenarioID) => {
|
||||
this.scenarioCacheFile = this.getScenarioCacheFile(this.featureCacheDirectory, scenarioID);
|
||||
this.processedCacheFile = this.getProcessedCacheFile(this.featureProcessedCacheDirectory, scenarioID);
|
||||
this.inputCacheFile = this.getInputCacheFile(this.featureProcessedCacheDirectory, scenarioID);
|
||||
this.rasterCacheFile = this.getRasterCacheFile(this.featureProcessedCacheDirectory, scenarioID);
|
||||
this.speedsCacheFile = this.getSpeedsCacheFile(this.featureProcessedCacheDirectory, scenarioID);
|
||||
this.penaltiesCacheFile = this.getPenaltiesCacheFile(this.featureProcessedCacheDirectory, scenarioID);
|
||||
};
|
||||
|
||||
// returns a hash of all OSRM code side dependencies
|
||||
this.getOSRMHash = (callback) => {
|
||||
let dependencies = [
|
||||
this.OSRM_EXTRACT_PATH,
|
||||
this.OSRM_CONTRACT_PATH,
|
||||
this.LIB_OSRM_EXTRACT_PATH,
|
||||
this.LIB_OSRM_CONTRACT_PATH
|
||||
];
|
||||
|
||||
var addLuaFiles = (directory, callback) => {
|
||||
fs.readdir(path.normalize(directory), (err, files) => {
|
||||
if (err) return callback(err);
|
||||
|
||||
var luaFiles = files.filter(f => !!f.match(/\.lua$/)).map(f => path.normalize(directory + '/' + f));
|
||||
Array.prototype.push.apply(dependencies, luaFiles);
|
||||
|
||||
callback();
|
||||
});
|
||||
};
|
||||
|
||||
// Note: we need a serialized queue here to ensure that the order of the files
|
||||
// passed is stable. Otherwise the hash will not be stable
|
||||
d3.queue(1)
|
||||
.defer(addLuaFiles, this.PROFILES_PATH)
|
||||
.defer(addLuaFiles, this.PROFILES_PATH + '/lib')
|
||||
.awaitAll(hash.hashOfFiles.bind(hash, dependencies, callback));
|
||||
};
|
||||
|
||||
// test/cache/bicycle/bollards/{HASH}/
|
||||
this.getFeatureCacheDirectory = (featureID) => {
|
||||
return path.join(this.CACHE_PATH, featureID);
|
||||
};
|
||||
|
||||
// converts the scenario titles in file prefixes
|
||||
this.getScenarioID = (scenario) => {
|
||||
let name = scenario.getName().toLowerCase().replace(/[\/\-'=,\(\)]/g, '').replace(/\s/g, '_').replace(/__/g, '_').replace(/\.\./g, '.');
|
||||
return util.format('%d_%s', scenario.getLine(), name);
|
||||
};
|
||||
|
||||
// test/cache/{feature_path}/{feature_hash}/{scenario}_raster.asc
|
||||
this.getRasterCacheFile = (featureCacheDirectory, scenarioID) => {
|
||||
return path.join(featureCacheDirectory, scenarioID) + '_raster.asc';
|
||||
};
|
||||
|
||||
// test/cache/{feature_path}/{feature_hash}/{scenario}_speeds.csv
|
||||
this.getSpeedsCacheFile = (featureCacheDirectory, scenarioID) => {
|
||||
return path.join(featureCacheDirectory, scenarioID) + '_speeds.csv';
|
||||
};
|
||||
|
||||
// test/cache/{feature_path}/{feature_hash}/{scenario}_penalties.csv
|
||||
this.getPenaltiesCacheFile = (featureCacheDirectory, scenarioID) => {
|
||||
return path.join(featureCacheDirectory, scenarioID) + '_penalties.csv';
|
||||
};
|
||||
|
||||
// test/cache/{feature_path}/{feature_hash}/{scenario}.osm
|
||||
this.getScenarioCacheFile = (featureCacheDirectory, scenarioID) => {
|
||||
return path.join(featureCacheDirectory, scenarioID) + '.osm';
|
||||
};
|
||||
|
||||
// test/cache/{feature_path}/{feature_hash}/{osrm_hash}/
|
||||
this.getFeatureProcessedCacheDirectory = (featureCacheDirectory, osrmHash) => {
|
||||
return path.join(featureCacheDirectory, osrmHash);
|
||||
};
|
||||
|
||||
// test/cache/{feature_path}/{feature_hash}/{osrm_hash}/{scenario}.osrm
|
||||
this.getProcessedCacheFile = (featureProcessedCacheDirectory, scenarioID) => {
|
||||
return path.join(featureProcessedCacheDirectory, scenarioID) + '.osrm';
|
||||
};
|
||||
|
||||
// test/cache/{feature_path}/{feature_hash}/{osrm_hash}/{scenario}.osm
|
||||
this.getInputCacheFile = (featureProcessedCacheDirectory, scenarioID) => {
|
||||
return path.join(featureProcessedCacheDirectory, scenarioID) + '.osm';
|
||||
};
|
||||
|
||||
|
||||
return this;
|
||||
};
|
||||
@@ -1,127 +0,0 @@
|
||||
var fs = require('fs');
|
||||
var path = require('path');
|
||||
var util = require('util');
|
||||
var d3 = require('d3-queue');
|
||||
var OSM = require('./build_osm');
|
||||
var classes = require('./data_classes');
|
||||
|
||||
module.exports = function () {
|
||||
this.initializeOptions = (callback) => {
|
||||
this.profile = this.profile || this.DEFAULT_SPEEDPROFILE;
|
||||
|
||||
this.OSMDB = this.OSMDB || new OSM.DB();
|
||||
|
||||
this.nameNodeHash = this.nameNodeHash || {};
|
||||
|
||||
this.locationHash = this.locationHash || {};
|
||||
|
||||
this.nameWayHash = this.nameWayHash || {};
|
||||
|
||||
this.osmData = new classes.osmData(this);
|
||||
|
||||
this.OSRMLoader = this._OSRMLoader();
|
||||
|
||||
this.PREPROCESS_LOG_FILE = path.resolve(this.TEST_FOLDER, 'preprocessing.log');
|
||||
|
||||
this.LOG_FILE = path.resolve(this.TEST_FOLDER, 'fail.log');
|
||||
|
||||
this.HOST = 'http://127.0.0.1:' + this.OSRM_PORT;
|
||||
|
||||
this.DESTINATION_REACHED = 15; // OSRM instruction code
|
||||
|
||||
this.shortcutsHash = this.shortcutsHash || {};
|
||||
|
||||
var hashLuaLib = (cb) => {
|
||||
fs.readdir(path.normalize(this.PROFILES_PATH + '/lib/'), (err, files) => {
|
||||
if (err) cb(err);
|
||||
var luaFiles = files.filter(f => !!f.match(/\.lua$/)).map(f => path.normalize(this.PROFILES_PATH + '/lib/' + f));
|
||||
this.hashOfFiles(luaFiles, hash => {
|
||||
this.luaLibHash = hash;
|
||||
cb();
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
var hashProfile = (cb) => {
|
||||
this.hashProfile((hash) => {
|
||||
this.profileHash = hash;
|
||||
cb();
|
||||
});
|
||||
};
|
||||
|
||||
var hashExtract = (cb) => {
|
||||
var files = [ util.format('%s/osrm-extract%s', this.BIN_PATH, this.EXE),
|
||||
util.format('%s/libosrm_extract%s', this.BIN_PATH, this.LIB) ];
|
||||
this.hashOfFiles(files, (hash) => {
|
||||
this.binExtractHash = hash;
|
||||
cb();
|
||||
});
|
||||
};
|
||||
|
||||
var hashContract = (cb) => {
|
||||
var files = [ util.format('%s/osrm-contract%s', this.BIN_PATH, this.EXE),
|
||||
util.format('%s/libosrm_contract%s', this.BIN_PATH, this.LIB) ];
|
||||
this.hashOfFiles(files, (hash) => {
|
||||
this.binContractHash = hash;
|
||||
cb();
|
||||
});
|
||||
};
|
||||
|
||||
var hashRouted = (cb) => {
|
||||
var files = [ util.format('%s/osrm-routed%s', this.BIN_PATH, this.EXE),
|
||||
util.format('%s/libosrm%s', this.BIN_PATH, this.LIB) ];
|
||||
this.hashOfFiles(files, (hash) => {
|
||||
this.binRoutedHash = hash;
|
||||
this.fingerprintRoute = this.hashString(this.binRoutedHash);
|
||||
cb();
|
||||
});
|
||||
};
|
||||
|
||||
d3.queue()
|
||||
.defer(hashLuaLib)
|
||||
.defer(hashProfile)
|
||||
.defer(hashExtract)
|
||||
.defer(hashContract)
|
||||
.defer(hashRouted)
|
||||
.awaitAll(() => {
|
||||
this.AfterConfiguration(() => {
|
||||
callback();
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
this.updateFingerprintExtract = (str) => {
|
||||
this.fingerprintExtract = this.hashString([this.fingerprintExtract, str].join('-'));
|
||||
};
|
||||
|
||||
this.updateFingerprintContract = (str) => {
|
||||
this.fingerprintContract = this.hashString([this.fingerprintContract, str].join('-'));
|
||||
};
|
||||
|
||||
this.setProfile = (profile, cb) => {
|
||||
var lastProfile = this.profile;
|
||||
if (profile !== lastProfile) {
|
||||
this.profile = profile;
|
||||
this.hashProfile((hash) => {
|
||||
this.profileHash = hash;
|
||||
this.updateFingerprintExtract(this.profileHash);
|
||||
cb();
|
||||
});
|
||||
} else {
|
||||
this.updateFingerprintExtract(this.profileHash);
|
||||
cb();
|
||||
}
|
||||
};
|
||||
|
||||
this.setExtractArgs = (args, callback) => {
|
||||
this.extractArgs = args;
|
||||
this.updateFingerprintExtract(args);
|
||||
callback();
|
||||
};
|
||||
|
||||
this.setContractArgs = (args, callback) => {
|
||||
this.contractArgs = args;
|
||||
this.updateFingerprintContract(args);
|
||||
callback();
|
||||
};
|
||||
};
|
||||
+72
-194
@@ -1,11 +1,14 @@
|
||||
var fs = require('fs');
|
||||
var path = require('path');
|
||||
var util = require('util');
|
||||
var exec = require('child_process').exec;
|
||||
var d3 = require('d3-queue');
|
||||
'use strict';
|
||||
|
||||
var OSM = require('./build_osm');
|
||||
var classes = require('./data_classes');
|
||||
const fs = require('fs');
|
||||
const util = require('util');
|
||||
const d3 = require('d3-queue');
|
||||
|
||||
const OSM = require('../lib/osm');
|
||||
const classes = require('./data_classes');
|
||||
const tableDiff = require('../lib/table_diff');
|
||||
const ensureDecimal = require('../lib/utils').ensureDecimal;
|
||||
const errorReason = require('../lib/utils').errorReason;
|
||||
|
||||
module.exports = function () {
|
||||
this.setGridSize = (meters) => {
|
||||
@@ -94,13 +97,8 @@ module.exports = function () {
|
||||
q.awaitAll(callback);
|
||||
};
|
||||
|
||||
this.ensureDecimal = (i) => {
|
||||
if (parseInt(i) === i) return i.toFixed(1);
|
||||
else return i;
|
||||
};
|
||||
|
||||
this.tableCoordToLonLat = (ci, ri) => {
|
||||
return [this.origin[0] + ci * this.zoom, this.origin[1] - ri * this.zoom].map(this.ensureDecimal);
|
||||
return [this.origin[0] + ci * this.zoom, this.origin[1] - ri * this.zoom].map(ensureDecimal);
|
||||
};
|
||||
|
||||
this.addOSMNode = (name, lon, lat, id) => {
|
||||
@@ -132,10 +130,6 @@ module.exports = function () {
|
||||
return this.nameWayHash[s.toString()] || this.nameWayHash[s.toString().split('').reverse().join('')];
|
||||
};
|
||||
|
||||
this.resetData = () => {
|
||||
this.resetOSM();
|
||||
};
|
||||
|
||||
this.makeOSMId = () => {
|
||||
this.osmID = this.osmID + 1;
|
||||
return this.osmID;
|
||||
@@ -143,206 +137,88 @@ module.exports = function () {
|
||||
|
||||
this.resetOSM = () => {
|
||||
this.OSMDB.clear();
|
||||
this.osmData.reset();
|
||||
this.nameNodeHash = {};
|
||||
this.locationHash = {};
|
||||
this.shortcutsHash = {};
|
||||
this.nameWayHash = {};
|
||||
this.osmID = 0;
|
||||
};
|
||||
|
||||
this.writeOSM = (callback) => {
|
||||
fs.exists(this.DATA_FOLDER, (exists) => {
|
||||
var mkDirFn = exists ? (cb) => { cb(); } : fs.mkdir.bind(fs.mkdir, this.DATA_FOLDER);
|
||||
mkDirFn((err) => {
|
||||
if (err) return callback(err);
|
||||
var osmPath = path.resolve(this.DATA_FOLDER, util.format('%s.osm', this.osmData.osmFile));
|
||||
fs.exists(osmPath, (exists) => {
|
||||
if (!exists) fs.writeFile(osmPath, this.osmData.str, callback);
|
||||
else callback();
|
||||
fs.exists(this.scenarioCacheFile, (exists) => {
|
||||
if (exists) callback();
|
||||
else {
|
||||
this.OSMDB.toXML((xml) => {
|
||||
fs.writeFile(this.scenarioCacheFile, xml, callback);
|
||||
});
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
this.isExtracted = (callback) => {
|
||||
fs.exists(util.format('%s.osrm', this.osmData.extractedFile), (core) => {
|
||||
if (!core) return callback(false);
|
||||
fs.exists(util.format('%s.osrm.names', this.osmData.extractedFile), (names) => {
|
||||
if (!names) return callback(false);
|
||||
fs.exists(util.format('%s.osrm.restrictions', this.osmData.extractedFile), (restrictions) => {
|
||||
return callback(restrictions);
|
||||
});
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
this.isContracted = (callback) => {
|
||||
fs.exists(util.format('%s.osrm.hsgr', this.osmData.contractedFile), callback);
|
||||
};
|
||||
|
||||
this.writeTimestamp = (callback) => {
|
||||
fs.writeFile(util.format('%s.osrm.timestamp', this.osmData.contractedFile), this.OSM_TIMESTAMP, callback);
|
||||
};
|
||||
|
||||
this.writeInputData = (callback) => {
|
||||
this.writeOSM((err) => {
|
||||
if (err) return callback(err);
|
||||
this.writeTimestamp(callback);
|
||||
});
|
||||
};
|
||||
|
||||
this.extractData = (callback) => {
|
||||
this.logPreprocessInfo();
|
||||
this.log(util.format('== Extracting %s.osm...', this.osmData.osmFile), 'preprocess');
|
||||
var cmd = util.format('%s/osrm-extract %s.osm %s --profile %s/%s.lua >>%s 2>&1',
|
||||
this.BIN_PATH, this.osmData.osmFile, this.extractArgs || '', this.PROFILES_PATH, this.profile, this.PREPROCESS_LOG_FILE);
|
||||
this.log(cmd);
|
||||
process.chdir(this.TEST_FOLDER);
|
||||
exec(cmd, (err) => {
|
||||
if (err) {
|
||||
this.log(util.format('*** Exited with code %d', err.code), 'preprocess');
|
||||
process.chdir('../');
|
||||
return callback(this.ExtractError(err.code, util.format('osrm-extract exited with code %d', err.code)));
|
||||
}
|
||||
|
||||
var q = d3.queue();
|
||||
|
||||
var rename = (file, cb) => {
|
||||
this.log(util.format('Renaming %s.%s to %s.%s', this.osmData.osmFile, file, this.osmData.extractedFile, file), 'preprocess');
|
||||
fs.rename([this.osmData.osmFile, file].join('.'), [this.osmData.extractedFile, file].join('.'), (err) => {
|
||||
if (err) return cb(this.FileError(null, 'failed to rename data file after extracting'));
|
||||
cb();
|
||||
});
|
||||
};
|
||||
|
||||
var renameIfExists = (file, cb) => {
|
||||
fs.stat([this.osmData.osmFile, file].join('.'), (doesNotExistErr, exists) => {
|
||||
if (exists) rename(file, cb);
|
||||
else cb();
|
||||
});
|
||||
};
|
||||
|
||||
['osrm', 'osrm.ebg', 'osrm.edges', 'osrm.enw', 'osrm.fileIndex', 'osrm.geometry', 'osrm.icd',
|
||||
'osrm.names', 'osrm.nodes', 'osrm.properties', 'osrm.ramIndex', 'osrm.restrictions', 'osrm.tld', 'osrm.tls'].forEach(file => {
|
||||
q.defer(rename, file);
|
||||
});
|
||||
|
||||
['osrm.edge_penalties', 'osrm.edge_segment_lookup'].forEach(file => {
|
||||
q.defer(renameIfExists, file);
|
||||
});
|
||||
|
||||
q.awaitAll((err) => {
|
||||
this.log('Finished extracting ' + this.osmData.extractedFile, 'preprocess');
|
||||
process.chdir('../');
|
||||
callback(err);
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
this.contractData = (callback) => {
|
||||
this.logPreprocessInfo();
|
||||
this.log(util.format('== Contracting %s.osm...', this.osmData.extractedFile), 'preprocess');
|
||||
var cmd = util.format('%s/osrm-contract %s %s.osrm >>%s 2>&1',
|
||||
this.BIN_PATH, this.contractArgs || '', this.osmData.extractedFile, this.PREPROCESS_LOG_FILE);
|
||||
this.log(cmd);
|
||||
process.chdir(this.TEST_FOLDER);
|
||||
exec(cmd, (err) => {
|
||||
if (err) {
|
||||
this.log(util.format('*** Exited with code %d', err.code), 'preprocess');
|
||||
process.chdir('../');
|
||||
return callback(this.ContractError(err.code, util.format('osrm-contract exited with code %d', err.code)));
|
||||
this.linkOSM = (callback) => {
|
||||
fs.exists(this.inputCacheFile, (exists) => {
|
||||
if (exists) callback();
|
||||
else {
|
||||
fs.link(this.scenarioCacheFile, this.inputCacheFile, callback);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
var rename = (file, cb) => {
|
||||
this.log(util.format('Renaming %s.%s to %s.%s', this.osmData.extractedFile, file, this.osmData.contractedFile, file), 'preprocess');
|
||||
fs.rename([this.osmData.extractedFile, file].join('.'), [this.osmData.contractedFile, file].join('.'), (err) => {
|
||||
if (err) return cb(this.FileError(null, 'failed to rename data file after contracting.'));
|
||||
cb();
|
||||
});
|
||||
};
|
||||
this.extractData = (p, callback) => {
|
||||
let stamp = p.processedCacheFile + '.extract';
|
||||
fs.exists(stamp, (exists) => {
|
||||
if (exists) return callback();
|
||||
|
||||
var renameIfExists = (file, cb) => {
|
||||
fs.stat([this.osmData.extractedFile, file].join('.'), (doesNotExistErr, exists) => {
|
||||
if (exists) rename(file, cb);
|
||||
else cb();
|
||||
});
|
||||
};
|
||||
|
||||
var copy = (file, cb) => {
|
||||
this.log(util.format('Copying %s.%s to %s.%s', this.osmData.extractedFile, file, this.osmData.contractedFile, file), 'preprocess');
|
||||
fs.createReadStream([this.osmData.extractedFile, file].join('.'))
|
||||
.pipe(fs.createWriteStream([this.osmData.contractedFile, file].join('.'))
|
||||
.on('finish', cb)
|
||||
)
|
||||
.on('error', () => {
|
||||
return cb(this.FileError(null, 'failed to copy data after contracting.'));
|
||||
});
|
||||
};
|
||||
|
||||
var q = d3.queue();
|
||||
|
||||
['osrm', 'osrm.core', 'osrm.datasource_indexes', 'osrm.datasource_names', 'osrm.ebg','osrm.edges',
|
||||
'osrm.enw', 'osrm.fileIndex', 'osrm.geometry', 'osrm.hsgr', 'osrm.icd','osrm.level', 'osrm.names',
|
||||
'osrm.nodes', 'osrm.properties', 'osrm.ramIndex', 'osrm.restrictions', 'osrm.tld', 'osrm.tls'].forEach((file) => {
|
||||
q.defer(rename, file);
|
||||
});
|
||||
|
||||
['osrm.edge_penalties', 'osrm.edge_segment_lookup'].forEach(file => {
|
||||
q.defer(renameIfExists, file);
|
||||
});
|
||||
|
||||
[].forEach((file) => {
|
||||
q.defer(copy, file);
|
||||
});
|
||||
|
||||
q.awaitAll((err) => {
|
||||
this.log('Finished contracting ' + this.osmData.contractedFile, 'preprocess');
|
||||
process.chdir('../');
|
||||
callback(err);
|
||||
this.runBin('osrm-extract', util.format('%s --profile %s %s', p.extractArgs, p.profileFile, p.inputCacheFile), p.environment, (err) => {
|
||||
if (err) {
|
||||
return callback(new Error(util.format('osrm-extract %s: %s', errorReason(err), err.cmd)));
|
||||
}
|
||||
fs.writeFile(stamp, 'ok', callback);
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
var noop = (cb) => cb();
|
||||
this.contractData = (p, callback) => {
|
||||
let stamp = p.processedCacheFile + '.contract';
|
||||
fs.exists(stamp, (exists) => {
|
||||
if (exists) return callback();
|
||||
|
||||
this.runBin('osrm-contract', util.format('%s %s', p.contractArgs, p.processedCacheFile), p.environment, (err) => {
|
||||
if (err) {
|
||||
return callback(new Error(util.format('osrm-contract %s: %s', errorReason(err), err)));
|
||||
}
|
||||
fs.writeFile(stamp, 'ok', callback);
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
this.extractAndContract = (callback) => {
|
||||
// a shallow copy of scenario parameters to avoid data inconsistency
|
||||
// if a cucumber timeout occurs during deferred jobs
|
||||
let p = {extractArgs: this.extractArgs, contractArgs: this.contractArgs,
|
||||
profileFile: this.profileFile, inputCacheFile: this.inputCacheFile,
|
||||
processedCacheFile: this.processedCacheFile, environment: this.environment};
|
||||
let queue = d3.queue(1);
|
||||
queue.defer(this.extractData.bind(this), p);
|
||||
queue.defer(this.contractData.bind(this), p);
|
||||
queue.awaitAll(callback);
|
||||
};
|
||||
|
||||
this.reprocess = (callback) => {
|
||||
this.osmData.populate(() => {
|
||||
this.isContracted((isContracted) => {
|
||||
if (!isContracted) {
|
||||
this.writeAndExtract((e) => {
|
||||
if (e) return callback(e);
|
||||
this.contractData((e) => {
|
||||
if (e) return callback(e);
|
||||
this.logPreprocessDone();
|
||||
callback();
|
||||
});
|
||||
});
|
||||
} else {
|
||||
this.log('Already contracted ' + this.osmData.contractedFile, 'preprocess');
|
||||
callback();
|
||||
}
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
this.writeAndExtract = (callback) => {
|
||||
this.writeInputData((e) => {
|
||||
if (e) return callback(e);
|
||||
this.isExtracted((isExtracted) => {
|
||||
var extractFn = isExtracted ? noop : this.extractData;
|
||||
if (isExtracted) this.log('Already extracted ' + this.osmData.extractedFile, 'preprocess');
|
||||
extractFn((e) => {
|
||||
callback(e);
|
||||
});
|
||||
});
|
||||
});
|
||||
let queue = d3.queue(1);
|
||||
queue.defer(this.writeOSM.bind(this));
|
||||
queue.defer(this.linkOSM.bind(this));
|
||||
queue.defer(this.extractAndContract.bind(this));
|
||||
queue.awaitAll(callback);
|
||||
};
|
||||
|
||||
this.reprocessAndLoadData = (callback) => {
|
||||
this.reprocess((e) => {
|
||||
if (e) return callback(e);
|
||||
this.OSRMLoader.load(util.format('%s.osrm', this.osmData.contractedFile), callback);
|
||||
});
|
||||
let queue = d3.queue(1);
|
||||
queue.defer(this.writeOSM.bind(this));
|
||||
queue.defer(this.linkOSM.bind(this));
|
||||
queue.defer(this.extractAndContract.bind(this));
|
||||
queue.defer(this.osrmLoader.load.bind(this.osrmLoader), this.processedCacheFile);
|
||||
queue.awaitAll(callback);
|
||||
};
|
||||
|
||||
this.processRowsAndDiff = (table, fn, callback) => {
|
||||
@@ -352,7 +228,9 @@ module.exports = function () {
|
||||
|
||||
q.awaitAll((err, actual) => {
|
||||
if (err) return callback(err);
|
||||
this.diffTables(table, actual, {}, callback);
|
||||
let diff = tableDiff(table, actual);
|
||||
if (diff) callback(new Error(diff));
|
||||
else callback();
|
||||
});
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
'use strict';
|
||||
|
||||
var util = require('util');
|
||||
var path = require('path');
|
||||
const util = require('util');
|
||||
|
||||
module.exports = {
|
||||
Location: class {
|
||||
@@ -11,43 +10,6 @@ module.exports = {
|
||||
}
|
||||
},
|
||||
|
||||
osmData: class {
|
||||
constructor (scope) {
|
||||
this.scope = scope;
|
||||
this.str = null;
|
||||
this.hash = null;
|
||||
this.fingerprintOSM = null;
|
||||
this.osmFile = null;
|
||||
this.extractedFile = null;
|
||||
this.contractedFile = null;
|
||||
}
|
||||
|
||||
populate (callback) {
|
||||
this.scope.OSMDB.toXML((str) => {
|
||||
this.str = str;
|
||||
|
||||
this.hash = this.scope.hashString(str);
|
||||
this.fingerprintOSM = this.scope.hashString(this.hash);
|
||||
|
||||
this.osmFile = path.resolve(this.scope.DATA_FOLDER, this.fingerprintOSM);
|
||||
|
||||
this.extractedFile = path.resolve([this.osmFile, this.scope.fingerprintExtract].join('_'));
|
||||
this.contractedFile = path.resolve([this.osmFile, this.scope.fingerprintExtract, this.scope.fingerprintContract].join('_'));
|
||||
|
||||
callback();
|
||||
});
|
||||
}
|
||||
|
||||
reset () {
|
||||
this.str = null;
|
||||
this.hash = null;
|
||||
this.fingerprintOSM = null;
|
||||
this.osmFile = null;
|
||||
this.extractedFile = null;
|
||||
this.contractedFile = null;
|
||||
}
|
||||
},
|
||||
|
||||
FuzzyMatch: class {
|
||||
match (got, want) {
|
||||
var matchPercent = want.match(/(.*)\s+~(.+)%$/),
|
||||
|
||||
+63
-47
@@ -1,32 +1,46 @@
|
||||
var path = require('path');
|
||||
var util = require('util');
|
||||
var fs = require('fs');
|
||||
var exec = require('child_process').exec;
|
||||
var d3 = require('d3-queue');
|
||||
'use strict';
|
||||
|
||||
const path = require('path');
|
||||
const util = require('util');
|
||||
const fs = require('fs');
|
||||
const d3 = require('d3-queue');
|
||||
const child_process = require('child_process');
|
||||
const tryConnect = require('../lib/try_connect');
|
||||
|
||||
// Sets up all constants that are valid for all features
|
||||
module.exports = function () {
|
||||
this.initializeEnv = (callback) => {
|
||||
this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
|
||||
this.TIMEOUT = process.env.CUCUMBER_TIMEOUT && parseInt(process.env.CUCUMBER_TIMEOUT) || 5000;
|
||||
// set cucumber default timeout
|
||||
this.setDefaultTimeout(this.TIMEOUT);
|
||||
this.ROOT_FOLDER = process.cwd();
|
||||
this.ROOT_PATH = process.cwd();
|
||||
|
||||
this.TEST_PATH = path.resolve(this.ROOT_PATH, 'test');
|
||||
this.CACHE_PATH = path.resolve(this.TEST_PATH, 'cache');
|
||||
this.LOGS_PATH = path.resolve(this.TEST_PATH, 'logs');
|
||||
|
||||
this.PROFILES_PATH = path.resolve(this.ROOT_PATH, 'profiles');
|
||||
this.FIXTURES_PATH = path.resolve(this.ROOT_PATH, 'unit_tests/fixtures');
|
||||
this.BIN_PATH = process.env.OSRM_BUILD_DIR && process.env.OSRM_BUILD_DIR || path.resolve(this.ROOT_PATH, 'build');
|
||||
var stxxl_config = path.resolve(this.ROOT_PATH, 'test/.stxxl');
|
||||
if (!fs.existsSync(stxxl_config)) {
|
||||
return callback(new Error('*** '+stxxl_config+ 'does not exist'));
|
||||
}
|
||||
|
||||
this.DEFAULT_ENVIRONMENT = Object.assign({STXXLCFG: stxxl_config}, process.env);
|
||||
this.DEFAULT_PROFILE = 'bicycle';
|
||||
this.DEFAULT_INPUT_FORMAT = 'osm';
|
||||
this.DEFAULT_LOAD_METHOD = 'datastore';
|
||||
this.DEFAULT_ORIGIN = [1,1];
|
||||
this.OSM_USER = 'osrm';
|
||||
this.OSM_GENERATOR = 'osrm-test';
|
||||
this.OSM_UID = 1;
|
||||
this.TEST_FOLDER = path.resolve(this.ROOT_FOLDER, 'test');
|
||||
this.DATA_FOLDER = path.resolve(this.TEST_FOLDER, 'cache');
|
||||
this.OSM_TIMESTAMP = '2000-01-01T00:00:00Z';
|
||||
this.DEFAULT_SPEEDPROFILE = 'bicycle';
|
||||
this.WAY_SPACING = 100;
|
||||
this.DEFAULT_GRID_SIZE = 100; // meters
|
||||
this.PROFILES_PATH = path.resolve(this.ROOT_FOLDER, 'profiles');
|
||||
this.FIXTURES_PATH = path.resolve(this.ROOT_FOLDER, 'unit_tests/fixtures');
|
||||
this.BIN_PATH = process.env.OSRM_BUILD_DIR && process.env.OSRM_BUILD_DIR || path.resolve(this.ROOT_FOLDER, 'build');
|
||||
this.DEFAULT_INPUT_FORMAT = 'osm';
|
||||
this.DEFAULT_ORIGIN = [1,1];
|
||||
this.DEFAULT_LOAD_METHOD = 'datastore';
|
||||
this.OSRM_ROUTED_LOG_FILE = path.resolve(this.TEST_FOLDER, 'osrm-routed.log');
|
||||
this.ERROR_LOG_FILE = path.resolve(this.TEST_FOLDER, 'error.log');
|
||||
this.DEFAULT_GRID_SIZE = 100; // meters
|
||||
|
||||
this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
|
||||
this.HOST = 'http://127.0.0.1:' + this.OSRM_PORT;
|
||||
|
||||
// TODO make sure this works on win
|
||||
if (process.platform.match(/indows.*/)) {
|
||||
@@ -37,36 +51,49 @@ module.exports = function () {
|
||||
} else {
|
||||
this.TERMSIGNAL = 'SIGTERM';
|
||||
this.EXE = '';
|
||||
this.LIB = '.so';
|
||||
// TODO autodetect if this was build with shared or static libraries
|
||||
this.LIB = process.env.BUILD_SHARED_LIBS && '.so' || '.a';
|
||||
this.QQ = '';
|
||||
}
|
||||
|
||||
this.OSRM_EXTRACT_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-extract', this.EXE));
|
||||
this.OSRM_CONTRACT_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-contract', this.EXE));
|
||||
this.OSRM_ROUTED_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-routed', this.EXE));
|
||||
this.LIB_OSRM_EXTRACT_PATH = util.format('%s/libosrm_extract%s', this.BIN_PATH, this.LIB),
|
||||
this.LIB_OSRM_CONTRACT_PATH = util.format('%s/libosrm_contract%s', this.BIN_PATH, this.LIB),
|
||||
this.LIB_OSRM_PATH = util.format('%s/libosrm%s', this.BIN_PATH, this.LIB);
|
||||
|
||||
// eslint-disable-next-line no-console
|
||||
console.info(util.format('Node Version', process.version));
|
||||
if (parseInt(process.version.match(/v(\d)/)[1]) < 4) throw new Error('*** PLease upgrade to Node 4.+ to run OSRM cucumber tests');
|
||||
|
||||
fs.exists(this.TEST_FOLDER, (exists) => {
|
||||
if (!exists) throw new Error(util.format('*** Test folder %s doesn\'t exist.', this.TEST_FOLDER));
|
||||
callback();
|
||||
fs.exists(this.TEST_PATH, (exists) => {
|
||||
if (exists)
|
||||
return callback();
|
||||
else
|
||||
return callback(new Error('*** Test folder doesn\'t exist.'));
|
||||
});
|
||||
};
|
||||
|
||||
this.verifyOSRMIsNotRunning = () => {
|
||||
if (this.OSRMLoader.up()) {
|
||||
throw new Error('*** osrm-routed is already running.');
|
||||
}
|
||||
this.getProfilePath = (profile) => {
|
||||
return path.resolve(this.PROFILES_PATH, profile + '.lua');
|
||||
};
|
||||
|
||||
this.verifyOSRMIsNotRunning = (callback) => {
|
||||
tryConnect(this.OSRM_PORT, (err) => {
|
||||
if (!err) return callback(new Error('*** osrm-routed is already running.'));
|
||||
else callback();
|
||||
});
|
||||
};
|
||||
|
||||
this.verifyExistenceOfBinaries = (callback) => {
|
||||
var verify = (bin, cb) => {
|
||||
var binPath = path.resolve(util.format('%s/%s%s', this.BIN_PATH, bin, this.EXE));
|
||||
var verify = (binPath, cb) => {
|
||||
fs.exists(binPath, (exists) => {
|
||||
if (!exists) throw new Error(util.format('%s is missing. Build failed?', binPath));
|
||||
if (!exists) return cb(new Error(util.format('%s is missing. Build failed?', binPath)));
|
||||
var helpPath = util.format('%s --help > /dev/null 2>&1', binPath);
|
||||
exec(helpPath, (err) => {
|
||||
child_process.exec(helpPath, (err) => {
|
||||
if (err) {
|
||||
this.log(util.format('*** Exited with code %d', err.code), 'preprocess');
|
||||
throw new Error(util.format('*** %s exited with code %d', helpPath, err.code));
|
||||
return cb(new Error(util.format('*** %s exited with code %d', helpPath, err.code)));
|
||||
}
|
||||
cb();
|
||||
});
|
||||
@@ -74,23 +101,12 @@ module.exports = function () {
|
||||
};
|
||||
|
||||
var q = d3.queue();
|
||||
['osrm-extract', 'osrm-contract', 'osrm-routed'].forEach(bin => { q.defer(verify, bin); });
|
||||
q.awaitAll(() => {
|
||||
callback();
|
||||
});
|
||||
};
|
||||
|
||||
this.AfterConfiguration = (callback) => {
|
||||
this.clearLogFiles(() => {
|
||||
this.verifyOSRMIsNotRunning();
|
||||
this.verifyExistenceOfBinaries(() => {
|
||||
callback();
|
||||
});
|
||||
});
|
||||
[this.OSRM_EXTRACT_PATH, this.OSRM_CONTRACT_PATH, this.OSRM_ROUTED_PATH].forEach(bin => { q.defer(verify, bin); });
|
||||
q.awaitAll(callback);
|
||||
};
|
||||
|
||||
process.on('exit', () => {
|
||||
if (this.OSRMLoader.loader) this.OSRMLoader.shutdown(() => {});
|
||||
this.osrmLoader.shutdown(() => {});
|
||||
});
|
||||
|
||||
process.on('SIGINT', () => {
|
||||
|
||||
@@ -1,132 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
var util = require('util');
|
||||
var path = require('path');
|
||||
var fs = require('fs');
|
||||
var chalk = require('chalk');
|
||||
|
||||
var OSRMError = class extends Error {
|
||||
constructor (process, code, msg, log, lines) {
|
||||
super(msg);
|
||||
this.process = process;
|
||||
this.code = code;
|
||||
this.msg = msg;
|
||||
this.lines = lines;
|
||||
this.log = log;
|
||||
}
|
||||
|
||||
extract (callback) {
|
||||
this.logTail(this.log, this.lines, callback);
|
||||
}
|
||||
|
||||
// toString (callback) {
|
||||
// this.extract((tail) => {
|
||||
// callback(util.format('*** %s\nLast %s from %s:\n%s\n', this.msg, this.lines, this.log, tail));
|
||||
// });
|
||||
// }
|
||||
|
||||
logTail (logPath, n, callback) {
|
||||
var expanded = path.resolve(this.TEST_FOLDER, logPath);
|
||||
fs.exists(expanded, (exists) => {
|
||||
if (exists) {
|
||||
fs.readFile(expanded, (err, data) => {
|
||||
var lines = data.toString().trim().split('\n');
|
||||
callback(lines
|
||||
.slice(lines.length - n)
|
||||
.map(line => util.format(' %s', line))
|
||||
.join('\n'));
|
||||
});
|
||||
} else {
|
||||
callback(util.format('File %s does not exist!', expanded));
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
var unescapeStr = (str) => str.replace(/\\\|/g, '\|').replace(/\\\\/g, '\\');
|
||||
|
||||
module.exports = {
|
||||
OSRMError: OSRMError,
|
||||
|
||||
FileError: class extends OSRMError {
|
||||
constructor (logFile, code, msg) {
|
||||
super ('fileutil', code, msg, logFile, 5);
|
||||
}
|
||||
},
|
||||
|
||||
LaunchError: class extends OSRMError {
|
||||
constructor (logFile, launchProcess, code, msg) {
|
||||
super (launchProcess, code, msg, logFile, 5);
|
||||
}
|
||||
},
|
||||
|
||||
ExtractError: class extends OSRMError {
|
||||
constructor (logFile, code, msg) {
|
||||
super('osrm-extract', code, msg, logFile, 3);
|
||||
}
|
||||
},
|
||||
|
||||
ContractError: class extends OSRMError {
|
||||
constructor (logFile, code, msg) {
|
||||
super('osrm-contract', code, msg, logFile, 3);
|
||||
}
|
||||
},
|
||||
|
||||
RoutedError: class extends OSRMError {
|
||||
constructor (logFile, msg) {
|
||||
super('osrm-routed', null, msg, logFile, 3);
|
||||
}
|
||||
},
|
||||
|
||||
TableDiffError: class extends Error {
|
||||
constructor (expected, actual) {
|
||||
super();
|
||||
this.headers = expected.raw()[0];
|
||||
this.expected = expected.hashes();
|
||||
this.actual = actual;
|
||||
this.diff = [];
|
||||
this.hasErrors = false;
|
||||
|
||||
var good = 0, bad = 0;
|
||||
|
||||
this.expected.forEach((row, i) => {
|
||||
var rowError = false;
|
||||
|
||||
for (var j in row) {
|
||||
if (unescapeStr(row[j]) != actual[i][j]) {
|
||||
rowError = true;
|
||||
this.hasErrors = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (rowError) {
|
||||
bad++;
|
||||
this.diff.push(Object.assign({}, row, {c_status: 'undefined'}));
|
||||
this.diff.push(Object.assign({}, actual[i], {c_status: 'comment'}));
|
||||
} else {
|
||||
good++;
|
||||
this.diff.push(row);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
get string () {
|
||||
if (!this.hasErrors) return null;
|
||||
|
||||
var s = ['Tables were not identical:'];
|
||||
s.push(this.headers.map(key => ' ' + key).join(' | '));
|
||||
this.diff.forEach((row) => {
|
||||
var rowString = '| ';
|
||||
this.headers.forEach((header) => {
|
||||
if (!row.c_status) rowString += chalk.green(' ' + row[header] + ' | ');
|
||||
else if (row.c_status === 'undefined') rowString += chalk.yellow('(-) ' + row[header] + ' | ');
|
||||
else rowString += chalk.red('(+) ' + row[header] + ' | ');
|
||||
});
|
||||
s.push(rowString);
|
||||
});
|
||||
|
||||
return s.join('\n') + '\nTODO this is a temp workaround waiting for https://github.com/cucumber/cucumber-js/issues/534';
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,15 +0,0 @@
|
||||
var exceptions = require('./exception_classes');
|
||||
|
||||
module.exports = function () {
|
||||
this.OSRMError = exceptions.OSRMError,
|
||||
|
||||
this.FileError = (code, msg) => new (exceptions.FileError.bind(exceptions.FileError, this.PREPROCESS_LOG_FILE))(code, msg);
|
||||
|
||||
this.LaunchError = (code, launchProcess, msg) => new (exceptions.LaunchError.bind(exceptions.LaunchError, this.ERROR_LOG_FILE))(code, launchProcess, msg);
|
||||
|
||||
this.ExtractError = (code, msg) => new (exceptions.ExtractError.bind(exceptions.ExtractError, this.PREPROCESS_LOG_FILE))(code, msg);
|
||||
|
||||
this.ContractError = (code, msg) => new (exceptions.ContractError.bind(exceptions.ContractError, this.PREPROCESS_LOG_FILE))(code, msg);
|
||||
|
||||
this.RoutedError = (msg) => new (exceptions.RoutedError.bind(exceptions.RoutedError, this.OSRM_ROUTED_LOG_FILE))(msg);
|
||||
};
|
||||
@@ -1,43 +0,0 @@
|
||||
var fs = require('fs');
|
||||
var path = require('path');
|
||||
var crypto = require('crypto');
|
||||
var d3 = require('d3-queue');
|
||||
|
||||
module.exports = function () {
|
||||
this.hashOfFiles = (paths, cb) => {
|
||||
paths = Array.isArray(paths) ? paths : [paths];
|
||||
var shasum = crypto.createHash('sha1'), hashedFiles = false;
|
||||
|
||||
var q = d3.queue(1);
|
||||
|
||||
var addFile = (path, cb) => {
|
||||
fs.readFile(path, (err, data) => {
|
||||
if (err && err.code === 'ENOENT') cb(); // ignore non-existing files
|
||||
else if (err) cb(err);
|
||||
else {
|
||||
shasum.update(data);
|
||||
hashedFiles = true;
|
||||
cb();
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
paths.forEach(path => { q.defer(addFile, path); });
|
||||
|
||||
q.awaitAll(err => {
|
||||
if (err) throw new Error('*** Error reading files:', err);
|
||||
if (!hashedFiles) throw new Error('*** No files found: [' + paths.join(', ') + ']');
|
||||
cb(shasum.digest('hex'));
|
||||
});
|
||||
};
|
||||
|
||||
this.hashProfile = (cb) => {
|
||||
this.hashOfFiles(path.resolve(this.PROFILES_PATH, this.profile + '.lua'), cb);
|
||||
};
|
||||
|
||||
this.hashString = (str) => {
|
||||
return crypto.createHash('sha1').update(str).digest('hex');
|
||||
};
|
||||
|
||||
return this;
|
||||
};
|
||||
+51
-26
@@ -1,36 +1,61 @@
|
||||
var util = require('util');
|
||||
'use strict';
|
||||
|
||||
var d3 = require('d3-queue');
|
||||
var path = require('path');
|
||||
var mkdirp = require('mkdirp');
|
||||
var rimraf = require('rimraf');
|
||||
var OSM = require('../lib/osm');
|
||||
var OSRMLoader = require('../lib/osrm_loader');
|
||||
|
||||
module.exports = function () {
|
||||
this.BeforeFeatures((features, callback) => {
|
||||
this.pid = null;
|
||||
this.initializeEnv(() => {
|
||||
this.initializeOptions(callback);
|
||||
});
|
||||
this.registerHandler('BeforeFeatures', {timeout: 30000}, (features, callback) => {
|
||||
this.osrmLoader = new OSRMLoader(this);
|
||||
this.OSMDB = new OSM.DB();
|
||||
|
||||
let queue = d3.queue(1);
|
||||
queue.defer(this.initializeEnv.bind(this));
|
||||
queue.defer(this.verifyOSRMIsNotRunning.bind(this));
|
||||
queue.defer(this.verifyExistenceOfBinaries.bind(this));
|
||||
queue.defer(this.initializeCache.bind(this));
|
||||
queue.defer(this.setupFeatures.bind(this, features));
|
||||
queue.awaitAll(callback);
|
||||
});
|
||||
|
||||
this.Before((scenario, callback) => {
|
||||
this.scenarioTitle = scenario.getName();
|
||||
|
||||
this.loadMethod = this.DEFAULT_LOAD_METHOD;
|
||||
this.queryParams = {};
|
||||
var d = new Date();
|
||||
this.scenarioTime = util.format('%d-%d-%dT%s:%s:%sZ', d.getFullYear(), d.getMonth()+1, d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds());
|
||||
this.resetData();
|
||||
this.hasLoggedPreprocessInfo = false;
|
||||
this.hasLoggedScenarioInfo = false;
|
||||
this.setGridSize(this.DEFAULT_GRID_SIZE);
|
||||
this.setOrigin(this.DEFAULT_ORIGIN);
|
||||
this.fingerprintExtract = this.hashString([this.luaLibHash, this.binExtractHash].join('-'));
|
||||
this.fingerprintContract = this.hashString(this.binContractHash);
|
||||
this.BeforeFeature((feature, callback) => {
|
||||
this.profile = this.DEFAULT_PROFILE;
|
||||
this.profileFile = path.join(this.PROFILES_PATH, this.profile + '.lua');
|
||||
this.setupFeatureCache(feature);
|
||||
callback();
|
||||
});
|
||||
|
||||
this.Before((scenario, callback) => {
|
||||
this.osrmLoader.setLoadMethod(this.DEFAULT_LOAD_METHOD);
|
||||
this.setGridSize(this.DEFAULT_GRID_SIZE);
|
||||
this.setOrigin(this.DEFAULT_ORIGIN);
|
||||
this.queryParams = {};
|
||||
this.extractArgs = '';
|
||||
this.contractArgs = '';
|
||||
this.environment = Object.assign(this.DEFAULT_ENVIRONMENT);
|
||||
this.resetOSM();
|
||||
|
||||
this.scenarioID = this.getScenarioID(scenario);
|
||||
this.setupScenarioCache(this.scenarioID);
|
||||
|
||||
// setup output logging
|
||||
let logDir = path.join(this.LOGS_PATH, this.featureID);
|
||||
this.scenarioLogFile = path.join(logDir, this.scenarioID) + '.log';
|
||||
d3.queue(1)
|
||||
.defer(mkdirp, logDir)
|
||||
.defer(rimraf, this.scenarioLogFile)
|
||||
.awaitAll(callback);
|
||||
});
|
||||
|
||||
this.After((scenario, callback) => {
|
||||
this.setExtractArgs('', () => {
|
||||
this.setContractArgs('', () => {
|
||||
if (this.loadMethod === 'directly' && !!this.OSRMLoader.loader) this.OSRMLoader.shutdown(callback);
|
||||
else callback();
|
||||
});
|
||||
});
|
||||
this.resetOptionsOutput();
|
||||
callback();
|
||||
});
|
||||
|
||||
this.AfterFeatures((features, callback) => {
|
||||
callback();
|
||||
});
|
||||
};
|
||||
|
||||
@@ -19,6 +19,9 @@ module.exports = function () {
|
||||
return paramString;
|
||||
};
|
||||
|
||||
// FIXME this needs to be simplified!
|
||||
// - remove usage of node-timeout
|
||||
// - replace with node's native timout mechanism
|
||||
this.sendRequest = (baseUri, parameters, callback) => {
|
||||
var limit = Timeout(this.TIMEOUT, { err: { statusCode: 408 } });
|
||||
|
||||
@@ -28,9 +31,9 @@ module.exports = function () {
|
||||
|
||||
request(this.query, (err, res, body) => {
|
||||
if (err && err.code === 'ECONNREFUSED') {
|
||||
throw new Error('*** osrm-routed is not running.');
|
||||
return cb(new Error('*** osrm-routed is not running.'));
|
||||
} else if (err && err.statusCode === 408) {
|
||||
throw new Error();
|
||||
return cb(new Error());
|
||||
}
|
||||
|
||||
return cb(err, res, body);
|
||||
@@ -40,11 +43,10 @@ module.exports = function () {
|
||||
runRequest(limit((err, res, body) => {
|
||||
if (err) {
|
||||
if (err.statusCode === 408)
|
||||
return callback(this.RoutedError('*** osrm-routed did not respond'));
|
||||
return callback(new Error('*** osrm-routed did not respond'));
|
||||
else if (err.code === 'ECONNREFUSED')
|
||||
return callback(this.RoutedError('*** osrm-routed is not running'));
|
||||
return callback(new Error('*** osrm-routed is not running'));
|
||||
}
|
||||
//console.log(body+"\n");
|
||||
return callback(err, res, body);
|
||||
}));
|
||||
};
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
var launchClasses = require('./launch_classes');
|
||||
|
||||
module.exports = function () {
|
||||
this._OSRMLoader = () => new (launchClasses._OSRMLoader.bind(launchClasses._OSRMLoader, this))();
|
||||
};
|
||||
@@ -1,164 +0,0 @@
|
||||
'use strict';
|
||||
|
||||
var fs = require('fs');
|
||||
var spawn = require('child_process').spawn;
|
||||
var util = require('util');
|
||||
var net = require('net');
|
||||
var Timeout = require('node-timeout');
|
||||
|
||||
var OSRMBaseLoader = class {
|
||||
constructor (scope) {
|
||||
this.scope = scope;
|
||||
}
|
||||
|
||||
launch (callback) {
|
||||
var limit = Timeout(this.scope.TIMEOUT, { err: this.scope.RoutedError('Launching osrm-routed timed out.') });
|
||||
|
||||
var runLaunch = (cb) => {
|
||||
this.osrmUp(() => { this.waitForConnection(cb); });
|
||||
};
|
||||
|
||||
runLaunch(limit((e) => { if (e) callback(e); else callback(); }));
|
||||
}
|
||||
|
||||
shutdown (callback) {
|
||||
var limit = Timeout(this.scope.TIMEOUT, { err: this.scope.RoutedError('Shutting down osrm-routed timed out.')});
|
||||
|
||||
var runShutdown = (cb) => {
|
||||
this.osrmDown(cb);
|
||||
};
|
||||
|
||||
runShutdown(limit((e) => { if (e) callback(e); else callback(); }));
|
||||
}
|
||||
|
||||
osrmIsRunning () {
|
||||
return !!this.scope.pid && this.child && !this.child.killed;
|
||||
}
|
||||
|
||||
osrmDown (callback) {
|
||||
if (this.scope.pid) {
|
||||
process.kill(this.scope.pid, this.scope.TERMSIGNAL);
|
||||
this.waitForShutdown(callback);
|
||||
this.scope.pid = null;
|
||||
} else callback(true);
|
||||
}
|
||||
|
||||
waitForConnection (callback) {
|
||||
var retryCount = 0;
|
||||
var connectWithRetry = () => {
|
||||
net.connect({ port: this.scope.OSRM_PORT, host: '127.0.0.1' })
|
||||
.on('connect', () => { callback(); })
|
||||
.on('error', () => {
|
||||
if (retryCount < 2) {
|
||||
retryCount++;
|
||||
setTimeout(connectWithRetry, 100);
|
||||
} else {
|
||||
callback(new Error('Could not connect to osrm-routed after three retires'));
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
connectWithRetry();
|
||||
}
|
||||
|
||||
waitForShutdown (callback) {
|
||||
var check = () => {
|
||||
if (!this.osrmIsRunning()) return callback();
|
||||
};
|
||||
setTimeout(check, 100);
|
||||
}
|
||||
};
|
||||
|
||||
var OSRMDirectLoader = class extends OSRMBaseLoader {
|
||||
constructor (scope) {
|
||||
super(scope);
|
||||
}
|
||||
|
||||
load (inputFile, callback) {
|
||||
this.inputFile = inputFile;
|
||||
this.shutdown(() => {
|
||||
this.launch(callback);
|
||||
});
|
||||
}
|
||||
|
||||
osrmUp (callback) {
|
||||
if (this.scope.pid) return callback();
|
||||
var writeToLog = (data) => {
|
||||
fs.appendFile(this.scope.OSRM_ROUTED_LOG_FILE, data, (err) => { if (err) throw err; });
|
||||
};
|
||||
|
||||
var child = spawn(util.format('%s/osrm-routed', this.scope.BIN_PATH), [this.inputFile, util.format('-p%d', this.scope.OSRM_PORT)]);
|
||||
this.scope.pid = child.pid;
|
||||
child.stdout.on('data', writeToLog);
|
||||
child.stderr.on('data', writeToLog);
|
||||
|
||||
callback();
|
||||
}
|
||||
};
|
||||
|
||||
var OSRMDatastoreLoader = class extends OSRMBaseLoader {
|
||||
constructor (scope) {
|
||||
super(scope);
|
||||
}
|
||||
|
||||
load (inputFile, callback) {
|
||||
this.inputFile = inputFile;
|
||||
this.loadData((err) => {
|
||||
if (err) return callback(err);
|
||||
if (!this.scope.pid) return this.launch(callback);
|
||||
else callback();
|
||||
});
|
||||
}
|
||||
|
||||
loadData (callback) {
|
||||
this.scope.runBin('osrm-datastore', this.inputFile, (err) => {
|
||||
if (err) return callback(this.scope.LaunchError(this.exitCode, 'datastore', err));
|
||||
callback();
|
||||
});
|
||||
}
|
||||
|
||||
osrmUp (callback) {
|
||||
if (this.scope.pid) return callback();
|
||||
var writeToLog = (data) => {
|
||||
fs.appendFile(this.scope.OSRM_ROUTED_LOG_FILE, data, (err) => { if (err) throw err; });
|
||||
};
|
||||
|
||||
var child = spawn(util.format('%s/osrm-routed', this.scope.BIN_PATH), ['--shared-memory=1', util.format('-p%d', this.scope.OSRM_PORT)]);
|
||||
this.child = child;
|
||||
this.scope.pid = child.pid;
|
||||
child.stdout.on('data', writeToLog);
|
||||
child.stderr.on('data', writeToLog);
|
||||
|
||||
callback();
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
_OSRMLoader: class {
|
||||
constructor (scope) {
|
||||
this.scope = scope;
|
||||
this.loader = null;
|
||||
}
|
||||
|
||||
load (inputFile, callback) {
|
||||
var method = this.scope.loadMethod;
|
||||
if (method === 'datastore') {
|
||||
this.loader = new OSRMDatastoreLoader(this.scope);
|
||||
this.loader.load(inputFile, callback);
|
||||
} else if (method === 'directly') {
|
||||
this.loader = new OSRMDirectLoader(this.scope);
|
||||
this.loader.load(inputFile, callback);
|
||||
} else {
|
||||
callback(new Error('*** Unknown load method ' + method));
|
||||
}
|
||||
}
|
||||
|
||||
shutdown (callback) {
|
||||
this.loader.shutdown(callback);
|
||||
}
|
||||
|
||||
up () {
|
||||
return this.loader ? this.loader.osrmIsRunning() : false;
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,90 +0,0 @@
|
||||
var fs = require('fs');
|
||||
|
||||
module.exports = function () {
|
||||
this.clearLogFiles = (callback) => {
|
||||
// emptying existing files, rather than deleting and writing new ones makes it
|
||||
// easier to use tail -f from the command line
|
||||
fs.writeFile(this.OSRM_ROUTED_LOG_FILE, '', err => {
|
||||
if (err) throw err;
|
||||
fs.writeFile(this.PREPROCESS_LOG_FILE, '', err => {
|
||||
if (err) throw err;
|
||||
fs.writeFile(this.LOG_FILE, '', err => {
|
||||
if (err) throw err;
|
||||
callback();
|
||||
});
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
var log = this.log = (s, type) => {
|
||||
s = s || '';
|
||||
type = type || null;
|
||||
var file = type === 'preprocess' ? this.PREPROCESS_LOG_FILE : this.LOG_FILE;
|
||||
fs.appendFile(file, s + '\n', err => {
|
||||
if (err) throw err;
|
||||
});
|
||||
};
|
||||
|
||||
this.logScenarioFailInfo = () => {
|
||||
if (this.hasLoggedScenarioInfo) return;
|
||||
|
||||
log('=========================================');
|
||||
log('Failed scenario: ' + this.scenarioTitle);
|
||||
log('Time: ' + this.scenarioTime);
|
||||
log('Fingerprint osm stage: ' + this.osmData.fingerprintOSM);
|
||||
log('Fingerprint extract stage: ' + this.fingerprintExtract);
|
||||
log('Fingerprint contract stage: ' + this.fingerprintContract);
|
||||
log('Fingerprint route stage: ' + this.fingerprintRoute);
|
||||
log('Profile: ' + this.profile);
|
||||
log();
|
||||
log('```xml'); // so output can be posted directly to github comment fields
|
||||
log(this.osmData.str.trim());
|
||||
log('```');
|
||||
log();
|
||||
log();
|
||||
|
||||
this.hasLoggedScenarioInfo = true;
|
||||
};
|
||||
|
||||
this.logFail = (expected, got, attempts) => {
|
||||
this.logScenarioFailInfo();
|
||||
log('== ');
|
||||
log('Expected: ' + JSON.stringify(expected));
|
||||
log('Got: ' + JSON.stringify(got));
|
||||
log();
|
||||
['route','forw','backw'].forEach((direction) => {
|
||||
if (attempts[direction]) {
|
||||
log('Direction: ' + direction);
|
||||
log('Query: ' + attempts[direction].query);
|
||||
log('Response: ' + attempts[direction].response.body);
|
||||
log();
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
this.logPreprocessInfo = () => {
|
||||
if (this.hasLoggedPreprocessInfo) return;
|
||||
log('=========================================', 'preprocess');
|
||||
log('Preprocessing data for scenario: ' + this.scenarioTitle, 'preprocess');
|
||||
log('Time: ' + this.scenarioTime, 'preprocess');
|
||||
log('', 'preprocess');
|
||||
log('== OSM data:', 'preprocess');
|
||||
log('```xml', 'preprocess'); // so output can be posted directly to github comment fields
|
||||
log(this.osmData.str, 'preprocess');
|
||||
log('```', 'preprocess');
|
||||
log('', 'preprocess');
|
||||
log('== Profile:', 'preprocess');
|
||||
log(this.profile, 'preprocess');
|
||||
log('', 'preprocess');
|
||||
this.hasLoggedPreprocessInfo = true;
|
||||
};
|
||||
|
||||
this.logPreprocess = (str) => {
|
||||
this.logPreprocessInfo();
|
||||
log(str, 'preprocess');
|
||||
};
|
||||
|
||||
this.logPreprocessDone = () => {
|
||||
log('Done with preprocessing at ' + new Date(), 'preprocess');
|
||||
};
|
||||
};
|
||||
@@ -1,7 +1,8 @@
|
||||
'use strict';
|
||||
|
||||
var Timeout = require('node-timeout');
|
||||
var request = require('request');
|
||||
const Timeout = require('node-timeout');
|
||||
const request = require('request');
|
||||
const ensureDecimal = require('../lib/utils').ensureDecimal;
|
||||
|
||||
module.exports = function () {
|
||||
this.requestPath = (service, params, callback) => {
|
||||
@@ -42,7 +43,7 @@ module.exports = function () {
|
||||
};
|
||||
|
||||
var encodeWaypoints = (waypoints) => {
|
||||
return waypoints.map(w => [w.lon, w.lat].map(this.ensureDecimal).join(','));
|
||||
return waypoints.map(w => [w.lon, w.lat].map(ensureDecimal).join(','));
|
||||
};
|
||||
|
||||
this.requestRoute = (waypoints, bearings, userParams, callback) => {
|
||||
|
||||
+42
-30
@@ -1,40 +1,52 @@
|
||||
var fs = require('fs');
|
||||
var util = require('util');
|
||||
var exec = require('child_process').exec;
|
||||
'use strict';
|
||||
|
||||
const fs = require('fs');
|
||||
const util = require('util');
|
||||
const child_process = require('child_process');
|
||||
|
||||
module.exports = function () {
|
||||
this.runBin = (bin, options, callback) => {
|
||||
var opts = options.slice();
|
||||
// replaces placeholders for in user supplied commands
|
||||
this.expandOptions = (options) => {
|
||||
let opts = options.slice();
|
||||
let table = {
|
||||
'{osm_file}': this.inputCacheFile,
|
||||
'{processed_file}': this.processedCacheFile,
|
||||
'{profile_file}': this.profileFile,
|
||||
'{rastersource_file}': this.rasterCacheFile,
|
||||
'{speeds_file}': this.speedsCacheFile,
|
||||
'{penalties_file}': this.penaltiesCacheFile
|
||||
};
|
||||
|
||||
if (opts.match('{osm_base}')) {
|
||||
if (!this.osmData.osmFile) throw new Error('*** {osm_base} is missing');
|
||||
opts = opts.replace('{osm_base}', this.osmData.osmFile);
|
||||
for (let k in table) {
|
||||
opts = opts.replace(k, table[k]);
|
||||
}
|
||||
|
||||
if (opts.match('{extracted_base}')) {
|
||||
if (!this.osmData.extractedFile) throw new Error('*** {extracted_base} is missing');
|
||||
opts = opts.replace('{extracted_base}', this.osmData.extractedFile);
|
||||
return opts;
|
||||
};
|
||||
|
||||
this.setupOutputLog = (process, log) => {
|
||||
if (process.logFunc) {
|
||||
process.stdout.removeListener('data', process.logFunc);
|
||||
process.stderr.removeListener('data', process.logFunc);
|
||||
}
|
||||
|
||||
if (opts.match('{contracted_base}')) {
|
||||
if (!this.osmData.contractedFile) throw new Error('*** {contracted_base} is missing');
|
||||
opts = opts.replace('{contracted_base}', this.osmData.contractedFile);
|
||||
}
|
||||
process.logFunc = (message) => { log.write(message); };
|
||||
process.stdout.on('data', process.logFunc);
|
||||
process.stderr.on('data', process.logFunc);
|
||||
};
|
||||
|
||||
if (opts.match('{profile}')) {
|
||||
opts = opts.replace('{profile}', [this.PROFILES_PATH, this.profile + '.lua'].join('/'));
|
||||
}
|
||||
|
||||
var cmd = util.format('%s%s/%s%s%s %s 2>%s', this.QQ, this.BIN_PATH, bin, this.EXE, this.QQ, opts, this.ERROR_LOG_FILE);
|
||||
process.chdir(this.TEST_FOLDER);
|
||||
exec(cmd, (err, stdout, stderr) => {
|
||||
this.stdout = stdout.toString();
|
||||
fs.readFile(this.ERROR_LOG_FILE, (e, data) => {
|
||||
this.stderr = data ? data.toString() : '';
|
||||
this.exitCode = err && err.code || 0;
|
||||
process.chdir('../');
|
||||
callback(err, stdout, stderr);
|
||||
});
|
||||
});
|
||||
this.runBin = (bin, options, env, callback) => {
|
||||
let cmd = util.format('%s%s/%s%s%s', this.QQ, this.BIN_PATH, bin, this.EXE, this.QQ);
|
||||
let opts = options.split(' ').filter((x) => { return x && x.length > 0; });
|
||||
let log = fs.createWriteStream(this.scenarioLogFile, {'flags': 'a'});
|
||||
log.write(util.format('*** running %s %s\n', cmd, options));
|
||||
// we need to set a large maxbuffer here because we have long running processes like osrm-routed
|
||||
// with lots of log output
|
||||
let child = child_process.execFile(cmd, opts, {maxBuffer: 1024 * 1024 * 1000, env: env}, callback);
|
||||
child.on('exit', function(code) {
|
||||
log.end(util.format('*** %s exited with code %d\n', bin, code));
|
||||
}.bind(this));
|
||||
this.setupOutputLog(child, log);
|
||||
return child;
|
||||
};
|
||||
};
|
||||
|
||||
@@ -93,7 +93,7 @@ module.exports = function () {
|
||||
if (headers.has('distance')) {
|
||||
if (row.distance.length) {
|
||||
if (!row.distance.match(/\d+m/))
|
||||
throw new Error('*** Distance must be specified in meters. (ex: 250m)');
|
||||
return cb(new Error('*** Distance must be specified in meters. (ex: 250m)'));
|
||||
got.distance = instructions ? util.format('%dm', distance) : '';
|
||||
} else {
|
||||
got.distance = '';
|
||||
@@ -102,7 +102,7 @@ module.exports = function () {
|
||||
|
||||
if (headers.has('time')) {
|
||||
if (!row.time.match(/\d+s/))
|
||||
throw new Error('*** Time must be specied in seconds. (ex: 60s)');
|
||||
return cb(new Error('*** Time must be specied in seconds. (ex: 60s)'));
|
||||
got.time = instructions ? util.format('%ds', time) : '';
|
||||
}
|
||||
|
||||
@@ -113,7 +113,7 @@ module.exports = function () {
|
||||
if (headers.has('speed')) {
|
||||
if (row.speed !== '' && instructions) {
|
||||
if (!row.speed.match(/\d+ km\/h/))
|
||||
throw new Error('*** Speed must be specied in km/h. (ex: 50 km/h)');
|
||||
cb(new Error('*** Speed must be specied in km/h. (ex: 50 km/h)'));
|
||||
var speed = time > 0 ? Math.round(3.6*distance/time) : null;
|
||||
got.speed = util.format('%d km/h', speed);
|
||||
} else {
|
||||
@@ -139,20 +139,12 @@ module.exports = function () {
|
||||
putValue('destinations', destinations);
|
||||
}
|
||||
|
||||
var ok = true;
|
||||
|
||||
for (var key in row) {
|
||||
if (this.FuzzyMatch.match(got[key], row[key])) {
|
||||
got[key] = row[key];
|
||||
} else {
|
||||
ok = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (!ok) {
|
||||
this.logFail(row, got, { route: { query: this.query, response: res }});
|
||||
}
|
||||
|
||||
cb(null, got);
|
||||
} else {
|
||||
cb(new Error('request failed to return valid body'));
|
||||
@@ -189,11 +181,11 @@ module.exports = function () {
|
||||
|
||||
if (row.from && row.to) {
|
||||
var fromNode = this.findNodeByName(row.from);
|
||||
if (!fromNode) throw new Error(util.format('*** unknown from-node "%s"'), row.from);
|
||||
if (!fromNode) return cb(new Error(util.format('*** unknown from-node "%s"'), row.from));
|
||||
waypoints.push(fromNode);
|
||||
|
||||
var toNode = this.findNodeByName(row.to);
|
||||
if (!toNode) throw new Error(util.format('*** unknown to-node "%s"'), row.to);
|
||||
if (!toNode) return cb(new Error(util.format('*** unknown to-node "%s"'), row.to));
|
||||
waypoints.push(toNode);
|
||||
|
||||
got.from = row.from;
|
||||
@@ -202,13 +194,13 @@ module.exports = function () {
|
||||
} else if (row.waypoints) {
|
||||
row.waypoints.split(',').forEach((n) => {
|
||||
var node = this.findNodeByName(n.trim());
|
||||
if (!node) throw new Error('*** unknown waypoint node "%s"', n.trim());
|
||||
if (!node) return cb(new Error('*** unknown waypoint node "%s"', n.trim()));
|
||||
waypoints.push(node);
|
||||
});
|
||||
got.waypoints = row.waypoints;
|
||||
this.requestRoute(waypoints, bearings, params, afterRequest);
|
||||
} else {
|
||||
throw new Error('*** no waypoints');
|
||||
return cb(new Error('*** no waypoints'));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
var DifferentError = require('./exception_classes').TableDiffError;
|
||||
|
||||
module.exports = function () {
|
||||
this.diffTables = (expected, actual, options, callback) => {
|
||||
// this is a temp workaround while waiting for https://github.com/cucumber/cucumber-js/issues/534
|
||||
|
||||
var error = new DifferentError(expected, actual);
|
||||
|
||||
return callback(error.string);
|
||||
};
|
||||
};
|
||||
Reference in New Issue
Block a user