609 lines
19 KiB
JavaScript
609 lines
19 KiB
JavaScript
var crypto = require('crypto'),
|
|
Step = require('step'),
|
|
_ = require('underscore'),
|
|
dot = require('dot');
|
|
|
|
// Class handling map templates
|
|
//
|
|
// See http://github.com/CartoDB/Windshaft-cartodb/wiki/Template-maps
|
|
//
|
|
// @param redis_pool an instance of a "redis-mpool"
|
|
// See https://github.com/CartoDB/node-redis-mpool
|
|
// Needs version 0.x.x of the API.
|
|
//
|
|
// @param signed_maps an instance of a "signed_maps" class,
|
|
// See signed_maps.js
|
|
//
|
|
// @param opts TemplateMap options. Supported elements:
|
|
// 'max_user_templates' limit on the number of per-user
|
|
//
|
|
//
|
|
function TemplateMaps(redis_pool, signed_maps, opts) {
|
|
this.redis_pool = redis_pool;
|
|
this.signed_maps = signed_maps;
|
|
this.opts = opts || {};
|
|
|
|
// Database containing templates
|
|
// TODO: allow configuring ?
|
|
// NOTE: currently it is the same as
|
|
// the one containing layergroups
|
|
this.db_signatures = 0;
|
|
|
|
//
|
|
// Map templates are owned by a user that specifies access permissions
|
|
// for their instances.
|
|
//
|
|
// We have the following datastores:
|
|
//
|
|
// 1. User templates: set of per-user map templates
|
|
// NOTE: each template would have an associated auth
|
|
// reference, see signed_maps.js
|
|
|
|
// User templates (HASH:tpl_id->tpl_val)
|
|
this.key_usr_tpl = dot.template("map_tpl|{{=it.owner}}");
|
|
|
|
// User template locks (HASH:tpl_id->ctime)
|
|
this.key_usr_tpl_lck = dot.template("map_tpl|{{=it.owner}}|locks");
|
|
|
|
this.lock_ttl = this.opts['lock_ttl'] || 5000;
|
|
}
|
|
|
|
var o = TemplateMaps.prototype;
|
|
|
|
//--------------- PRIVATE METHODS --------------------------------
|
|
|
|
o._userTemplateLimit = function() {
|
|
return this.opts['max_user_templates'] || 0;
|
|
};
|
|
|
|
o._acquireRedis = function(callback) {
|
|
this.redis_pool.acquire(this.db_signatures, callback);
|
|
};
|
|
|
|
o._releaseRedis = function(client) {
|
|
this.redis_pool.release(this.db_signatures, client);
|
|
};
|
|
|
|
/**
|
|
* Internal function to communicate with redis
|
|
*
|
|
* @param redisFunc - the redis function to execute
|
|
* @param redisArgs - the arguments for the redis function in an array
|
|
* @param callback - function to pass results too.
|
|
*/
|
|
o._redisCmd = function(redisFunc, redisArgs, callback) {
|
|
var redisClient;
|
|
var that = this;
|
|
var db = that.db_signatures;
|
|
|
|
Step(
|
|
function getRedisClient() {
|
|
that.redis_pool.acquire(db, this);
|
|
},
|
|
function executeQuery(err, data) {
|
|
if ( err ) throw err;
|
|
redisClient = data;
|
|
redisArgs.push(this);
|
|
redisClient[redisFunc.toUpperCase()].apply(redisClient, redisArgs);
|
|
},
|
|
function releaseRedisClient(err, data) {
|
|
if ( ! _.isUndefined(redisClient) ) that.redis_pool.release(db, redisClient);
|
|
callback(err, data);
|
|
}
|
|
);
|
|
};
|
|
|
|
// @param callback function(err, obtained)
|
|
o._obtainTemplateLock = function(owner, tpl_id, callback) {
|
|
var that = this,
|
|
lockKey = this.key_usr_tpl_lck({owner:owner});
|
|
Step (
|
|
function obtainLock() {
|
|
that._redisCmd('HGET', [lockKey, tpl_id], this);
|
|
},
|
|
function checkLock(err, lockTime) {
|
|
if (err) { throw err; }
|
|
|
|
var _newLockTime = Date.now();
|
|
if (!lockTime || ((_newLockTime - lockTime) > that.lock_ttl)) {
|
|
that._redisCmd('HSET', [lockKey, tpl_id, _newLockTime], this);
|
|
} else {
|
|
throw new Error("Template '" + tpl_id + "' of user '" + owner + "' is locked");
|
|
}
|
|
},
|
|
function finish(err, hsetValue) {
|
|
callback(err, !!hsetValue);
|
|
}
|
|
);
|
|
};
|
|
|
|
// @param callback function(err, deleted)
|
|
o._releaseTemplateLock = function(owner, tpl_id, callback) {
|
|
this._redisCmd('HDEL', [this.key_usr_tpl_lck({owner:owner}), tpl_id], callback);
|
|
};
|
|
|
|
var _reValidIdentifier = /^[a-zA-Z][0-9a-zA-Z_]*$/;
|
|
o._checkInvalidTemplate = function(template) {
|
|
if ( template.version != '0.0.1' ) {
|
|
return new Error("Unsupported template version " + template.version);
|
|
}
|
|
var tplname = template.name;
|
|
if ( ! tplname ) {
|
|
return new Error("Missing template name");
|
|
}
|
|
if ( ! tplname.match(_reValidIdentifier) ) {
|
|
return new Error("Invalid characters in template name '" + tplname + "'");
|
|
}
|
|
|
|
var placeholders = template.placeholders || {};
|
|
|
|
var placeholderKeys = Object.keys(placeholders);
|
|
for (var i = 0, len = placeholderKeys.length; i < len; i++) {
|
|
var placeholderKey = placeholderKeys[i];
|
|
|
|
if (!placeholderKey.match(_reValidIdentifier)) {
|
|
return new Error("Invalid characters in placeholder name '" + placeholderKey + "'");
|
|
}
|
|
if ( ! placeholders[placeholderKey].hasOwnProperty('default') ) {
|
|
return new Error("Missing default for placeholder '" + placeholderKey + "'");
|
|
}
|
|
if ( ! placeholders[placeholderKey].hasOwnProperty('type') ) {
|
|
return new Error("Missing type for placeholder '" + placeholderKey + "'");
|
|
}
|
|
}
|
|
|
|
// Check certificate validity
|
|
var cert = this.getTemplateCertificate(template);
|
|
var err = this.signed_maps.checkInvalidCertificate(cert);
|
|
if ( err ) return err;
|
|
|
|
// TODO: run more checks over template format ?
|
|
};
|
|
|
|
//--------------- PUBLIC API -------------------------------------
|
|
|
|
// Extract a signature certificate from a template
|
|
//
|
|
// The certificate will be ready to be passed to
|
|
// SignedMaps.addCertificate or SignedMaps.authorizedByCert
|
|
//
|
|
o.getTemplateCertificate = function(template) {
|
|
return {
|
|
version: '0.0.1',
|
|
template_id: template.name,
|
|
auth: template.auth
|
|
};
|
|
};
|
|
|
|
// Add a template
|
|
//
|
|
// NOTE: locks user+template_name or fails
|
|
//
|
|
// @param owner cartodb username of the template owner
|
|
//
|
|
// @param template layergroup template, see
|
|
// http://github.com/CartoDB/Windshaft-cartodb/wiki/Template-maps#template-format
|
|
//
|
|
// @param callback function(err, tpl_id)
|
|
// Return template identifier (only valid for given user)
|
|
//
|
|
o.addTemplate = function(owner, template, callback) {
|
|
var invalidError = this._checkInvalidTemplate(template);
|
|
if ( invalidError ) {
|
|
callback(invalidError);
|
|
return;
|
|
}
|
|
var tplname = template.name;
|
|
|
|
// Procedure:
|
|
//
|
|
// - Check against limit
|
|
// 0. Obtain a lock for user+template_name, fail if impossible
|
|
// 1. Check no other template exists with the same name
|
|
// 2. Install certificate extracted from template, extending
|
|
// it to contain a name to properly salt things out.
|
|
// 3. Modify the template object to reference certificate by id
|
|
// 4. Install template
|
|
// 5. Release lock
|
|
//
|
|
//
|
|
|
|
var usr_tpl_key = this.key_usr_tpl({owner:owner});
|
|
var gotLock = false;
|
|
var that = this;
|
|
var limit = that._userTemplateLimit();
|
|
Step(
|
|
function checkLimit() {
|
|
if ( ! limit ) return 0;
|
|
that._redisCmd('HLEN', [ usr_tpl_key ], this);
|
|
},
|
|
// try to obtain a lock
|
|
function obtainLock(err, len) {
|
|
if ( err ) throw err;
|
|
if ( limit && len >= limit ) {
|
|
throw new Error("User '" + owner + "' reached limit on number of templates (" + len + "/" + limit + ")");
|
|
}
|
|
that._obtainTemplateLock(owner, tplname, this);
|
|
},
|
|
function getExistingTemplate(err, locked) {
|
|
if ( err ) throw err;
|
|
if ( ! locked ) {
|
|
// Already locked
|
|
throw new Error("Template '" + tplname + "' of user '" + owner + "' is locked");
|
|
}
|
|
gotLock = true;
|
|
that._redisCmd('HEXISTS', [ usr_tpl_key, tplname ], this);
|
|
},
|
|
function installCertificate(err, exists) {
|
|
if ( err ) throw err;
|
|
if ( exists ) {
|
|
throw new Error("Template '" + tplname + "' of user '" + owner + "' already exists");
|
|
}
|
|
var cert = that.getTemplateCertificate(template);
|
|
that.signed_maps.addCertificate(owner, cert, this);
|
|
},
|
|
function installTemplate(err, crt_id) {
|
|
if ( err ) throw err;
|
|
template.auth_id = crt_id;
|
|
var tpl_val = JSON.stringify(template);
|
|
that._redisCmd('HSET', [ usr_tpl_key, tplname, tpl_val ], this);
|
|
},
|
|
function releaseLock(err, newfield) {
|
|
if ( ! err && ! newfield ) {
|
|
console.log("ERROR: addTemplate overridden existing template '"
|
|
+ tplname + "' of '" + owner
|
|
+ "' -- HSET returned " + overridden + ": someone added it without locking ?");
|
|
// TODO: how to recover this ?!
|
|
}
|
|
|
|
if ( err && ! gotLock ) throw err;
|
|
|
|
// release the lock
|
|
var next = this;
|
|
that._releaseTemplateLock(owner, tplname, function(e, d) {
|
|
if ( e ) {
|
|
console.log("Error removing lock on template '" + tplname
|
|
+ "' of user '" + owner + "': " + e);
|
|
} else if ( ! d ) {
|
|
console.log("ERROR: lock on template '" + tplname
|
|
+ "' of user '" + owner + "' externally removed during insert!");
|
|
}
|
|
next(err);
|
|
});
|
|
},
|
|
function finish(err) {
|
|
callback(err, tplname);
|
|
}
|
|
);
|
|
};
|
|
|
|
// Delete a template
|
|
//
|
|
// NOTE: locks user+template_name or fails
|
|
//
|
|
// Also deletes associated authentication certificate, which
|
|
// in turn deletes all instance signatures
|
|
//
|
|
// @param owner cartodb username of the template owner
|
|
//
|
|
// @param tpl_id template identifier as returned
|
|
// by addTemplate or listTemplates
|
|
//
|
|
// @param callback function(err)
|
|
//
|
|
o.delTemplate = function(owner, tpl_id, callback) {
|
|
var usr_tpl_key = this.key_usr_tpl({owner:owner});
|
|
var gotLock = false;
|
|
var that = this;
|
|
Step(
|
|
// try to obtain a lock
|
|
function obtainLock() {
|
|
that._obtainTemplateLock(owner, tpl_id, this);
|
|
},
|
|
function getExistingTemplate(err, locked) {
|
|
if ( err ) throw err;
|
|
if ( ! locked ) {
|
|
// Already locked
|
|
throw new Error("Template '" + tpl_id + "' of user '" + owner + "' is locked");
|
|
}
|
|
gotLock = true;
|
|
that._redisCmd('HGET', [ usr_tpl_key, tpl_id ], this);
|
|
},
|
|
function delCertificate(err, tplval) {
|
|
if ( err ) throw err;
|
|
if ( ! tplval ) {
|
|
throw new Error("Template '" + tpl_id + "' of user '" + owner + "' does not exist");
|
|
}
|
|
var tpl = JSON.parse(tplval);
|
|
if ( ! tpl.auth_id ) {
|
|
// not sure this is an error, in case we'll ever
|
|
// allow unsigned templates...
|
|
console.log("ERROR: installed template '" + tpl_id
|
|
+ "' of user '" + owner + "' has no auth_id reference: "); console.dir(tpl);
|
|
return null;
|
|
}
|
|
var next = this;
|
|
that.signed_maps.delCertificate(owner, tpl.auth_id, function(err) {
|
|
if ( err ) {
|
|
var msg = "ERROR: could not delete certificate '"
|
|
+ tpl.auth_id + "' associated with template '"
|
|
+ tpl_id + "' of user '" + owner + "': " + err;
|
|
// I'm actually not sure we want this event to be fatal
|
|
// (avoiding a deletion of the template itself)
|
|
next(new Error(msg));
|
|
} else {
|
|
next();
|
|
}
|
|
});
|
|
},
|
|
function delTemplate(err) {
|
|
if ( err ) throw err;
|
|
that._redisCmd('HDEL', [ usr_tpl_key, tpl_id ], this);
|
|
},
|
|
function releaseLock(err, deleted) {
|
|
if ( ! err && ! deleted ) {
|
|
console.log("ERROR: template '" + tpl_id
|
|
+ "' of user '" + owner + "' externally removed during delete!");
|
|
}
|
|
|
|
if ( ! gotLock ) {
|
|
if ( err ) throw err;
|
|
return null;
|
|
}
|
|
|
|
// release the lock
|
|
var next = this;
|
|
that._releaseTemplateLock(owner, tpl_id, function(e, d) {
|
|
if ( e ) {
|
|
console.log("Error removing lock on template '" + tpl_id
|
|
+ "' of user '" + owner + "': " + e);
|
|
} else if ( ! d ) {
|
|
console.log("ERROR: lock on template '" + tpl_id
|
|
+ "' of user '" + owner + "' externally removed during delete!");
|
|
}
|
|
next(err);
|
|
});
|
|
},
|
|
function finish(err) {
|
|
callback(err);
|
|
}
|
|
);
|
|
};
|
|
|
|
// Update a template
|
|
//
|
|
// NOTE: locks user+template_name or fails
|
|
//
|
|
// Also deletes and re-creates associated authentication certificate,
|
|
// which in turn deletes all instance signatures
|
|
//
|
|
// @param owner cartodb username of the template owner
|
|
//
|
|
// @param tpl_id template identifier as returned by addTemplate
|
|
//
|
|
// @param template layergroup template, see
|
|
// http://github.com/CartoDB/Windshaft-cartodb/wiki/Template-maps#template-format
|
|
//
|
|
// @param callback function(err)
|
|
//
|
|
o.updTemplate = function(owner, tpl_id, template, callback) {
|
|
|
|
var invalidError = this._checkInvalidTemplate(template);
|
|
if ( invalidError ) {
|
|
callback(invalidError);
|
|
return;
|
|
}
|
|
|
|
var tplname = template.name;
|
|
|
|
if ( tpl_id != tplname ) {
|
|
callback(new Error("Cannot update name of a map template ('" + tpl_id + "' != '" + tplname + "')"));
|
|
return;
|
|
}
|
|
|
|
var usr_tpl_key = this.key_usr_tpl({owner:owner});
|
|
var gotLock = false;
|
|
var that = this;
|
|
Step(
|
|
// try to obtain a lock
|
|
function obtainLock() {
|
|
that._obtainTemplateLock(owner, tpl_id, this);
|
|
},
|
|
function getExistingTemplate(err, locked) {
|
|
if ( err ) throw err;
|
|
if ( ! locked ) {
|
|
// Already locked
|
|
throw new Error("Template '" + tpl_id + "' of user '" + owner + "' is locked");
|
|
}
|
|
gotLock = true;
|
|
that._redisCmd('HGET', [ usr_tpl_key, tpl_id ], this);
|
|
},
|
|
function delOldCertificate(err, tplval) {
|
|
if ( err ) throw err;
|
|
if ( ! tplval ) {
|
|
throw new Error("Template '" + tpl_id + "' of user '"
|
|
+ owner +"' does not exist");
|
|
}
|
|
var tpl = JSON.parse(tplval);
|
|
if ( ! tpl.auth_id ) {
|
|
// not sure this is an error, in case we'll ever
|
|
// allow unsigned templates...
|
|
console.log("ERROR: installed template '" + tpl_id
|
|
+ "' of user '" + owner + "' has no auth_id reference: "); console.dir(tpl);
|
|
return null;
|
|
}
|
|
var next = this;
|
|
that.signed_maps.delCertificate(owner, tpl.auth_id, function(err) {
|
|
if ( err ) {
|
|
var msg = "ERROR: could not delete certificate '"
|
|
+ tpl.auth_id + "' associated with template '"
|
|
+ tpl_id + "' of user '" + owner + "': " + err;
|
|
// I'm actually not sure we want this event to be fatal
|
|
// (avoiding a deletion of the template itself)
|
|
next(new Error(msg));
|
|
} else {
|
|
next();
|
|
}
|
|
});
|
|
},
|
|
function installNewCertificate(err) {
|
|
if ( err ) throw err;
|
|
var cert = that.getTemplateCertificate(template);
|
|
that.signed_maps.addCertificate(owner, cert, this);
|
|
},
|
|
function updTemplate(err, crt_id) {
|
|
if ( err ) throw err;
|
|
template.auth_id = crt_id;
|
|
var tpl_val = JSON.stringify(template);
|
|
that._redisCmd('HSET', [ usr_tpl_key, tplname, tpl_val ], this);
|
|
},
|
|
function releaseLock(err, newfield) {
|
|
if ( ! err && newfield ) {
|
|
console.log("ERROR: template '" + tpl_id
|
|
+ "' of user '" + owner + "' externally removed during update!");
|
|
}
|
|
|
|
if ( ! gotLock ) {
|
|
if ( err ) throw err;
|
|
return null;
|
|
}
|
|
|
|
// release the lock
|
|
var next = this;
|
|
that._releaseTemplateLock(owner, tpl_id, function(e, d) {
|
|
if ( e ) {
|
|
console.log("Error removing lock on template '" + tpl_id
|
|
+ "' of user '" + owner + "': " + e);
|
|
} else if ( ! d ) {
|
|
console.log("ERROR: lock on template '" + tpl_id
|
|
+ "' of user '" + owner + "' externally removed during update!");
|
|
}
|
|
next(err);
|
|
});
|
|
},
|
|
function finish(err) {
|
|
callback(err);
|
|
}
|
|
);
|
|
};
|
|
|
|
// List user templates
|
|
//
|
|
// @param owner cartodb username of the templates owner
|
|
//
|
|
// @param callback function(err, tpl_id_list)
|
|
// Returns a list of template identifiers
|
|
//
|
|
o.listTemplates = function(owner, callback) {
|
|
this._redisCmd('HKEYS', [ this.key_usr_tpl({owner:owner}) ], callback);
|
|
};
|
|
|
|
// Get a templates
|
|
//
|
|
// @param owner cartodb username of the template owner
|
|
//
|
|
// @param tpl_id template identifier as returned
|
|
// by addTemplate or listTemplates
|
|
//
|
|
// @param callback function(err, template)
|
|
// Return full template definition
|
|
//
|
|
o.getTemplate = function(owner, tpl_id, callback) {
|
|
var that = this;
|
|
Step(
|
|
function getTemplate() {
|
|
that._redisCmd('HGET', [ that.key_usr_tpl({owner:owner}), tpl_id ], this);
|
|
},
|
|
function parseTemplate(err, tpl_val) {
|
|
if ( err ) throw err;
|
|
// Should we strip auth_id ?
|
|
return JSON.parse(tpl_val);
|
|
},
|
|
function finish(err, tpl) {
|
|
callback(err, tpl);
|
|
}
|
|
);
|
|
};
|
|
|
|
// Perform placeholder substitutions on a template
|
|
//
|
|
// @param template a template object (will not be modified)
|
|
//
|
|
// @param params an object containing named subsitution parameters
|
|
// Only the ones found in the template's placeholders object
|
|
// will be used, with missing ones taking default values.
|
|
//
|
|
// @returns a layergroup configuration
|
|
//
|
|
// @throws Error on malformed template or parameter
|
|
//
|
|
var _reNumber = /^([-+]?[\d\.]?\d+([eE][+-]?\d+)?)$/,
|
|
_reCSSColorName = /^[a-zA-Z]+$/,
|
|
_reCSSColorVal = /^#[0-9a-fA-F]{3,6}$/;
|
|
|
|
_replaceVars = function(str, params) {
|
|
//return _.template(str, params); // lazy way, possibly dangerous
|
|
// Construct regular expressions for each param
|
|
Object.keys(params).forEach(function(k) {
|
|
str = str.replace(new RegExp("<%=\\s*" + k + "\\s*%>", "g"), params[k]);
|
|
});
|
|
return str;
|
|
};
|
|
o.instance = function(template, params) {
|
|
var all_params = {};
|
|
var phold = template.placeholders || {};
|
|
Object.keys(phold).forEach(function(k) {
|
|
var val = params.hasOwnProperty(k) ? params[k] : phold[k].default;
|
|
var type = phold[k].type;
|
|
// properly escape
|
|
if ( type === 'sql_literal' ) {
|
|
// duplicate any single-quote
|
|
val = val.replace(/'/g, "''");
|
|
}
|
|
else if ( type === 'sql_ident' ) {
|
|
// duplicate any double-quote
|
|
val = val.replace(/"/g, '""');
|
|
}
|
|
else if ( type === 'number' ) {
|
|
// check it's a number
|
|
if ( typeof(val) !== 'number' && ! val.match(_reNumber) ) {
|
|
throw new Error("Invalid number value for template parameter '"
|
|
+ k + "': " + val);
|
|
}
|
|
}
|
|
else if ( type === 'css_color' ) {
|
|
// check it only contains letters or
|
|
// starts with # and only contains hexdigits
|
|
if ( ! val.match(_reCSSColorName) && ! val.match(_reCSSColorVal) ) {
|
|
throw new Error("Invalid css_color value for template parameter '"
|
|
+ k + "': " + val);
|
|
}
|
|
}
|
|
else {
|
|
// NOTE: should be checked at template create/update time
|
|
throw new Error("Invalid placeholder type '" + type + "'");
|
|
}
|
|
all_params[k] = val;
|
|
});
|
|
|
|
// NOTE: we're deep-cloning the layergroup here
|
|
var layergroup = JSON.parse(JSON.stringify(template.layergroup));
|
|
for (var i=0; i<layergroup.layers.length; ++i) {
|
|
var lyropt = layergroup.layers[i].options;
|
|
if ( lyropt.cartocss ) lyropt.cartocss = _replaceVars(lyropt.cartocss, all_params);
|
|
if ( lyropt.sql) lyropt.sql = _replaceVars(lyropt.sql, all_params);
|
|
// Anything else ?
|
|
}
|
|
return layergroup;
|
|
};
|
|
|
|
// Return a fingerPrint of the object
|
|
o.fingerPrint = function(template) {
|
|
return crypto.createHash('md5')
|
|
.update(JSON.stringify(template))
|
|
.digest('hex')
|
|
;
|
|
};
|
|
|
|
module.exports = TemplateMaps;
|