Manager.prototype._areCompatible = function (candidate, resolved) {
var resolvedVersion;
var highestCandidate;
var highestResolved;
// Check if targets are equal
if (candidate.target === resolved.target) {
return true;
}
resolvedVersion = resolved.pkgMeta && resolved.pkgMeta.version;
if (!resolvedVersion) {
return false;
}
// If target is a version, compare against the resolved version
if (semver.valid(candidate.target)) {
return semver.eq(candidate.target, resolvedVersion);
}
// If target is a range, check if the max versions of the range are the same
// and if the resolved version satisfies the candidate target
if (semver.validRange(candidate.target)) {
highestCandidate = this._getCap(semver.toComparators(candidate.target), 'highest');
highestResolved = this._getCap(semver.toComparators(resolved.target), 'highest');
return highestCandidate.version && highestResolved.version &&
semver.eq(highestCandidate.version, highestResolved.version) &&
highestCandidate.comparator === highestResolved.comparator &&
semver.satisfies(resolvedVersion, candidate.target);
}
return false;
};
var pendingUpdates = function(code, database) {
// Check the validity of the the code and database version numbers.
if (
(!code || typeof code !== 'string' || !semver.valid(code))
|| (!database || typeof database !== 'string' || !semver.valid(database))
) {
return unlock(function() {
throw new Error('The provided versions given for comparison, do not match the semantic versioning format; ' +
'code: ' + code + ', database: ' + database);
});
}
// Versions are the same, skip updates.
if (semver.eq(code, database)) {
debug('Current database (' + database + ') and Pending code sversions (' + code + ') are the same.');
return false;
}
else if (semver.gt(database, code)) {
unlock(function() {
throw new Error(
'The provided codebase version is more recent than the database schema version. Update the codebase and ' +
'restart.'
);
});
}
else {
// The code has a higher version than the database, lock the database and update the schemas.
return true;
}
};
export function isConfigVersionUpgradeable(savedVersion, kibanaVersion) {
if (
typeof savedVersion !== 'string' ||
typeof kibanaVersion !== 'string' ||
savedVersion === kibanaVersion ||
/alpha|beta|snapshot/i.test(savedVersion)
) {
return false;
}
const [savedReleaseVersion, savedRcNumber] = extractRcNumber(savedVersion);
const [kibanaReleaseVersion, kibanaRcNumber] = extractRcNumber(kibanaVersion);
// ensure that both release versions are valid, if not then abort
if (!semver.valid(savedReleaseVersion) || !semver.valid(kibanaReleaseVersion)) {
return false;
}
// ultimately if the saved config is from a previous kibana version
// or from an earlier rc of the same version, then we can upgrade
const savedIsLessThanKibana = semver.lt(savedReleaseVersion, kibanaReleaseVersion);
const savedIsSameAsKibana = semver.eq(savedReleaseVersion, kibanaReleaseVersion);
const savedRcIsLessThanKibana = savedRcNumber < kibanaRcNumber;
return savedIsLessThanKibana || (savedIsSameAsKibana && savedRcIsLessThanKibana);
}
exports.load = function (service, accessKeyId, secretAccessKey, sessionToken, httpOptions) {
if (service === 's3') {
if (semver.eq(process.version, 'v0.6.9')) {
throw new Error('FATAL: The S3 client is NOT supported under node.js v0.6.9.');
}
}
if (semver.lt(process.version, 'v0.8.5')) {
console.error('Warning: aws2js under node.js v0.8.4 and below is deprecated. Only node.js v0.8.5+ will be supported.');
}
var clientTemplate = cfg.clients[service], key;
if ( ! clientTemplate) {
throw new Error('Invalid AWS client');
}
if (service !== 's3') {
clientTemplate.path = '/';
}
var clientConfig = lodash.clone(clientTemplate, true);
var result = client(clientConfig, httpOptions || {});
if (accessKeyId && secretAccessKey) {
result.setCredentials(accessKeyId, secretAccessKey, sessionToken);
}
return result;
};
async.eachSeries(versions, (upgradingVersion, nextVersion) => {
if (semver.eq(upgradingVersion, versionAim) || (semver.gt(upgradingVersion, versionStart) && semver.lt(upgradingVersion, versionAim))) {
console.log(`upgrading to version ${upgradingVersion}`);
var sqlFiles = this.getFiles(upgradingVersion);
console.debug(`all files for ${upgradingVersion}`, sqlFiles);
async.eachSeries(sqlFiles,(file, nextFile) => {
var sqlFileContent = fs.readFileSync(path.resolve(__dirname, `${upgradingVersion}/${file}`), 'utf8');
console.debug("Executing: ", sqlFileContent);
models.sequelize.query(sqlFileContent, {
raw: true
}).then( () => {
console.log("** query success ** ");
nextFile();
}).catch ( (error) => {
nextFile({
msg: `error upgrading to version ${upgradingVersion}`,
details: error
});
});
}, (error) => {
if (error) {
console.error(error);
return nextVersion(error);
}
console.log(`upgraded to version ${upgradingVersion}`, error);
nextVersion();
});
} else {
nextVersion();
}
}, (error) => {
function shouldPublish(options, localVersion, remoteVersion) {
options = options || {};
log.info('Local version: ' + localVersion);
log.info('Published version: ' + remoteVersion);
if (semver.eq(remoteVersion, localVersion)) {
log.info('Your local version is the same as your published version: publish will do nothing');
return false;
}
if (semver.gt(remoteVersion, localVersion)) {
log.warn('Your local version is smaller than your published version: publish will do nothing');
return false;
}
if (containsOnVersion(options)) {
var diff = semver.diff(remoteVersion, localVersion);
if (!options['on-' + diff]) {
log.info('Your local version does not satisfy your --on-[major|minor|patch|build] options; publish will do nothing');
return false;
}
}
log.info('Defined criteria met; publish will release a new version');
return true;
}
versions.forEach(function (version) {
if (semver.eq(version, newVersion)) {
throw createError('Version exists: ' + newVersion, 'EVERSIONEXISTS', {
versions: versions,
newVersion: newVersion
});
}
});
setImmediate(function() {
if(!that._version || !semver.eq(that._version, packageJson.version)) {
return that.emit('error', new Error('Specified version does not match current system version'));
}
if(!that._update) {
return that.emit('error', new Error('Update missing'));
}
update();
});
config.storeVersion(function (err, version) {
if (err)
return callback(err);
var configVersion = config.get('version') || '0.0.0';
if (version) {
//we have an existing config
if (semver.gt(configVersion, version)) {
//we need to replace the existing version
joola.logger.warn('Found an out-dated central configuration store with version [' + version + '], updating to version [' + configVersion + '].');
config.storePopulate(config._config, function (err) {
if (err)
return callback(err);
//store is now populated with local copy
joola.events.emit('config:done');
return callback(null);
});
}
else if (semver.eq(version, configVersion)) {
joola.logger.info('Found a valid configuration store with version [' + version + '].');
config.localApply(version, function (err) {
if (err)
return callback(err);
joola.events.emit('config:done');
return callback(null);
});
}
else {
joola.logger.info('Found an out-dated local configuration with version [' + version + '].');
//we need to override local configuration with central
config.localApply(version, function (err) {
if (err)
return callback(err);
joola.events.emit('config:done');
return callback(null);
});
}
}
else {
//we have an empty store, let's populate it
config.overrideWithEnvironment();
config.storePopulate(config._config, function (err) {
if (err)
return callback(err);
//store is now populated with local copy
joola.events.emit('config:done');
return callback(null);
});
}
});
moveStateFromLegacyPlace() {
// read state from legacy place
const state = this.getStateLegacy();
// state not found in legacy place
if (semver_1.eq(state.version, SettingsManager.defaultState.version)) {
return Promise.resolve();
}
// store in new place: 'globalState'
return this.setState(state).then(() =>
// delete state from legacy place
this.deleteStateLegacy());
}
function single_vs_range(a,b,bValidRange) {
if (semver.gtr(a, b)) {
return 1;
} else if (semver.ltr(a, b)) {
return -1
}
var brange = bValidRange.replace(/[<>=]/g,'').split(' ');
var bmin = brange[0];
if (semver.eq(a,bmin)) {
return -1;
}
return 1;
}
export function diffWithUnstable(version1: string, version2: string): Release | null {
if (semver.eq(version1, version2) === false) {
const v1 = semver.parse(version1);
const v2 = semver.parse(version2);
if (v1 != null && v2 != null) {
const isPreRelease = v1.prerelease.length > 0 || v2.prerelease.length > 0;
const preMajor = v1.major === 0 || v2.major === 0;
const preMinor = preMajor && (v1.minor === 0 || v2.minor === 0);
let diff = null;
if (v1.major !== v2.major) {
diff = 'major';
} else if (v1.minor !== v2.minor) {
if (preMajor) {
// If the major version number is zero (0.x.x), treat a change
// of the minor version number as a major change.
diff = 'major';
} else {
diff = 'minor';
}
} else if (v1.patch !== v2.patch) {
if (preMinor) {
// If the major & minor version numbers are zero (0.0.x), treat a change
// of the patch version number as a major change.
diff = 'major';
} else if (preMajor) {
// If the major version number is zero (0.x.x), treat a change
// of the patch version number as a minor change.
diff = 'minor';
} else {
diff = 'patch';
}
}
if (isPreRelease) {
if (diff != null) {
diff = PRE_RELEASES[diff];
} else {
diff = 'prerelease';
}
}
return diff;
}
}
return null;
}
getCurrentVersion(function (err, current) {
if (err) {
cb(err);
}
else if (semver.lt(ver, current.ver)) {
downgrade(current.ver, ver, cb);
}
else if (semver.eq(ver, current.ver)) {
cb(null, 'Version "' + ver + '" is already installed');
}
else {
dl_and_install(ver, cb);
}
});
.then(tags => {
var newVersions = []
for(tag of tags) {
if (semver.gt(tag.name, update.latest) || (
semver.eq(tag.name, update.latest) && (semver(tag.name).build[0] || 0) > (semver(update.latest).build[0] || 0)
)) {
newVersions.push(tag)
}
}
newVersions.reverse()
// order versions from lower to greater
console.log(chalk.blue('New versions available: ' + (newVersions.map(v => v.name).join(', ') || 'none') + '.'))
return newVersions
})
}).then(function(res) {
for (var ii = 0; ii < res.length; ++ii) {
var release = res[ii];
if (semver.valid(release.name)) {
console.log("found existing release: " + release.name);
if (!highestVersion || semver.gt(release.name, highestVersion)) {
highestVersion = release.name;
}
}
}
// If we specified a version, make sure it's higher than the highest published version
if (options.version) {
if (highestVersion && semver.lte(version, highestVersion)) {
return Promise.reject(new Error("version '" + version + "' is less than highest released version: " + highestVersion));
}
// Make sure this verison is >= package.json
if (semver.lt(version, info.version)) {
return Promise.reject(new Error("version '" + version + "' is less than package.json version: " + info.version));
}
} else {
// If there is no published version just use version in package.json
if (!highestVersion) {
version = info.version;
return Promise.resolve();
}
version = semver.inc(highestVersion, options.bump);
if (!version) {
return Promise.reject(new Error("bad bump type: '" + options.bump + "'"));
}
if (semver.lt(version, info.version)) {
version = info.version;
}
}
// check if version in package.json matches. If not ask
if (!semver.eq(version, info.version)) {
return askOrForce('update package.json to version:' + version).then(function() {
runtimeInfo.info.version = version;
gameInfo.writeGameInfo(runtimeInfo);
console.warn("don't forgot to commit the new updated package.json");
return Promise.resolve();
});
}
return Promise.resolve();
}).then(function() {
exec( path.join( binPath, 'clever-downgrade' ) + ' clever-datatables@0.0.1', { cwd: path.join( assetPath, 'my-new-project', 'frontend' ) }, function ( err, stdout, stderr ) {
expect( stderr ).to.equal( '' );
expect( fs.existsSync( path.join( assetPath, 'my-new-project', 'frontend', 'app', 'modules', 'cs_datatables', 'bower.json' ) ) ).to.be.true;
if (require.cache[ path.join( assetPath, 'my-new-project', 'frontend', 'app', 'modules', 'cs_datatables', 'bower.json' ) ]) {
delete require.cache[ require.resolve( path.join( assetPath, 'my-new-project', 'frontend', 'app', 'modules', 'cs_datatables', 'bower.json' ) ) ];
}
var pkg = require( path.join( assetPath, 'my-new-project', 'frontend', 'app', 'modules', 'cs_datatables', 'bower.json' ) );
expect( pkg.name ).to.equal( 'clever-datatables' );
expect( semver.eq( pkg.version, '0.0.1' ) ).to.true;
done( err );
} );
return exec('npm info ' + name + ' versions --json --loglevel=info', function (err, json) {
if (err) {
if ((/^npm ERR! code E404$/m).test(err)) {
return callback(null, 'v' + version + ' is the first version published.');
}
return callback([
'Error fetching package versions:',
err
]);
}
var allVersions;
try {
allVersions = [].concat(JSON.parse(json));
} catch (e) {
return callback([
'Error parsing JSON from npm',
e
]);
}
var versions = allVersions.filter(isNotPrerelease);
if (versions.length === 0) {
return callback(null, 'No non-prerelease versions detected.');
}
var max = semver.maxSatisfying(versions, '*');
if (semver.eq(version, max)) {
return callback([
'Attempting to publish already-published version v' + version + '.'
]);
}
var greater = semver.gtr(version, versions.join('||'));
var prerelease = isPrerelease(version);
if (!greater || prerelease) {
var msg = prerelease
? format('Attempting to publish v%s as "latest", but it is a prerelease version.', version)
: format('Attempting to publish v%s as "latest", but it is not later than v%s.', version, max);
return callback([
msg,
'\nPossible Solutions:',
'\t1) Provide a dist-tag: `npm publish --tag=backport`, for example',
'\t2) Use the very dangerous override: `PUBLISH_LATEST_DANGEROUSLY=true npm publish`'
]);
}
return callback(null, format('v%s is later than v%s.', version, max));
});
exec( path.join( binPath, 'clever-downgrade' ) + ' clever-background-tasks@0.0.1', { cwd: path.join( assetPath, 'my-new-project', 'backend' ) }, function ( err, stdout, stderr ) {
expect( stderr ).to.equal( '' );
expect( fs.existsSync( path.join( assetPath, 'my-new-project', 'backend', 'modules', 'clever-background-tasks', 'package.json' ) ) ).to.be.true;
expect( fs.existsSync( path.join( assetPath, 'my-new-project', 'backend', 'node_modules', 'memcached' ) ) ).to.be.true;
if (require.cache[ path.join( assetPath, 'my-new-project', 'backend', 'modules', 'clever-background-tasks', 'package.json' ) ]) {
delete require.cache[ require.resolve( path.join( assetPath, 'my-new-project', 'backend', 'modules', 'clever-background-tasks', 'package.json' ) ) ];
}
var pkg = require( path.join( assetPath, 'my-new-project', 'backend', 'modules', 'clever-background-tasks', 'package.json' ) );
expect( pkg.name ).to.equal( 'clever-background-tasks' );
expect( semver.eq( pkg.version, '0.0.1' ) ).to.true;
done( err );
} );
checkFHCUpToDate: function(cb) {
var self = this,
cachedLatest = ini.get('fhclatest');
try {
cachedLatest = JSON.parse(cachedLatest)
} catch (error) {}
if (!_.isEmpty(cachedLatest)) {
if(cachedLatest.current && semver.eq(cleanupVersion(cachedLatest.current), cleanupVersion(fhc._version))){
if (cachedLatest.ts - (new Date().getTime() - (dayInMs * daysToCache)) > 0) {
self.latest = cachedLatest;
return cb(cachedLatest.is);
}
}
}
return this.checkLatestFromServer(cb);
},
versions: npm.view(function (next, viewObj) {
viewObj.versions = viewObj.versions || {}
var versions = {}
ref.private = (!Object.keys(viewObj).length > 1 || !viewObj.versions[v])
if (!ref.private) {
var latestVersion = viewObj['dist-tags'].latest
versions[v] = {
isDeprecated: (!!viewObj.versions[v].deprecated),
isOutdated: semver.eq(latestVersion, v),
dependencies: viewObj.versions[v].dependencies || {}
}
}
return next(null, versions)
})
], function (err, results) {
if (err) {
return fail(err);
}
const last = results[0], latest = results[1];
console.log(' > last: %s, latest: %s', (last || '(none)'), latest);
if (semver.eq(last, latest)) {
return fail(' > already have latest jsdoc3 build', 0);
}
if (semver.gt(last, latest)) {
return fail(' > got previous version %s'.replace('%s', latest), 0);
}
console.log(' > using working version %s...', latest);
config.WORKING_VERSION = latest;
complete();
});
function mergeBounds(range, bound) {
if (!bound) {
return range;
}
var _parseRange3 = parseRange(range),
condition = _parseRange3.condition,
version = _parseRange3.version;
var boundingVersion = parseRange(bound).version;
var comparator = condition.startsWith('<') ? semver.lt : semver.gt;
var strict = condition === '<' || condition === '>';
if (comparator(version, boundingVersion)) {
return range;
} else if (strict && semver.eq(version, boundingVersion)) {
return range;
} else {
return bound;
}
}
function shouldPublish(options, localVersion, remoteVersion) {
options = options || {};
log.info('Local version: ' + localVersion);
log.info('Published version: ' + remoteVersion);
if (semver.eq(remoteVersion, localVersion)) {
log.info('Your local version is the same as your published version: publish will do nothing');
return false;
} else if (semver.gt(remoteVersion, localVersion)) {
log.warn('Your local version is smaller than your published version: publish will do nothing');
return false;
} else {
remoteVersion = semver.parse(remoteVersion);
localVersion = semver.parse(localVersion);
var shouldPublish = true;
for (var i = 0; i < onVersions.length; i++) {
var onVersion = onVersions[i];
var parsedIndex = parsedIndexLookup[onVersion];
if (options[onVersion]) {
if (remoteVersion[parsedIndex] === localVersion[parsedIndex]) {
shouldPublish = false;
} else {
shouldPublish = true;
break;
}
}
}
if (!shouldPublish) {
log.info('Your local version does not satisfy your --on-[major|minor|patch|build] options');
}
return shouldPublish;
}
}
var mochaDir = path.dirname(require.resolve("mocha"));
function makeMochaCopyFunction(fileName) {
return function copy(callback) {
var src = path.join(mochaDir, fileName);
var dst = path.join(__dirname, fileName);
fs.unlink(dst, function() {
fs.symlink(src, dst, callback);
});
};
}
enqueue(makeMochaCopyFunction("mocha.js"));
enqueue(makeMochaCopyFunction("mocha.css"));
// uglify-js does not work properly due to Node 0.11.7 bug.
// (https://github.com/joyent/node/issues/6235)
if (!semver.eq(process.version, "0.11.7")) {
try {
require.resolve("browserify"); // Throws if missing.
enqueue(bundle, [
"./test/tests.es5.js",
"./test/tests.browser.js"
]);
} catch (ignored) {
console.error("browserify not installed; skipping bundle step");
}
}
flush();
return _.find( versions, function (version) {
return semver.eq(version,pkg.version);
});
exports.eq = function (v1, v2) { return semver.eq(exports.format(v1, 3, 3), exports.format(v2, 3, 3)); };
info.versions.sort(function(a, b) {
if (semver.eq(a.version, b.version)) {
return 0;
}
return semver.gt(a.version, b.version) ? 1 : -1;
});
eq: function (v2) {
return semver.eq(v1, v2);
}
exports.eq = function eq(v1, v2) {
return semver.eq(format(v1, 3, 3), format(v2, 3, 3));
};
it('should handle the unroutable', function(done){
var complete = 0;
if (!semver.gte(zmq.version, '3.2.0')) {
done();
return console.warn('Test requires libzmq >= 3.2.0');
}
if (semver.eq(zmq.version, '3.2.1')) {
done();
return console.warn('ZMQ_ROUTER_MANDATORY is broken in libzmq = 3.2.1');
}
var envelope = '12384982398293';
var errMsgs = require('os').platform() === 'win32' ? ['Unknown error'] : [];
errMsgs.push('No route to host');
errMsgs.push('Resource temporarily unavailable');
function assertRouteError(err) {
if (errMsgs.indexOf(err.message) === -1) {
throw new Error('Bad error');
}
}
// should emit an error event on unroutable msgs if mandatory = 1 and error handler is set
(function(){
var sock = zmq.socket('router');
sock.on('error', function (err) {
sock.close();
assertRouteError(err);
if (++complete === 2) done();
});
sock.setsockopt(zmq.ZMQ_ROUTER_MANDATORY, 1);
sock.send([envelope, '']);
})();
// should throw an error on unroutable msgs if mandatory = 1 and no error handler is set
(function(){
var sock = zmq.socket('router');
sock.setsockopt(zmq.ZMQ_ROUTER_MANDATORY, 1);
try {
sock.send([envelope, '']);
} catch (err) {
assertRouteError(err);
}
try {
sock.send([envelope, '']);
} catch (err) {
assertRouteError(err);
}
try {
sock.send([envelope, '']);
} catch (err) {
assertRouteError(err);
}
sock.close();
})();
// should silently ignore unroutable msgs if mandatory = 0
(function(){
var sock = zmq.socket('router');
(function(){
sock.send([envelope, '']);
sock.close();
}).should.not.throw;
})();
if (++complete === 2) done();
});