Release 2.26.2

Upgrade windshaft to 1.13.1

.gitignore

@@ -5,3 +5,7 @@ config/environments/*.js
 tools/munin/windshaft.conf
 logs/
 pids/
+redis.pid
+test.log
+npm-debug.log
+coverage/

.jshintignore

@@ -0,0 +1,4 @@
+test/results/
+test/monkey/
+test/benchmark.js
+test/support/

.jshintrc

@@ -0,0 +1,94 @@
+{
+//    // JSHint Default Configuration File (as on JSHint website)
+//    // See http://jshint.com/docs/ for more details
+//
+//    "maxerr"        : 50,       // {int} Maximum error before stopping
+//
+//    // Enforcing
+//    "bitwise"       : true,     // true: Prohibit bitwise operators (&, |, ^, etc.)
+//    "camelcase"     : false,    // true: Identifiers must be in camelCase
+    "curly"         : true,     // true: Require {} for every new block or scope
+    "eqeqeq"        : true,     // true: Require triple equals (===) for comparison
+    "forin"         : true,     // true: Require filtering for..in loops with obj.hasOwnProperty()
+    "freeze"        : true,     // true: prohibits overwriting prototypes of native objects such as Array, Date etc.
+    "immed"         : true,    // true: Require immediate invocations to be wrapped in parens e.g. `(function () { } ());`
+//    "indent"        : 4,        // {int} Number of spaces to use for indentation
+//    "latedef"       : false,    // true: Require variables/functions to be defined before being used
+    "newcap"        : true,    // true: Require capitalization of all constructor functions e.g. `new F()`
+    "noarg"         : true,     // true: Prohibit use of `arguments.caller` and `arguments.callee`
+//    "noempty"       : true,     // true: Prohibit use of empty blocks
+    "nonbsp"        : true,     // true: Prohibit "non-breaking whitespace" characters.
+    "nonew"         : true,    // true: Prohibit use of constructors for side-effects (without assignment)
+//    "plusplus"      : false,    // true: Prohibit use of `++` & `--`
+//    "quotmark"      : false,    // Quotation mark consistency:
+//    //   false    : do nothing (default)
+//    //   true     : ensure whatever is used is consistent
+//    //   "single" : require single quotes
+//    //   "double" : require double quotes
+    "undef"         : true,     // true: Require all non-global variables to be declared (prevents global leaks)
+    "unused"        : true,     // true: Require all defined variables be used
+//    "strict"        : true,     // true: Requires all functions run in ES5 Strict Mode
+//    "maxparams"     : false,    // {int} Max number of formal params allowed per function
+//    "maxdepth"      : false,    // {int} Max depth of nested blocks (within functions)
+//    "maxstatements" : false,    // {int} Max number statements per function
+    "maxcomplexity" : 6,    // {int} Max cyclomatic complexity per function
+    "maxlen"        : 120,    // {int} Max number of characters per line
+//
+//    // Relaxing
+//    "asi"           : false,     // true: Tolerate Automatic Semicolon Insertion (no semicolons)
+//    "boss"          : false,     // true: Tolerate assignments where comparisons would be expected
+    "debug"         : false,     // true: Allow debugger statements e.g. browser breakpoints.
+//    "eqnull"        : false,     // true: Tolerate use of `== null`
+//    "es5"           : false,     // true: Allow ES5 syntax (ex: getters and setters)
+//    "esnext"        : false,     // true: Allow ES.next (ES6) syntax (ex: `const`)
+//    "moz"           : false,     // true: Allow Mozilla specific syntax (extends and overrides esnext features)
+//    // (ex: `for each`, multiple try/catch, function expression…)
+//    "evil"          : false,     // true: Tolerate use of `eval` and `new Function()`
+//    "expr"          : false,     // true: Tolerate `ExpressionStatement` as Programs
+//    "funcscope"     : false,     // true: Tolerate defining variables inside control statements
+//    "globalstrict"  : false,     // true: Allow global "use strict" (also enables 'strict')
+//    "iterator"      : false,     // true: Tolerate using the `__iterator__` property
+//    "lastsemic"     : false,     // true: Tolerate omitting a semicolon for the last statement of a 1-line block
+//    "laxbreak"      : false,     // true: Tolerate possibly unsafe line breakings
+//    "laxcomma"      : false,     // true: Tolerate comma-first style coding
+//    "loopfunc"      : false,     // true: Tolerate functions being defined in loops
+//    "multistr"      : false,     // true: Tolerate multi-line strings
+//    "noyield"       : false,     // true: Tolerate generator functions with no yield statement in them.
+//    "notypeof"      : false,     // true: Tolerate invalid typeof operator values
+//    "proto"         : false,     // true: Tolerate using the `__proto__` property
+//    "scripturl"     : false,     // true: Tolerate script-targeted URLs
+//    "shadow"        : false,     // true: Allows re-define variables later in code e.g. `var x=1; x=2;`
+//    "sub"           : false,     // true: Tolerate using `[]` notation when it can still be expressed in dot notation
+//    "supernew"      : false,     // true: Tolerate `new function () { ... };` and `new Object;`
+//    "validthis"     : false,     // true: Tolerate using this in a non-constructor function
+//
+//    // Environments
+//    "browser"       : true,     // Web Browser (window, document, etc)
+//    "browserify"    : false,    // Browserify (node.js code in the browser)
+//    "couch"         : false,    // CouchDB
+//    "devel"         : true,     // Development/debugging (alert, confirm, etc)
+//    "dojo"          : false,    // Dojo Toolkit
+//    "jasmine"       : false,    // Jasmine
+//    "jquery"        : false,    // jQuery
+//    "mocha"         : true,     // Mocha
+//    "mootools"      : false,    // MooTools
+    "node"          : true,    // Node.js
+//    "nonstandard"   : false,    // Widely adopted globals (escape, unescape, etc)
+//    "prototypejs"   : false,    // Prototype and Scriptaculous
+//    "qunit"         : false,    // QUnit
+//    "rhino"         : false,    // Rhino
+//    "shelljs"       : false,    // ShellJS
+//    "worker"        : false,    // Web Workers
+//    "wsh"           : false,    // Windows Scripting Host
+//    "yui"           : false,    // Yahoo User Interface
+
+    // Custom Globals
+    "globals"       : { // additional predefined global variables
+        "describe": true,
+        "before": true,
+        "after": true,
+        "beforeEach": true,
+        "afterEach": true,
+        "it": true
+    }
+}

.travis.yml

@@ -1,16 +1,26 @@
+sudo: false
+
+addons:
+  postgresql: "9.4"
+  apt:
+    packages:
+    - postgresql-plpython-9.4
+    - pkg-config
+    - libcairo2-dev
+    - libjpeg8-dev
+    - libgif-dev
+
 before_install:
-  - sudo apt-add-repository --yes ppa:mapnik/v2.1.0
-  - sudo apt-get update -q
-  - sudo apt-get install -q libmapnik-dev
+  - npm install -g npm@2
   - createdb template_postgis
   - psql -c "CREATE EXTENSION postgis" template_postgis
 
 env:
-  - NPROCS=1 JOBS=1
+  - NPROCS=1 JOBS=1 PGUSER=postgres
 
 language: node_js
 node_js:
-  - "0.8"
+  - "0.10"
 
 notifications:
   irc:

CONTRIBUTING.md

@@ -0,0 +1,11 @@
+Contributing
+---
+
+The issue tracker is at [github.com/CartoDB/Windshaft-cartodb](https://github.com/CartoDB/Windshaft-cartodb).
+
+We love pull requests from everyone, see [Contributing to Open Source on GitHub](https://guides.github.com/activities/contributing-to-open-source/#contributing).
+
+
+## Submitting Contributions
+
+* You will need to sign a Contributor License Agreement (CLA) before making a submission. [Learn more here](https://cartodb.com/contributing).

HOWTO_RELEASE

@@ -1,11 +1,19 @@
-1. Ensure proper version in package.json 
-2. Ensure NEWS section exists for the new version, review it, add release date
-3. Drop npm-shrinkwrap.json
-4. Run npm install
-5. Test (make check or npm test), fix if broken before proceeding
-6. Run npm shrinkwrap
-7. Commit package.json, npm-shrinwrap.json, NEWS
-8. Tag Major.Minor.Patch
-9. Announce
-10. Stub NEWS/package for next version
+1. Test (make clean all check), fix if broken before proceeding
+2. Ensure proper version in package.json 
+3. Ensure NEWS section exists for the new version, review it, add release date
+4. Recreate npm-shrinkwrap.json with: `npm install --no-shrinkwrap && npm shrinkwrap`
+5. Commit package.json, npm-shrinwrap.json, NEWS
+6. git tag -a Major.Minor.Patch # use NEWS section as content
+7. Announce on cartodb@googlegroups.com
+8. Stub NEWS/package for next version
 
+Versions:
+
+Bugfix releases increment Patch component of version.
+Feature releases increment Minor and set Patch to zero.
+If backward compatibility is broken, increment Major and
+set to zero Minor and Patch.
+
+Branches named 'b<Major>.<Minor>' are kept for any critical
+fix that might need to be shipped before next feature release
+is ready.

INSTALL.md

@@ -0,0 +1,53 @@
+# Installing Windshaft-CartoDB #
+
+## Requirements ##
+Make sure that you have the requirements needed. These are
+
+- Core
+  - Node.js >=0.8
+  - npm >=1.2.1 <2.0.0
+  - PostgreSQL >8.3.x, PostGIS >1.5.x
+  - Redis >2.4.0 (http://www.redis.io)
+  - Mapnik 2.0.1, 2.0.2, 2.1.0, 2.2.0, 2.3.0. See [Installing Mapnik](https://github.com/CartoDB/Windshaft#installing-mapnik).
+  - Windshaft: check [Windshaft dependencies and installation notes](https://github.com/CartoDB/Windshaft#dependencies)
+  - libcairo2-dev, libpango1.0-dev, libjpeg8-dev and libgif-dev for server side canvas support
+
+- For cache control (optional)
+  - CartoDB 0.9.5+ (for `CDB_QueryTables`)
+  - Varnish (http://www.varnish-cache.org)
+
+On Ubuntu 14.04 the dependencies can be installed with
+
+```shell
+sudo apt-get update
+sudo apt-get install -y make g++ pkg-config git-core \
+  libgif-dev libjpeg-dev libcairo2-dev \
+  libhiredis-dev redis-server \
+  nodejs nodejs-legacy npm \
+  postgresql-9.3-postgis-2.1 postgresql-plpython-9.3 postgresql-server-dev-9.3
+```
+
+On Ubuntu 12.04 the [cartodb/cairo PPA](https://launchpad.net/~cartodb/+archive/ubuntu/cairo) may be useful.
+
+## PostGIS setup ##
+
+A `template_postgis` database is expected. One can be set up with
+
+```shell
+createdb --owner postgres --template template0 template_postgis
+psql -d template_postgis -c 'CREATE EXTENSION postgis;'
+```
+
+## Build/install ##
+
+To fetch and build all node-based dependencies, run:
+
+```
+npm install
+```
+
+Note that the ```npm install``` step will populate the node_modules/
+directory with modules, some of which being compiled on demand. If you
+happen to have startup errors you may need to force rebuilding those
+modules. At any time just wipe out the node_modules/ directory and run
+```npm install``` again.

LICENCE

@@ -1,27 +0,0 @@
-Copyright (c) 2011, Vizzuality 
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-3. All advertising materials mentioning features or use of this software
-   must display the following acknowledgement:
-   This product includes software developed by Vizzuality.
-4. Neither the name of Vizzuality nor the
-   names of its contributors may be used to endorse or promote products
-   derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS "AS IS" AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2015, CartoDB
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this 
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, 
+this list of conditions and the following disclaimer in the documentation 
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors 
+may be used to endorse or promote products derived from this software without 
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Makefile

@@ -1,7 +1,10 @@
-srcdir=$(shell pwd)
+SHELL=/bin/bash
+
+pre-install:
+	@$(SHELL) ./scripts/check-node-canvas.sh
 
 all:
-	npm install
+	@$(SHELL) ./scripts/install.sh
 
 clean:
 	rm -rf node_modules/*
@@ -15,21 +18,36 @@ config.status--test:
 config/environments/test.js: config.status--test
 	./config.status--test 
 
-check-local: config/environments/test.js
-	./run_tests.sh ${RUNTESTFLAGS} \
-    test/unit/cartodb/*.js \
-    test/acceptance/*.js 
+TEST_SUITE := $(shell find test/{acceptance,integration,unit} -name "*.js")
+TEST_SUITE_UNIT := $(shell find test/unit -name "*.js")
+TEST_SUITE_INTEGRATION := $(shell find test/integration -name "*.js")
+TEST_SUITE_ACCEPTANCE := $(shell find test/acceptance -name "*.js")
 
-check-submodules:
-	PATH="$$PATH:$(srcdir)/node_modules/.bin/"; \
-	for sub in windshaft grainstore node-varnish mapnik; do \
-	  if test -e node_modules/$${sub}; then \
-	      echo "Testing submodule $${sub}"; \
-	      make -C node_modules/$${sub} check || exit 1; \
-	  fi; \
-	done
+test: config/environments/test.js
+	@echo "***tests***"
+	@$(SHELL) ./run_tests.sh ${RUNTESTFLAGS} $(TEST_SUITE)
 
-check-full: check-local check-submodules
+test-unit: config/environments/test.js
+	@echo "***tests***"
+	@$(SHELL) ./run_tests.sh ${RUNTESTFLAGS} $(TEST_SUITE_UNIT)
 
-check: check-local
+test-integration: config/environments/test.js
+	@echo "***tests***"
+	@$(SHELL) ./run_tests.sh ${RUNTESTFLAGS} $(TEST_SUITE_INTEGRATION)
 
+test-acceptance: config/environments/test.js
+	@echo "***tests***"
+	@$(SHELL) ./run_tests.sh ${RUNTESTFLAGS} $(TEST_SUITE_ACCEPTANCE)
+
+jshint:
+	@echo "***jshint***"
+	@./node_modules/.bin/jshint lib/ test/ app.js
+
+test-all: jshint test
+
+coverage:
+	@RUNTESTFLAGS=--with-coverage make test
+
+check: test
+
+.PHONY: pre-install test jshint coverage

README.md

@@ -1,39 +1,21 @@
 Windshaft-CartoDB
 ==================
 
-[![Build Status](http://travis-ci.org/CartoDB/Windshaft-cartodb.png)]
-(http://travis-ci.org/CartoDB/Windshaft-cartodb)
+[![Build Status](https://travis-ci.org/CartoDB/Windshaft-cartodb.svg?branch=master)](https://travis-ci.org/CartoDB/Windshaft-cartodb)
 
-This is the CartoDB map tiler. It extends Windshaft with some extra
-functionality and custom filters for authentication
+This is the [CartoDB Maps API](http://docs.cartodb.com/cartodb-platform/maps-api.html) tiler. It extends
+[Windshaft](https://github.com/CartoDB/Windshaft) with some extra functionality and custom filters for authentication.
 
 * reads dbname from subdomain and cartodb redis for pretty tile urls
-* configures windshaft to publish ``cartodb_id`` as the interactivity layer
+* configures windshaft to publish `cartodb_id` as the interactivity layer
 * gets the default geometry type from the cartodb redis store
 * allows tiles to be styled individually
 * provides a link to varnish high speed cache
-* provides a ``infowindow`` endpoint for windshaft (DEPRECATED)
-* provides a ``map_metadata`` endpoint for windshaft (DEPRECATED)
-* provides signed template maps API
-  (http://github.com/CartoDB/Windshaft-cartodb/wiki/Template-maps)
+* provides a [template maps API](https://github.com/CartoDB/Windshaft-cartodb/blob/master/docs/Template-maps.md)
 
-Requirements
-------------
-
- [core]
- - node-0.8.x+
- - PostgreSQL-8.3+
- - PostGIS-1.5.0+
- - Redis 2.4.0+ (http://www.redis.io)
- - Mapnik 2.0 or 2.1 
-
- [for cache control]
- - CartoDB-SQL-API 1.0.0+
- - CartoDB 0.9.5+ (for ``CDB_QueryTables``)
- - Varnish (http://www.varnish-cache.org)
-
- [for running the testsuite]
- - Imagemagick (http://www.imagemagick.org)
+Install
+-------
+See [INSTALL.md](INSTALL.md) for detailed installation instructions.
 
 Configure
 ---------
@@ -44,23 +26,15 @@ see ```./configure --help``` to see available options.
 
 Look at lib/cartodb/server_options.js for more on config
 
-Build/install
--------------
+Upgrading
+---------
 
-To fetch and build all node-based dependencies, run:
+Checkout your commit/branch. If you need to reinstall dependencies (you can check [NEWS](NEWS.md)) do the following:
 
 ```
-git clone
-npm install
+rm -rf node_modules; npm install
 ```
 
-Note that the ```npm install``` step will populate the node_modules/
-directory with modules, some of which being compiled on demand. If you
-happen to have startup errors you may need to force rebuilding those
-modules. At any time just wipe out the node_modules/ directory and run
-```npm install``` again.
-
-
 Run
 ---
 
@@ -75,59 +49,34 @@ there may be out-of-sync records in there.
 Take a look: http://redis.io/commands
 
 
-URLs
-----
+Documentation
+-------------
 
-**TILES**
-
-[GET] subdomain.cartodb.com/tiles/:table_name/:z/:x/:y.[png|png8|grid.json]
-
-Args:
-
-* sql - plain SQL arguments
-* interactivity - specify the column to use in UTFGrid
-* cache_buster - Specify an identifier for the internal tile cache.
-                 Requesting tiles with the same cache_buster value may
-                 result in being served a cached version of the tile
-                 (even when requesting a tile for the first time, as tiles
-                 can be prepared in advance)
-* cache_policy - Set to "persist" to have the server send an Cache-Control
-                 header requesting caching devices to keep the response
-                 cached as much as possible. This is best used with a
-                 timestamp value in cache_buster for manual control of
-                 updates.
-* geom_type - override the cartodb default
-* style - override the default map style with Carto
+The [docs directory](https://github.com/CartoDB/Windshaft-cartodb/tree/master/docs) contains different documentation
+resources, from higher level to more detailed ones:
+The [Maps API](https://github.com/CartoDB/Windshaft-cartodb/blob/master/docs/Map-API.md) defined the endpoints and their
+expected parameters and outputs.
 
 
-**STYLE**
+Examples
+--------
 
-[GET/POST] subdomain.cartodb.com/tiles/:table_name/style
+[CartoDB's Map Gallery](http://cartodb.com/gallery/) showcases several examples of visualisations built on top of this.
 
-Args:
+Contributing
+---
 
-* style - the style in CartoCSS you want to set
-* style_version - the version of the style for POST
-* style_convert - request conversion to target version (both POST and GET)
+See [CONTRIBUTING.md](CONTRIBUTING.md).
 
+### Developing with a custom windshaft version
 
-**INFOWINDOW**
+If you plan or want to use a custom / not released yet version of windshaft (or any other dependency) the best option is
+to use `npm link`. You can read more about it at [npm-link: Symlink a package folder](https://docs.npmjs.com/cli/link).
 
-[GET] subdomain.cartodb.com/tiles/:table_name/infowindow
+**Quick start**:
 
-Args:
-
-* infowindow - returns contents of infowindow from CartoDB.
-
-
-**MAP METADATA**
-
-[GET] subdomain.cartodb.com/tiles/:table_name/map_metadata
-
-Args:
-
-* infowindow - returns contents of infowindow from CartoDB.
-
-
-All GET requests are wrappable with JSONP using callback argument,
-including the UTFGrid map tile call.
+```shell
+~/windshaft-directory $ npm install
+~/windshaft-directory $ npm link
+~/windshaft-cartodb-directory $ npm link windshaft
+```

app.js

@@ -1,54 +1,120 @@
-/*
- * Windshaft-CartoDB
- * ===============
- *
- * ./app.js [environment]
- *
- * environments: [development, production]
- */
+var http = require('http');
+var https = require('https');
+var path = require('path');
+var fs = require('fs');
 
+var _ = require('underscore');
+
+var ENVIRONMENT;
+if ( process.argv[2] ) {
+    ENVIRONMENT = process.argv[2];
+} else if ( process.env.NODE_ENV ) {
+    ENVIRONMENT = process.env.NODE_ENV;
+} else {
+    ENVIRONMENT = 'development';
+}
+
+var availableEnvironments = {
+    production: true,
+    staging: true,
+    development: true
+};
 
 // sanity check
-var ENV = process.argv[2]
-if (ENV != 'development' && ENV != 'production' && ENV != 'staging' ){
-    console.error("\nnode app.js [environment]");
-    console.error("environments: [development, production, staging]\n");
+if (!availableEnvironments[ENVIRONMENT]){
+    console.error('node app.js [environment]');
+    console.error('environments: %s', Object.keys(availableEnvironments).join(', '));
     process.exit(1);
 }
 
-var _ = require('underscore')
-    , Step       = require('step')
-    ;
+process.env.NODE_ENV = ENVIRONMENT;
+
 // set environment specific variables
-global.settings     = require(__dirname + '/config/settings');
-global.environment  = require(__dirname + '/config/environments/' + ENV);
-_.extend(global.settings, global.environment);
+global.environment = require('./config/environments/' + ENVIRONMENT);
+
+global.log4js = require('log4js');
+var log4js_config = {
+  appenders: [],
+  replaceConsole: true
+};
+
+if (global.environment.uv_threadpool_size) {
+    process.env.UV_THREADPOOL_SIZE = global.environment.uv_threadpool_size;
+}
+
+// set global HTTP and HTTPS agent default configurations
+// ref https://nodejs.org/api/http.html#http_new_agent_options
+var agentOptions = _.defaults(global.environment.httpAgent || {}, {
+    keepAlive: false,
+    keepAliveMsecs: 1000,
+    maxSockets: Infinity,
+    maxFreeSockets: 256
+});
+http.globalAgent = new http.Agent(agentOptions);
+https.globalAgent = new https.Agent(agentOptions);
+
+if ( global.environment.log_filename ) {
+  var logdir = path.dirname(global.environment.log_filename);
+  // See cwd inlog4js.configure call below
+  logdir = path.resolve(__dirname, logdir);
+  if ( ! fs.existsSync(logdir) ) {
+    console.error("Log filename directory does not exist: " + logdir);
+    process.exit(1);
+  }
+  console.log("Logs will be written to " + global.environment.log_filename);
+  log4js_config.appenders.push(
+    { type: "file", filename: global.environment.log_filename }
+  );
+} else {
+  log4js_config.appenders.push(
+    { type: "console", layout: { type:'basic' } }
+  );
+}
+
+global.log4js.configure(log4js_config, { cwd: __dirname });
+global.logger = global.log4js.getLogger();
+
+global.environment.api_hostname = require('os').hostname().split('.')[0];
 
 // Include cartodb_windshaft only _after_ the "global" variable is set
 // See https://github.com/Vizzuality/Windshaft-cartodb/issues/28
-var CartodbWindshaft = require('./lib/cartodb/cartodb_windshaft');
+var cartodbWindshaft = require('./lib/cartodb/server');
 var serverOptions = require('./lib/cartodb/server_options');
 
-ws = CartodbWindshaft(serverOptions);
+var server = cartodbWindshaft(serverOptions);
 
 // Maximum number of connections for one process
 // 128 is a good number if you have up to 1024 filedescriptors
 // 4 is good if you have max 32 filedescriptors
 // 1 is good if you have max 16 filedescriptors
-ws.maxConnections = global.environment.maxConnections || 128;
+var backlog = global.environment.maxConnections || 128;
 
-ws.listen(global.environment.port, global.environment.host);
+var listener = server.listen(serverOptions.bind.port, serverOptions.bind.host, backlog);
 
-ws.on('listening', function() {
-  console.log("Windshaft tileserver started on " + global.environment.host + ':' + global.environment.port);
+var version = require("./package").version;
+
+listener.on('listening', function() {
+    console.log(
+        "Windshaft tileserver %s started on %s:%s PID=%d (%s)",
+        version, serverOptions.bind.host, serverOptions.bind.port, process.pid, ENVIRONMENT
+    );
 });
 
-// DEPRECATED, use SIGUSR2
-process.on('SIGUSR1', function() {
-  console.log('WARNING: handling of SIGUSR1 by Windshaft-CartoDB is deprecated, please send SIGUSR2 instead');
-  ws.dumpCacheStats();
+setInterval(function() {
+    var memoryUsage = process.memoryUsage();
+    Object.keys(memoryUsage).forEach(function(k) {
+        global.statsClient.gauge('windshaft.memory.' + k, memoryUsage[k]);
+    });
+}, 5000);
+
+process.on('SIGHUP', function() {
+    global.log4js.clearAndShutdownAppenders(function() {
+        global.log4js.configure(log4js_config);
+        global.logger = global.log4js.getLogger();
+        console.log('Log files reloaded');
+    });
 });
 
-process.on('SIGUSR2', function() {
-  ws.dumpCacheStats();
+process.on('uncaughtException', function(err) {
+    global.logger.error('Uncaught exception: ' + err.stack);
 });

config/environments/development.js.example

@@ -2,17 +2,46 @@ var config = {
      environment: 'development'
     ,port: 8181
     ,host: '127.0.0.1'
+    // Size of the threadpool which can be used to run user code and get notified in the loop thread
+    // Its default size is 4, but it can be changed at startup time (the absolute maximum is 128).
+    // See http://docs.libuv.org/en/latest/threadpool.html
+    ,uv_threadpool_size: undefined
     // Regular expression pattern to extract username
     // from hostname. Must have a single grabbing block.
     ,user_from_host: '^(.*)\\.localhost'
+
+    // Base URLs for the APIs
+    //
+    // See http://github.com/CartoDB/Windshaft-cartodb/wiki/Unified-Map-API
+    //
+    // Base url for the Templated Maps API
+    // "/api/v1/map/named" is the new API,
+    // "/tiles/template" is for compatibility with versions up to 1.6.x
+    ,base_url_templated: '(?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template)'
+    // Base url for the Detached Maps API
+    // "maps" is the the new API,
+    // "tiles/layergroup" is for compatibility with versions up to 1.6.x
+    ,base_url_detached: '(?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)'
+
     // Maximum number of connections for one process
     // 128 is a good value with a limit of 1024 open file descriptors
     ,maxConnections:128
-    // idle socket timeout, in miliseconds 
+    // Maximum number of templates per user. Unlimited by default.
+    ,maxUserTemplates:1024
+    // Seconds since "last creation" before a detached
+    // or template instance map expires. Or: how long do you want
+    // to be able to navigate the map without a reload ?
+    // Defaults to 7200 (2 hours)
+    ,mapConfigTTL: 7200
+    // idle socket timeout, in milliseconds
     ,socket_timeout: 600000
     ,enable_cors: true
     ,cache_enabled: false
-    ,log_format: '[:date] :req[X-Real-IP] :method :req[Host]:url :status :response-time ms -> :res[Content-Type] (:res[X-Tiler-Profiler])'
+    ,log_format: ':req[X-Real-IP] :method :req[Host]:url :status :response-time ms -> :res[Content-Type] (:res[X-Tiler-Profiler])'
+    // If log_filename is given logs will be written
+    // there, in append mode. Otherwise stdout is used (default).
+    // Log file will be re-opened on receiving the HUP signal
+    ,log_filename: undefined
     // Templated database username for authorized user
     // Supported labels: 'user_id' (read from redis)
     ,postgres_auth_user: 'development_cartodb_user_<%= user_id %>'
@@ -35,14 +64,132 @@ var config = {
         */
         row_limit: 65535,
         simplify_geometries: true,
+        use_overviews: true, // use overviews to retrieve raster
+        /*
+         * Set persist_connection to false if you want
+         * database connections to be closed on renderer
+         * expiration (1 minute after last use).
+         * Setting to true (the default) would never
+         * close any connection for the server's lifetime
+         */
+        persist_connection: false,
         max_size: 500
     }
     ,mapnik_version: undefined
+    ,mapnik_tile_format: 'png8:m=h'
+    ,statsd: {
+        host: 'localhost',
+        port: 8125,
+        prefix: 'dev.',
+        cacheDns: true
+        // support all allowed node-statsd options
+    }
     ,renderer: {
       // Milliseconds since last access before renderer cache item expires
       cache_ttl: 60000,
-      metatile: 4,
-      bufferSize: 64
+      statsInterval: 5000, // milliseconds between each report to statsd about number of renderers and mapnik pool status
+      mapnik: {
+          // The size of the pool of internal mapnik backend
+          // This pool size is per mapnik renderer created in Windshaft's RendererFactory
+          // See https://github.com/CartoDB/Windshaft/blob/master/lib/windshaft/renderers/renderer_factory.js
+          // Important: check the configuration of uv_threadpool_size to use suitable value
+          poolSize: 8,
+
+          // Metatile is the number of tiles-per-side that are going
+          // to be rendered at once. If all of them will be requested
+          // we'd have saved time. If only one will be used, we'd have
+          // wasted time.
+          metatile: 2,
+
+          // tilelive-mapnik uses an internal cache to store tiles/grids
+          // generated when using metatile. This options allow to tune
+          // the behaviour for that internal cache.
+          metatileCache: {
+              // Time an object must stay in the cache until is removed
+              ttl: 0,
+              // Whether an object must be removed after the first hit
+              // Usually you want to use `true` here when ttl>0.
+              deleteOnHit: false
+          },
+
+          // Override metatile behaviour depending on the format
+          formatMetatile: {
+              png: 2,
+              'grid.json': 1
+          },
+
+          // Buffer size is the tickness in pixel of a buffer
+          // around the rendered (meta?)tile.
+          //
+          // This is important for labels and other marker that overlap tile boundaries.
+          // Setting to 128 ensures no render artifacts.
+          // 64 may have artifacts but is faster.
+          // Less important if we can turn metatiling on.
+          bufferSize: 64,
+
+          // SQL queries will be wrapped with ST_SnapToGrid
+          // Snapping all points of the  geometry to a regular grid
+          snapToGrid: false,
+
+          // SQL queries will be wrapped with ST_ClipByBox2D
+          // Returning the portion of a geometry falling within a rectangle
+          // It will only work if snapToGrid is enabled
+          clipByBox2d: false, // this requires postgis >=2.2 and geos >=3.5
+
+          limits: {
+              // Time in milliseconds a render request can take before it fails, some notes:
+              //  - 0 means no render limit
+              //  - it considers metatiling, naive implementation: (render timeout) * (number of tiles in metatile)
+              render: 0,
+              // As the render request will finish even if timed out, whether it should be placed in the internal
+              // cache or it should be fully discarded. When placed in the internal cache another attempt to retrieve
+              // the same tile will result in an immediate response, however that will use a lot of more application
+              // memory. If we want to enforce this behaviour we have to implement a cache eviction policy for the
+              // internal cache.
+              cacheOnTimeout: true
+          },
+
+          geojson: {
+                dbPoolParams: {
+                      // maximum number of resources to create at any given time
+                      size: 16,
+                      // max milliseconds a resource can go unused before it should be destroyed
+                      idleTimeout: 3000,
+                      // frequency to check for idle resources
+                      reapInterval: 1000
+                },
+
+              // SQL queries will be wrapped with ST_ClipByBox2D
+              // Returning the portion of a geometry falling within a rectangle
+              // It will only work if snapToGrid is enabled
+              clipByBox2d: false, // this requires postgis >=2.2 and geos >=3.5
+          }
+
+      },
+      http: {
+          timeout: 2000, // the timeout in ms for a http tile request
+          proxy: undefined, // the url for a proxy server
+          whitelist: [ // the whitelist of urlTemplates that can be used
+              '.*', // will enable any URL
+              'http://{s}.example.com/{z}/{x}/{y}.png'
+          ],
+          // image to use as placeholder when urlTemplate is not in the whitelist
+          // if provided the http renderer will use it instead of throw an error
+          fallbackImage: {
+              type: 'fs', // 'fs' and 'url' supported
+              src: __dirname + '/../../assets/default-placeholder.png'
+          }
+      },
+      torque: {
+          dbPoolParams: {
+              // maximum number of resources to create at any given time
+              size: 16,
+              // max milliseconds a resource can go unused before it should be destroyed
+              idleTimeout: 3000,
+              // frequency to check for idle resources
+              reapInterval: 1000
+          }
+      }
     }
     ,millstone: {
         // Needs to be writable by server user
@@ -54,29 +201,77 @@ var config = {
         // Max number of connections in each pool.
         // Users will be put on a queue when the limit is hit.
         // Set to maxConnection to have no possible queues.
-        // There are currently 3 pools involved in serving
+        // There are currently 2 pools involved in serving
         // windshaft-cartodb requests so multiply this number
-        // by 3 to know how many possible connections will be
+        // by 2 to know how many possible connections will be
         // kept open by the server. The default is 50.
         max: 50,
+        returnToHead: true, // defines the behaviour of the pool: false => queue, true => stack
         idleTimeoutMillis: 1, // idle time before dropping connection
-        reapIntervalMillis: 1 // time between cleanups
+        reapIntervalMillis: 1, // time between cleanups
+        slowQueries: {
+            log: true,
+            elapsedThreshold: 200
+        },
+        slowPool: {
+            log: true, // whether a slow acquire must be logged or not
+            elapsedThreshold: 25 // the threshold to determine an slow acquire must be reported or not
+        },
+        emitter: {
+            statusInterval: 5000 // time, in ms, between each status report is emitted from the pool, status is sent to statsd
+        },
+        unwatchOnRelease: false, // Send unwatch on release, see http://github.com/CartoDB/Windshaft-cartodb/issues/161
+        noReadyCheck: true // Check `no_ready_check` at https://github.com/mranney/node_redis/tree/v0.12.1#overloading
     }
-    ,sqlapi: {
-        protocol: 'http',
-        domain: 'localhost.lan',
-        port: 8080,
-        version: 'v1'
+    // For more details about this options check https://nodejs.org/api/http.html#http_new_agent_options
+    ,httpAgent: {
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 25,
+        maxFreeSockets: 256
     }
     ,varnish: {
         host: 'localhost',
-        port: 6082,
-        ttl: 86400
+        port: 6082, // the por for the telnet interface where varnish is listening to
+        http_port: 6081, // the port for the HTTP interface where varnish is listening to
+        purge_enabled: false, // whether the purge/invalidation mechanism is enabled in varnish or not
+        secret: 'xxx',
+        ttl: 86400,
+        layergroupTtl: 86400 // the max-age for cache-control header in layergroup responses
+    }
+    // this [OPTIONAL] configuration enables invalidating by surrogate key in fastly
+    ,fastly: {
+        // whether the invalidation is enabled or not
+        enabled: false,
+        // the fastly api key
+        apiKey: 'wadus_api_key',
+        // the service that will get surrogate key invalidation
+        serviceId: 'wadus_service_id'
     }
     // If useProfiler is true every response will be served with an
-    // X-Tiler-Profile header containing elapsed timing for various 
+    // X-Tiler-Profile header containing elapsed timing for various
     // steps taken for producing the response.
     ,useProfiler:true
+    // Settings for the health check available at /health
+    ,health: {
+      enabled: false,
+      username: 'localhost',
+      z: 0,
+      x: 0,
+      y: 0
+    }
+    ,disabled_file: 'pids/disabled'
+
+    // Use this as a feature flags enabling/disabling mechanism
+    ,enabledFeatures: {
+        // whether it should intercept tile render errors an act based on them, enabled by default.
+        onTileErrorStrategy: true,
+        // whether the affected tables for a given SQL must query directly postgresql or use the SQL API
+        cdbQueryTablesFromPostgres: true,
+        // whether in mapconfig is available stats & metadata for each layer
+        layerMetadata: true
+
+    }
 };
 
 module.exports = config;

config/environments/production.js.example

@@ -2,17 +2,46 @@ var config = {
     environment: 'production'
     ,port: 8181
     ,host: '127.0.0.1'
+    // Size of the threadpool which can be used to run user code and get notified in the loop thread
+    // Its default size is 4, but it can be changed at startup time (the absolute maximum is 128).
+    // See http://docs.libuv.org/en/latest/threadpool.html
+    ,uv_threadpool_size: undefined
     // Regular expression pattern to extract username
     // from hostname. Must have a single grabbing block.
     ,user_from_host: '^(.*)\\.cartodb\\.com$'
+
+    // Base URLs for the APIs
+    //
+    // See http://github.com/CartoDB/Windshaft-cartodb/wiki/Unified-Map-API
+    //
+    // Base url for the Templated Maps API
+    // "/api/v1/map/named" is the new API,
+    // "/tiles/template" is for compatibility with versions up to 1.6.x
+    ,base_url_templated: '(?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template)'
+    // Base url for the Detached Maps API
+    // "maps" is the the new API,
+    // "tiles/layergroup" is for compatibility with versions up to 1.6.x
+    ,base_url_detached: '(?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)'
+
     // Maximum number of connections for one process
     // 128 is a good value with a limit of 1024 open file descriptors
     ,maxConnections:128
-    // idle socket timeout, in miliseconds
-    ,socket_timeout: 600000 
+    // Maximum number of templates per user. Unlimited by default.
+    ,maxUserTemplates:1024
+    // Seconds since "last creation" before a detached
+    // or template instance map expires. Or: how long do you want
+    // to be able to navigate the map without a reload ?
+    // Defaults to 7200 (2 hours)
+    ,mapConfigTTL: 7200
+    // idle socket timeout, in milliseconds
+    ,socket_timeout: 600000
     ,enable_cors: true
     ,cache_enabled: true
-    ,log_format: '[:date] :req[X-Real-IP] :method :req[Host]:url :status :response-time ms -> :res[Content-Type] (:res[X-Tiler-Profiler])'
+    ,log_format: ':req[X-Real-IP] :method :req[Host]:url :status :response-time ms -> :res[Content-Type] (:res[X-Tiler-Profiler])'
+    // If log_filename is given logs will be written
+    // there, in append mode. Otherwise stdout is used (default).
+    // Log file will be re-opened on receiving the HUP signal
+    ,log_filename: 'logs/node-windshaft.log'
     // Templated database username for authorized user
     // Supported labels: 'user_id' (read from redis)
     ,postgres_auth_user: 'cartodb_user_<%= user_id %>'
@@ -28,15 +57,133 @@ var config = {
         port: 6432,
         extent: "-20037508.3,-20037508.3,20037508.3,20037508.3",
         row_limit: 65535,
+        /*
+         * Set persist_connection to false if you want
+         * database connections to be closed on renderer
+         * expiration (1 minute after last use).
+         * Setting to true (the default) would never
+         * close any connection for the server's lifetime
+         */
+        persist_connection: false,
         simplify_geometries: true,
+        use_overviews: true, // use overviews to retrieve raster
         max_size: 500
     }
     ,mapnik_version: undefined
+    ,mapnik_tile_format: 'png8:m=h'
+    ,statsd: {
+        host: 'localhost',
+        port: 8125,
+        prefix: ':host.', // could be hostname, better not containing dots
+        cacheDns: true
+        // support all allowed node-statsd options
+    }
     ,renderer: {
       // Milliseconds since last access before renderer cache item expires
       cache_ttl: 60000,
-      metatile: 4,
-      bufferSize: 64
+      statsInterval: 5000, // milliseconds between each report to statsd about number of renderers and mapnik pool status
+      mapnik: {
+          // The size of the pool of internal mapnik backend
+          // This pool size is per mapnik renderer created in Windshaft's RendererFactory
+          // See https://github.com/CartoDB/Windshaft/blob/master/lib/windshaft/renderers/renderer_factory.js
+          // Important: check the configuration of uv_threadpool_size to use suitable value
+          poolSize: 8,
+
+          // Metatile is the number of tiles-per-side that are going
+          // to be rendered at once. If all of them will be requested
+          // we'd have saved time. If only one will be used, we'd have
+          // wasted time.
+          metatile: 2,
+
+          // tilelive-mapnik uses an internal cache to store tiles/grids
+          // generated when using metatile. This options allow to tune
+          // the behaviour for that internal cache.
+          metatileCache: {
+              // Time an object must stay in the cache until is removed
+              ttl: 0,
+              // Whether an object must be removed after the first hit
+              // Usually you want to use `true` here when ttl>0.
+              deleteOnHit: false
+          },
+
+          // Override metatile behaviour depending on the format
+          formatMetatile: {
+              png: 2,
+              'grid.json': 1
+          },
+
+          // Buffer size is the tickness in pixel of a buffer
+          // around the rendered (meta?)tile.
+          //
+          // This is important for labels and other marker that overlap tile boundaries.
+          // Setting to 128 ensures no render artifacts.
+          // 64 may have artifacts but is faster.
+          // Less important if we can turn metatiling on.
+          bufferSize: 64,
+
+          // SQL queries will be wrapped with ST_SnapToGrid
+          // Snapping all points of the  geometry to a regular grid
+          snapToGrid: false,
+
+          // SQL queries will be wrapped with ST_ClipByBox2D
+          // Returning the portion of a geometry falling within a rectangle
+          // It will only work if snapToGrid is enabled
+          clipByBox2d: false, // this requires postgis >=2.2 and geos >=3.5
+
+          limits: {
+              // Time in milliseconds a render request can take before it fails, some notes:
+              //  - 0 means no render limit
+              //  - it considers metatiling, naive implementation: (render timeout) * (number of tiles in metatile)
+              render: 0,
+              // As the render request will finish even if timed out, whether it should be placed in the internal
+              // cache or it should be fully discarded. When placed in the internal cache another attempt to retrieve
+              // the same tile will result in an immediate response, however that will use a lot of more application
+              // memory. If we want to enforce this behaviour we have to implement a cache eviction policy for the
+              // internal cache.
+              cacheOnTimeout: true
+          },
+
+          geojson: {
+                dbPoolParams: {
+                      // maximum number of resources to create at any given time
+                      size: 16,
+                      // max milliseconds a resource can go unused before it should be destroyed
+                      idleTimeout: 3000,
+                      // frequency to check for idle resources
+                      reapInterval: 1000
+                },
+
+              // SQL queries will be wrapped with ST_ClipByBox2D
+              // Returning the portion of a geometry falling within a rectangle
+              // It will only work if snapToGrid is enabled
+              clipByBox2d: false, // this requires postgis >=2.2 and geos >=3.5
+          }
+
+      },
+      http: {
+          timeout: 2000, // the timeout in ms for a http tile request
+          proxy: undefined, // the url for a proxy server
+          whitelist: [ // the whitelist of urlTemplates that can be used
+              '.*', // will enable any URL
+              'http://{s}.example.com/{z}/{x}/{y}.png'
+          ],
+          // image to use as placeholder when urlTemplate is not in the whitelist
+          // if provided the http renderer will use it instead of throw an error
+          fallbackImage: {
+              type: 'fs', // 'fs' and 'url' supported
+              src: __dirname + '/../../assets/default-placeholder.png'
+          }
+      },
+      torque: {
+          dbPoolParams: {
+              // maximum number of resources to create at any given time
+              size: 16,
+              // max milliseconds a resource can go unused before it should be destroyed
+              idleTimeout: 3000,
+              // frequency to check for idle resources
+              reapInterval: 1000
+          }
+      }
     }
     ,millstone: {
         // Needs to be writable by server user
@@ -48,29 +195,82 @@ var config = {
         // Max number of connections in each pool.
         // Users will be put on a queue when the limit is hit.
         // Set to maxConnection to have no possible queues.
-        // There are currently 3 pools involved in serving
+        // There are currently 2 pools involved in serving
         // windshaft-cartodb requests so multiply this number
-        // by 3 to know how many possible connections will be
+        // by 2 to know how many possible connections will be
         // kept open by the server. The default is 50.
         max: 50,
+        returnToHead: true, // defines the behaviour of the pool: false => queue, true => stack
         idleTimeoutMillis: 30000, // idle time before dropping connection
-        reapIntervalMillis: 1000 // time between cleanups
+        reapIntervalMillis: 1000, // time between cleanups
+        slowQueries: {
+            log: true,
+            elapsedThreshold: 200
+        },
+        slowPool: {
+            log: true, // whether a slow acquire must be logged or not
+            elapsedThreshold: 25 // the threshold to determine an slow acquire must be reported or not
+        },
+        emitter: {
+            statusInterval: 5000 // time, in ms, between each status report is emitted from the pool, status is sent to statsd
+        },
+        unwatchOnRelease: false, // Send unwatch on release, see http://github.com/CartoDB/Windshaft-cartodb/issues/161
+        noReadyCheck: true // Check `no_ready_check` at https://github.com/mranney/node_redis/tree/v0.12.1#overloading
     }
-    ,sqlapi: {
-        protocol: 'https',
-        domain: 'cartodb.com',
-        port: 8080,
-        version: 'v2'
+    // For more details about this options check https://nodejs.org/api/http.html#http_new_agent_options
+    ,httpAgent: {
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 25,
+        maxFreeSockets: 256
     }
     ,varnish: {
         host: 'localhost',
-        port: 6082,
-        ttl: 86400
+        port: 6082, // the por for the telnet interface where varnish is listening to
+        http_port: 6081, // the port for the HTTP interface where varnish is listening to
+        purge_enabled: false, // whether the purge/invalidation mechanism is enabled in varnish or not
+        secret: 'xxx',
+        ttl: 86400,
+        layergroupTtl: 86400 // the max-age for cache-control header in layergroup responses
+    }
+    // this [OPTIONAL] configuration enables invalidating by surrogate key in fastly
+    ,fastly: {
+        // whether the invalidation is enabled or not
+        enabled: false,
+        // the fastly api key
+        apiKey: 'wadus_api_key',
+        // the service that will get surrogate key invalidation
+        serviceId: 'wadus_service_id'
     }
     // If useProfiler is true every response will be served with an
-    // X-Tiler-Profile header containing elapsed timing for various 
+    // X-Tiler-Profile header containing elapsed timing for various
     // steps taken for producing the response.
     ,useProfiler:false
+    ,serverMetadata: {
+      cdn_url: {
+        http: 'api.cartocdn.com',
+        https: 'cartocdn.global.ssl.fastly.net'
+      }
+    }
+    // Settings for the health check available at /health
+    ,health: {
+      enabled: true,
+      username: 'localhost',
+      z: 0,
+      x: 0,
+      y: 0
+    }
+    ,disabled_file: 'pids/disabled'
+
+    // Use this as a feature flags enabling/disabling mechanism
+    ,enabledFeatures: {
+        // whether it should intercept tile render errors an act based on them, enabled by default.
+        onTileErrorStrategy: true,
+        // whether the affected tables for a given SQL must query directly postgresql or use the SQL API
+        cdbQueryTablesFromPostgres: true,
+        // whether in mapconfig is available stats & metadata for each layer
+        layerMetadata: false
+    }
 };
 
 module.exports = config;

config/environments/staging.js.example

@@ -2,17 +2,46 @@ var config = {
     environment: 'production'
     ,port: 8181
     ,host: '127.0.0.1'
+    // Size of the threadpool which can be used to run user code and get notified in the loop thread
+    // Its default size is 4, but it can be changed at startup time (the absolute maximum is 128).
+    // See http://docs.libuv.org/en/latest/threadpool.html
+    ,uv_threadpool_size: undefined
     // Regular expression pattern to extract username
     // from hostname. Must have a single grabbing block.
     ,user_from_host: '^(.*)\\.cartodb\\.com$'
+
+    // Base URLs for the APIs
+    //
+    // See http://github.com/CartoDB/Windshaft-cartodb/wiki/Unified-Map-API
+    //
+    // Base url for the Templated Maps API
+    // "/api/v1/maps/named" is the new API,
+    // "/tiles/template" is for compatibility with versions up to 1.6.x
+    ,base_url_templated: '(?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template)'
+    // Base url for the Detached Maps API
+    // "/api/v1/maps" is the the new API,
+    // "/tiles/layergroup" is for compatibility with versions up to 1.6.x
+    ,base_url_detached: '(?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)'
+
     // Maximum number of connections for one process
     // 128 is a good value with a limit of 1024 open file descriptors
     ,maxConnections:128
-    // idle socket timeout, in miliseconds
-    ,socket_timeout: 600000 
+    // Maximum number of templates per user. Unlimited by default.
+    ,maxUserTemplates:1024
+    // Seconds since "last creation" before a detached
+    // or template instance map expires. Or: how long do you want
+    // to be able to navigate the map without a reload ?
+    // Defaults to 7200 (2 hours)
+    ,mapConfigTTL: 7200
+    // idle socket timeout, in milliseconds
+    ,socket_timeout: 600000
     ,enable_cors: true
     ,cache_enabled: true
-    ,log_format: '[:date] :req[X-Real-IP] :method :req[Host]:url :status :response-time ms (:res[X-Tiler-Profiler]) -> :res[Content-Type]'
+    ,log_format: ':req[X-Real-IP] :method :req[Host]:url :status :response-time ms (:res[X-Tiler-Profiler]) -> :res[Content-Type]'
+    // If log_filename is given logs will be written
+    // there, in append mode. Otherwise stdout is used (default).
+    // Log file will be re-opened on receiving the HUP signal
+    ,log_filename: 'logs/node-windshaft.log'
     // Templated database username for authorized user
     // Supported labels: 'user_id' (read from redis)
     ,postgres_auth_user: 'cartodb_staging_user_<%= user_id %>'
@@ -29,14 +58,132 @@ var config = {
         extent: "-20037508.3,-20037508.3,20037508.3,20037508.3",
         row_limit: 65535,
         simplify_geometries: true,
+        use_overviews: true, // use overviews to retrieve raster
+        /*
+         * Set persist_connection to false if you want
+         * database connections to be closed on renderer
+         * expiration (1 minute after last use).
+         * Setting to true (the default) would never
+         * close any connection for the server's lifetime
+         */
+        persist_connection: false,
         max_size: 500
     }
     ,mapnik_version: undefined
+    ,mapnik_tile_format: 'png8:m=h'
+    ,statsd: {
+        host: 'localhost',
+        port: 8125,
+        prefix: 'stage.:host.',
+        cacheDns: true
+        // support all allowed node-statsd options
+    }
     ,renderer: {
       // Milliseconds since last access before renderer cache item expires
       cache_ttl: 60000,
-      metatile: 4,
-      bufferSize: 64
+      statsInterval: 5000, // milliseconds between each report to statsd about number of renderers and mapnik pool status
+      mapnik: {
+          // The size of the pool of internal mapnik backend
+          // This pool size is per mapnik renderer created in Windshaft's RendererFactory
+          // See https://github.com/CartoDB/Windshaft/blob/master/lib/windshaft/renderers/renderer_factory.js
+          // Important: check the configuration of uv_threadpool_size to use suitable value
+          poolSize: 8,
+
+          // Metatile is the number of tiles-per-side that are going
+          // to be rendered at once. If all of them will be requested
+          // we'd have saved time. If only one will be used, we'd have
+          // wasted time.
+          metatile: 2,
+
+          // tilelive-mapnik uses an internal cache to store tiles/grids
+          // generated when using metatile. This options allow to tune
+          // the behaviour for that internal cache.
+          metatileCache: {
+              // Time an object must stay in the cache until is removed
+              ttl: 0,
+              // Whether an object must be removed after the first hit
+              // Usually you want to use `true` here when ttl>0.
+              deleteOnHit: false
+          },
+
+          // Override metatile behaviour depending on the format
+          formatMetatile: {
+              png: 2,
+              'grid.json': 1
+          },
+
+          // Buffer size is the tickness in pixel of a buffer
+          // around the rendered (meta?)tile.
+          //
+          // This is important for labels and other marker that overlap tile boundaries.
+          // Setting to 128 ensures no render artifacts.
+          // 64 may have artifacts but is faster.
+          // Less important if we can turn metatiling on.
+          bufferSize: 64,
+
+          // SQL queries will be wrapped with ST_SnapToGrid
+          // Snapping all points of the  geometry to a regular grid
+          snapToGrid: false,
+
+          // SQL queries will be wrapped with ST_ClipByBox2D
+          // Returning the portion of a geometry falling within a rectangle
+          // It will only work if snapToGrid is enabled
+          clipByBox2d: false, // this requires postgis >=2.2 and geos >=3.5
+
+          limits: {
+              // Time in milliseconds a render request can take before it fails, some notes:
+              //  - 0 means no render limit
+              //  - it considers metatiling, naive implementation: (render timeout) * (number of tiles in metatile)
+              render: 0,
+              // As the render request will finish even if timed out, whether it should be placed in the internal
+              // cache or it should be fully discarded. When placed in the internal cache another attempt to retrieve
+              // the same tile will result in an immediate response, however that will use a lot of more application
+              // memory. If we want to enforce this behaviour we have to implement a cache eviction policy for the
+              // internal cache.
+              cacheOnTimeout: true
+          },
+
+          geojson: {
+                dbPoolParams: {
+                      // maximum number of resources to create at any given time
+                      size: 16,
+                      // max milliseconds a resource can go unused before it should be destroyed
+                      idleTimeout: 3000,
+                      // frequency to check for idle resources
+                      reapInterval: 1000
+                },
+
+              // SQL queries will be wrapped with ST_ClipByBox2D
+              // Returning the portion of a geometry falling within a rectangle
+              // It will only work if snapToGrid is enabled
+              clipByBox2d: false, // this requires postgis >=2.2 and geos >=3.5
+          }
+
+      },
+      http: {
+          timeout: 2000, // the timeout in ms for a http tile request
+          proxy: undefined, // the url for a proxy server
+          whitelist: [ // the whitelist of urlTemplates that can be used
+              '.*', // will enable any URL
+              'http://{s}.example.com/{z}/{x}/{y}.png'
+          ],
+          // image to use as placeholder when urlTemplate is not in the whitelist
+          // if provided the http renderer will use it instead of throw an error
+          fallbackImage: {
+              type: 'fs', // 'fs' and 'url' supported
+              src: __dirname + '/../../assets/default-placeholder.png'
+          }
+      },
+      torque: {
+          dbPoolParams: {
+              // maximum number of resources to create at any given time
+              size: 16,
+              // max milliseconds a resource can go unused before it should be destroyed
+              idleTimeout: 3000,
+              // frequency to check for idle resources
+              reapInterval: 1000
+          }
+      }
     }
     ,millstone: {
         // Needs to be writable by server user
@@ -48,29 +195,82 @@ var config = {
         // Max number of connections in each pool.
         // Users will be put on a queue when the limit is hit.
         // Set to maxConnection to have no possible queues.
-        // There are currently 3 pools involved in serving
+        // There are currently 2 pools involved in serving
         // windshaft-cartodb requests so multiply this number
-        // by 3 to know how many possible connections will be
+        // by 2 to know how many possible connections will be
         // kept open by the server. The default is 50.
         max: 50,
+        returnToHead: true, // defines the behaviour of the pool: false => queue, true => stack
         idleTimeoutMillis: 30000, // idle time before dropping connection
-        reapIntervalMillis: 1000 // time between cleanups
+        reapIntervalMillis: 1000, // time between cleanups
+        slowQueries: {
+            log: true,
+            elapsedThreshold: 200
+        },
+        slowPool: {
+            log: true, // whether a slow acquire must be logged or not
+            elapsedThreshold: 25 // the threshold to determine an slow acquire must be reported or not
+        },
+        emitter: {
+            statusInterval: 5000 // time, in ms, between each status report is emitted from the pool, status is sent to statsd
+        },
+        unwatchOnRelease: false, // Send unwatch on release, see http://github.com/CartoDB/Windshaft-cartodb/issues/161
+        noReadyCheck: true // Check `no_ready_check` at https://github.com/mranney/node_redis/tree/v0.12.1#overloading
     }
-    ,sqlapi: {
-        protocol: 'https',
-        domain: 'cartodb.com',
-        port: 8080,
-        version: 'v2'
+    // For more details about this options check https://nodejs.org/api/http.html#http_new_agent_options
+    ,httpAgent: {
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 25,
+        maxFreeSockets: 256
     }
     ,varnish: {
         host: 'localhost',
-        port: 6082,
-        ttl: 86400
+        port: 6082, // the por for the telnet interface where varnish is listening to
+        http_port: 6081, // the port for the HTTP interface where varnish is listening to
+        purge_enabled: false, // whether the purge/invalidation mechanism is enabled in varnish or not
+        secret: 'xxx',
+        ttl: 86400,
+        layergroupTtl: 86400 // the max-age for cache-control header in layergroup responses
+    }
+    // this [OPTIONAL] configuration enables invalidating by surrogate key in fastly
+    ,fastly: {
+        // whether the invalidation is enabled or not
+        enabled: false,
+        // the fastly api key
+        apiKey: 'wadus_api_key',
+        // the service that will get surrogate key invalidation
+        serviceId: 'wadus_service_id'
     }
     // If useProfiler is true every response will be served with an
-    // X-Tiler-Profile header containing elapsed timing for various 
+    // X-Tiler-Profile header containing elapsed timing for various
     // steps taken for producing the response.
     ,useProfiler:true
+    ,serverMetadata: {
+      cdn_url: {
+        http: 'api.cartocdn.com',
+        https: 'cartocdn.global.ssl.fastly.net'
+      }
+    }
+    // Settings for the health check available at /health
+    ,health: {
+      enabled: false,
+      username: 'localhost',
+      z: 0,
+      x: 0,
+      y: 0
+    }
+    ,disabled_file: 'pids/disabled'
+
+    // Use this as a feature flags enabling/disabling mechanism
+    ,enabledFeatures: {
+        // whether it should intercept tile render errors an act based on them, enabled by default.
+        onTileErrorStrategy: true,
+        // whether the affected tables for a given SQL must query directly postgresql or use the SQL API
+        cdbQueryTablesFromPostgres: true,
+        // whether in mapconfig is available stats & metadata for each layer
+        layerMetadata: true
+    }
 };
 
 module.exports = config;

config/environments/test.js.example

@@ -2,41 +2,189 @@ var config = {
      environment: 'test'
     ,port: 8888
     ,host: '127.0.0.1'
+    // Size of the threadpool which can be used to run user code and get notified in the loop thread
+    // Its default size is 4, but it can be changed at startup time (the absolute maximum is 128).
+    // See http://docs.libuv.org/en/latest/threadpool.html
+    ,uv_threadpool_size: undefined
     // Regular expression pattern to extract username
     // from hostname. Must have a single grabbing block.
     ,user_from_host: '(.*)'
+
+    // Base URLs for the APIs
+    //
+    // See https://github.com/CartoDB/Windshaft-cartodb/wiki/Unified-Map-API
+    //
+    // Base url for the Templated Maps API
+    // "/api/v1/map/named" is the new API,
+    // "/tiles/template" is for compatibility with versions up to 1.6.x
+    ,base_url_templated: '(?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template)'
+    // Base url for the Detached Maps API
+    // "maps" is the the new API,
+    // "tiles/layergroup" is for compatibility with versions up to 1.6.x
+    ,base_url_detached: '(?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)'
+
     // Maximum number of connections for one process
     // 128 is a good value with a limit of 1024 open file descriptors
     ,maxConnections:128
-    // idle socket timeout, in miliseconds
-    ,socket_timeout: 600000 
+    // Maximum number of templates per user. Unlimited by default.
+    ,maxUserTemplates:1024
+    // Seconds since "last creation" before a detached
+    // or template instance map expires. Or: how long do you want
+    // to be able to navigate the map without a reload ?
+    // Defaults to 7200 (2 hours)
+    ,mapConfigTTL: 7200
+    // idle socket timeout, in milliseconds
+    ,socket_timeout: 600000
     ,enable_cors: true
     ,cache_enabled: false
     ,log_format: '[:date] :req[X-Real-IP] :method :req[Host]:url :status :response-time ms -> :res[Content-Type] (:res[X-Tiler-Profiler])'
+    // If log_filename is given logs will be written
+    // there, in append mode. Otherwise stdout is used (default).
+    // Log file will be re-opened on receiving the HUP signal
+    //,log_filename: 'logs/node-windshaft.log'
     // Templated database username for authorized user
     // Supported labels: 'user_id' (read from redis)
-    ,postgres_auth_user: 'test_cartodb_user_<%= user_id %>'
+    ,postgres_auth_user: 'test_windshaft_cartodb_user_<%= user_id %>'
     // Templated database password for authorized user
     // Supported labels: 'user_id', 'user_password' (both read from redis)
-    ,postgres_auth_pass: 'test_cartodb_user_<%= user_id %>_pass'
+    ,postgres_auth_pass: 'test_windshaft_cartodb_user_<%= user_id %>_pass'
     ,postgres: {
         // Parameters to pass to datasource plugin of mapnik
         // See http://github.com/mapnik/mapnik/wiki/PostGIS
-        user: "testpublicuser",
+        user: "test_windshaft_publicuser",
         password: "public",
         host: '127.0.0.1',
         port: 5432,
         extent: "-20037508.3,-20037508.3,20037508.3,20037508.3",
         row_limit: 65535,
         simplify_geometries: true,
+        use_overviews: true, // use overviews to retrieve raster
+        /*
+         * Set persist_connection to false if you want
+         * database connections to be closed on renderer
+         * expiration (1 minute after last use).
+         * Setting to true (the default) would never
+         * close any connection for the server's lifetime
+         */
+        persist_connection: false,
         max_size: 500
     }
-    ,mapnik_version: '2.0.2'
+    ,mapnik_version: ''
+    ,mapnik_tile_format: 'png8:m=h'
+    ,statsd: {
+        host: 'localhost',
+        port: 8125,
+        prefix: 'test.:host.',
+        cacheDns: true
+        // support all allowed node-statsd options
+    }
     ,renderer: {
       // Milliseconds since last access before renderer cache item expires
       cache_ttl: 60000,
-      metatile: 4,
-      bufferSize: 64
+      statsInterval: 5000, // milliseconds between each report to statsd about number of renderers and mapnik pool status
+      mapnik: {
+          // The size of the pool of internal mapnik backend
+          // This pool size is per mapnik renderer created in Windshaft's RendererFactory
+          // See https://github.com/CartoDB/Windshaft/blob/master/lib/windshaft/renderers/renderer_factory.js
+          // Important: check the configuration of uv_threadpool_size to use suitable value
+          poolSize: 8,
+
+          // Metatile is the number of tiles-per-side that are going
+          // to be rendered at once. If all of them will be requested
+          // we'd have saved time. If only one will be used, we'd have
+          // wasted time.
+          metatile: 2,
+
+          // tilelive-mapnik uses an internal cache to store tiles/grids
+          // generated when using metatile. This options allow to tune
+          // the behaviour for that internal cache.
+          metatileCache: {
+              // Time an object must stay in the cache until is removed
+              ttl: 0,
+              // Whether an object must be removed after the first hit
+              // Usually you want to use `true` here when ttl>0.
+              deleteOnHit: false
+          },
+
+          // Override metatile behaviour depending on the format
+          formatMetatile: {
+              png: 2,
+              'grid.json': 1
+          },
+
+          // Buffer size is the tickness in pixel of a buffer
+          // around the rendered (meta?)tile.
+          //
+          // This is important for labels and other marker that overlap tile boundaries.
+          // Setting to 128 ensures no render artifacts.
+          // 64 may have artifacts but is faster.
+          // Less important if we can turn metatiling on.
+          bufferSize: 64,
+
+          // SQL queries will be wrapped with ST_SnapToGrid
+          // Snapping all points of the  geometry to a regular grid
+          snapToGrid: false,
+
+          // SQL queries will be wrapped with ST_ClipByBox2D
+          // Returning the portion of a geometry falling within a rectangle
+          // It will only work if snapToGrid is enabled
+          clipByBox2d: false, // this requires postgis >=2.2 and geos >=3.5
+
+          limits: {
+              // Time in milliseconds a render request can take before it fails, some notes:
+              //  - 0 means no render limit
+              //  - it considers metatiling, naive implementation: (render timeout) * (number of tiles in metatile)
+              render: 0,
+              // As the render request will finish even if timed out, whether it should be placed in the internal
+              // cache or it should be fully discarded. When placed in the internal cache another attempt to retrieve
+              // the same tile will result in an immediate response, however that will use a lot of more application
+              // memory. If we want to enforce this behaviour we have to implement a cache eviction policy for the
+              // internal cache.
+              cacheOnTimeout: true
+          },
+
+          geojson: {
+                dbPoolParams: {
+                      // maximum number of resources to create at any given time
+                      size: 16,
+                      // max milliseconds a resource can go unused before it should be destroyed
+                      idleTimeout: 3000,
+                      // frequency to check for idle resources
+                      reapInterval: 1000
+                },
+
+              // SQL queries will be wrapped with ST_ClipByBox2D
+              // Returning the portion of a geometry falling within a rectangle
+              // It will only work if snapToGrid is enabled
+              clipByBox2d: false // this requires postgis >=2.2 and geos >=3.5
+          }
+      },
+      http: {
+          timeout: 2000, // the timeout in ms for a http tile request
+          proxy: undefined, // the url for a proxy server
+          whitelist: [ // the whitelist of urlTemplates that can be used
+              '.*', // will enable any URL
+              'http://{s}.example.com/{z}/{x}/{y}.png',
+              // for testing purposes
+              'http://{s}.basemaps.cartocdn.com/dark_nolabels/{z}/{x}/{y}.png'
+          ],
+          // image to use as placeholder when urlTemplate is not in the whitelist
+          // if provided the http renderer will use it instead of throw an error
+          fallbackImage: {
+              type: 'fs', // 'fs' and 'url' supported
+              src: __dirname + '/../../assets/default-placeholder.png'
+          }
+      },
+      torque: {
+          dbPoolParams: {
+              // maximum number of resources to create at any given time
+              size: 16,
+              // max milliseconds a resource can go unused before it should be destroyed
+              idleTimeout: 3000,
+              // frequency to check for idle resources
+              reapInterval: 1000
+          }
+      }
     }
     ,millstone: {
         // Needs to be writable by server user
@@ -48,31 +196,76 @@ var config = {
         // Max number of connections in each pool.
         // Users will be put on a queue when the limit is hit.
         // Set to maxConnection to have no possible queues.
-        // There are currently 3 pools involved in serving
+        // There are currently 2 pools involved in serving
         // windshaft-cartodb requests so multiply this number
-        // by 3 to know how many possible connections will be
+        // by 2 to know how many possible connections will be
         // kept open by the server. The default is 50.
         max: 50,
+        returnToHead: true, // defines the behaviour of the pool: false => queue, true => stack
         idleTimeoutMillis: 1, // idle time before dropping connection
-        reapIntervalMillis: 1 // time between cleanups
+        reapIntervalMillis: 1, // time between cleanups
+        slowQueries: {
+            log: true,
+            elapsedThreshold: 200
+        },
+        slowPool: {
+            log: true, // whether a slow acquire must be logged or not
+            elapsedThreshold: 25 // the threshold to determine an slow acquire must be reported or not
+        },
+        emitter: {
+            statusInterval: 5000 // time, in ms, between each status report is emitted from the pool, status is sent to statsd
+        },
+        unwatchOnRelease: false, // Send unwatch on release, see http://github.com/CartoDB/Windshaft-cartodb/issues/161
+        noReadyCheck: true // Check `no_ready_check` at https://github.com/mranney/node_redis/tree/v0.12.1#overloading
     }
-    ,sqlapi: {
-        protocol: 'http',
-        domain: '',
-        // This port will be used by "make check" for testing purposes
-        // It must be available
-        port: 1080,
-        version: 'v1'
+    // For more details about this options check https://nodejs.org/api/http.html#http_new_agent_options
+    ,httpAgent: {
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 25,
+        maxFreeSockets: 256
     }
     ,varnish: {
         host: '',
-        port: null,
-        ttl: 86400
+        port: null, // the por for the telnet interface where varnish is listening to
+        http_port: 6081, // the port for the HTTP interface where varnish is listening to
+        purge_enabled: false, // whether the purge/invalidation mechanism is enabled in varnish or not
+        secret: 'xxx',
+        ttl: 86400,
+        layergroupTtl: 86400 // the max-age for cache-control header in layergroup responses
+    }
+    // this [OPTIONAL] configuration enables invalidating by surrogate key in fastly
+    ,fastly: {
+        // whether the invalidation is enabled or not
+        enabled: false,
+        // the fastly api key
+        apiKey: 'wadus_api_key',
+        // the service that will get surrogate key invalidation
+        serviceId: 'wadus_service_id'
     }
     // If useProfiler is true every response will be served with an
-    // X-Tiler-Profile header containing elapsed timing for various 
+    // X-Tiler-Profile header containing elapsed timing for various
     // steps taken for producing the response.
-    ,useProfiler:false
+    ,useProfiler:true
+    // Settings for the health check available at /health
+    ,health: {
+      enabled: false,
+      username: 'localhost',
+      z: 0,
+      x: 0,
+      y: 0
+    }
+    ,disabled_file: 'pids/disabled'
+
+    // Use this as a feature flags enabling/disabling mechanism
+    ,enabledFeatures: {
+        // whether it should intercept tile render errors an act based on them, enabled by default.
+        onTileErrorStrategy: true,
+        // whether the affected tables for a given SQL must query directly postgresql or use the SQL API
+        cdbQueryTablesFromPostgres: true,
+        // whether in mapconfig is available stats & metadata for each layer
+        layerMetadata: true
+    }
 };
 
 module.exports = config;

config/settings.js

@@ -1 +0,0 @@
-module.exports.oneDay   = 86400000;

configure

@@ -20,7 +20,6 @@
 ENVDIR=config/environments
 
 PGPORT=
-SQLAPI_PORT=
 MAPNIK_VERSION=
 ENVIRONMENT=development
 
@@ -32,7 +31,6 @@ usage() {
   echo "Configuration:"
   echo "  --help                        display this help and exit"
   echo "  --with-pgport=NUM             access PostgreSQL server on TCP port NUM [$PGPORT]"
-  echo "  --with-sqlapi-port=NUM        access SQL-API server on TCP port NUM [$SQLAPI_PORT]"
   echo "  --with-mapnik-version=STRING  set mapnik version string [$MAPNIK_VERSION]"
   echo "  --environment=STRING          set output environment name [$ENVIRONMENT]"
 }
@@ -46,9 +44,6 @@ while test -n "$1"; do
     --with-pgport=*)
       PGPORT=`echo "$1" | cut -d= -f2`
       ;;
-    --with-sqlapi-port=*)
-      SQLAPI_PORT=`echo "$1" | cut -d= -f2`
-      ;;
     --with-mapnik-version=*)
       MAPNIK_VERSION=`echo "$1" | cut -d= -f2`
       ;;
@@ -56,9 +51,8 @@ while test -n "$1"; do
       ENVIRONMENT=`echo "$1" | cut -d= -f2`
       ;;
     *)
-      echo "Unknown option '$1'" >&2
-      usage >&2
-      exit 1
+      echo "Unused option '$1'" >&2
+      ;;
   esac
   shift
 done
@@ -68,12 +62,8 @@ ENVEX=./${ENVDIR}/${ENVIRONMENT}.js.example
 if [ -z "$PGPORT" ]; then
   PGPORT=`node -e "console.log(require('${ENVEX}').postgres.port)"`
 fi
-if [ -z "$SQLAPI_PORT" ]; then
-  SQLAPI_PORT=`node -e "console.log(require('${ENVEX}').sqlapi.port)"`
-fi
 
 echo "PGPORT: $PGPORT"
-echo "SQLAPI_PORT: $SQLAPI_PORT"
 echo "MAPNIK_VERSION: $MAPNIK_VERSION"
 echo "ENVIRONMENT: $ENVIRONMENT"
 
@@ -83,7 +73,6 @@ echo "Writing $o"
 # See http://austinmatzko.com/2008/04/26/sed-multi-line-search-and-replace/
 sed -n "1h;1!H;\${;g;s/\(,postgres: {[^}]*port: *'\?\)[^',]*\('\?,\)/\1$PGPORT\2/;p;}" < "${ENVEX}" \
   | sed "s/mapnik_version:.*/mapnik_version: '$MAPNIK_VERSION'/" \
-  | sed -n "1h;1!H;\${;g;s/\(,sqlapi: {[^}]*port: *'\?\)[^',]*\('\?,\)/\1$SQLAPI_PORT\2/;p;}" \
   > "$o"
 
 STATUSFILE=config.status--${ENVIRONMENT}

docs/Map-API.md

@@ -0,0 +1,19 @@
+# Maps API
+
+The CartoDB Maps API allows you to generate maps based on data hosted in your CartoDB account and apply custom SQL and CartoCSS to the data. The API generates a XYZ-based URL to fetch Web Mercator projected tiles, using web clients such as [Leaflet](http://leafletjs.com), [Google Maps](https://developers.google.com/maps/), or [OpenLayers](http://openlayers.org/).
+
+You can create two types of maps with the Maps API:
+
+- **Anonymous maps**  
+  You can create maps using your CartoDB public data. Any client can change the read-only SQL and CartoCSS parameters that generate the map tiles. These maps can be created from a JavaScript application alone and no authenticated calls are needed. See [this CartoDB.js example](/cartodb-platform/cartodb-js/getting-started/).
+
+- **Named maps**  
+  There are also maps that have access to your private data. These maps require an owner to setup and modify any SQL and CartoCSS parameters and are not modifiable without new setup calls.
+
+## Documentation
+
+* [Quickstart](quickstart.md)
+* [General Concepts](general_concepts.md)
+* [Anonymous Maps](anonymous_maps.md)
+* [Named Maps](named_maps.md)
+* [Static Maps API](static_maps_api.md)

docs/MapConfig-NamedMaps-extension.md

@@ -0,0 +1,56 @@
+# 1. Purpose
+
+This specification describes an extension for
+[MapConfig 1.3.0](https://github.com/CartoDB/Windshaft/blob/master/doc/MapConfig-1.3.0.md) version.
+
+
+# 2. Changes over specification
+
+This extension introduces a new layer type so it's possible to use a named map by its name as a layer.
+
+## 2.1 Named layers definition
+
+```javascript
+{
+    // REQUIRED
+    // string, `named` is the only supported value
+    type: "named",
+
+    // REQUIRED
+    // object, set `named` map layers configuration
+    options: {
+
+        // REQUIRED
+        // string, the name for the named map to use
+        name: "world_borders",
+
+        // OPTIONAL
+        // object, the replacement values for the named map's template placeholders
+        // See https://github.com/CartoDB/Windshaft-cartodb/blob/master/docs/Map-API.md#instantiate-1 for more details
+        config: {
+            "color": "#000"
+        },
+
+        // OPTIONAL
+        // string array, the authorized tokens in case the named map has auth method set to `token`
+        // See https://github.com/CartoDB/Windshaft-cartodb/blob/master/docs/Map-API.md#named-maps-1 for more details
+        auth_tokens: [
+            "token1",
+            "token2"
+        ]
+    }
+}
+```
+
+## 2.2 Limitations
+
+1. A Named Map will not allow to have `named` type layers inside their templates layergroup's layers definition.
+2. A `named` layer does not allow Named Maps form other accounts, it's only possible to use Named Maps from the very
+same user account.
+
+
+# History
+
+## 1.0.0
+
+ - Initial version

docs/MultiLayer-API.md

@@ -0,0 +1,28 @@
+The Windshaft-CartoDB MultiLayer API extends the [Windshaft MultiLayer API](https://github.com/CartoDB/Windshaft/blob/master/doc/Multilayer-API.md) in a few ways.
+
+## Last modification timestamp embedded in the token
+
+It encodes a timestamp of 'last modification time' into the map token (token:EPOCH) returned to the client.
+It accepts tokens with encoded timestamp from the client considering the token suffix as a cache_buster value.
+
+Clients don't need to be aware of the extension but rather use the API as they would use the base one.
+The only difference will be that the _same_ layergroup configuration may result in different tokens if source data was modified between the mapview requests. 
+
+## Additional attributes in the response object
+
+Windshaft-CartoDB adds the following attributes in the response object
+
+- ``last_update`` field with ISO format (2013-11-30T12:23:10).
+- ``cdn_url`` object containing CDN url client should use (not mandatory) to access the tiles. It's in the form:
+
+   ```json
+   {
+     "http": "http://cdn_url.com/",
+     "https": "https://secure.cdn_url.com/"
+   }
+   ```
+
+
+## Stats tag
+
+Windshaft-CartoDB adds support for a ``stat_tag`` element in the multilayer configuration to help [stats](https://github.com/CartoDB/Windshaft-cartodb/wiki/Redis-stats-format) gathering.

docs/Routes.md

@@ -0,0 +1,104 @@
+This document list all routes available in Windshaft-cartodb Maps API server.
+
+## Routes list
+
+1. `GET (?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)/:token/:z/:x/:y@:scale_factor?x.:format {:user(f),:token(f),:z(f),:x(f),:y(f),:scale_factor(t),:format(f)} (1)`
+<br/>Notes: Mapnik retina tiles [0]
+
+1. `GET (?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)/:token/:z/:x/:y.:format {:user(f),:token(f),:z(f),:x(f),:y(f),:format(f)} (1)`
+<br/>Notes: Mapnik tiles [0]
+
+1. `GET (?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)/:token/:layer/:z/:x/:y.(:format) {:user(f),:token(f),:layer(f),:z(f),:x(f),:y(f),:format(f)} (1)`
+<br/>Notes: Per :layer rendering based on :format [0]
+
+1. `GET (?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup) {:user(f)} (1)`
+<br/>Notes: Map instantiation [0]
+
+1. `GET (?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)/:token/:layer/attributes/:fid {:user(f),:token(f),:layer(f),:fid(f)} (1)`
+<br/>Notes: Endpoint for info windows data, alternative for sql api when tables are private [0]
+
+1. `GET (?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)/static/center/:token/:z/:lat/:lng/:width/:height.:format {:user(f),:token(f),:z(f),:lat(f),:lng(f),:width(f),:height(f),:format(f)} (1)`
+<br/>Notes: Static Maps API [0]
+
+1. `GET (?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)/static/bbox/:token/:west,:south,:east,:north/:width/:height.:format {:user(f),:token(f),:west(f),:south(f),:east(f),:north(f),:width(f),:height(f),:format(f)} (1)`
+<br/>Notes: Static Maps API [0]
+
+1. `GET / {} (1)`
+<br/>Notes: Welcome message
+
+1. `GET /version {} (1)`
+<br/>Notes: Return relevant module versions: mapnik, grainstore, etc
+
+1. `GET (?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template)/:template_id/jsonp {:user(f),:template_id(f)} (1)`
+<br/>Notes: Named maps JSONP instantiation [1]
+
+1. `GET (?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template)/:template_id {:user(f),:template_id(f)} (1)`
+<br/>Notes: Named map retrieval (w/ API KEY) [1]
+
+1. `GET (?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template) {:user(f)} (1)`
+<br/>Notes: List named maps (w/ API KEY) [1]
+
+1. `GET (?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup)/static/named/:template_id/:width/:height.:format {:user(f),:template_id(f),:width(f),:height(f),:format(f)} (1)`
+<br/>Notes: Static map for named maps
+
+1. `GET /health {} (1)`
+<br/>Notes: Healt check
+
+1. `OPTIONS (?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup) {:user(f)} (1)`
+<br/>Notes: CORS [0]
+
+1. `OPTIONS (?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template)/:template_id {:user(f),:template_id(f)} (1)`
+<br/>Notes: CORS [1]
+
+1. `POST (?:/api/v1/map|/user/:user/api/v1/map|/tiles/layergroup) {:user(f)} (1)`
+<br/>Notes: Map instantiation [0]
+
+1. `POST (?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template) {:user(f)} (1)`
+<br/>Notes: Create named map (w/ API KEY) [1]
+
+1. `POST (?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template)/:template_id {:user(f),:template_id(f)} (1)`
+<br/>Notes: Instantiate named map [1]
+
+1. `PUT (?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template)/:template_id {:user(f),:template_id(f)} (1)`
+<br/>Notes: Update a named map (w/ API KEY) [1]
+
+1. `DELETE (?:/api/v1/map/named|/user/:user/api/v1/map/named|/tiles/template)/:template_id {:user(f),:template_id(f)} (1)`
+<br/>Notes: Delete named map (w/ API KEY) [1]
+
+## Optional deprecated routes
+
+- [0] `/tiles/layergroup` is deprecated and `/api/v1/map` should be used but we keep it for now.
+- [1] `/tiles/template` is deprecated and `/api/v1/map/named` should be used but we keep it for now.
+
+## How to generate the list of routes
+
+Something like the following patch should do the trick
+
+```javascript
+diff --git a/lib/cartodb/cartodb_windshaft.js b/lib/cartodb/cartodb_windshaft.js
+index b9429a2..e6cc5f9 100644
+--- a/lib/cartodb/cartodb_windshaft.js
++++ b/lib/cartodb/cartodb_windshaft.js
+@@ -212,6 +212,20 @@ var CartodbWindshaft = function(serverOptions) {
+         }
+     });
+
++    var format = require('util').format;
++    var routesNotes = Object.keys(ws.routes.routes)
++        .map(function(method) { return ws.routes.routes[method]; })
++        .reduce(function(previous, current) { current.map(function(r) { previous.push(r) }); return previous;}, [])
++        .map(function(route) {
++            return format("\n1. `%s %s {%s} (%d)`\n<br/>Notes: [DEPRECATED]? ",
++                route.method.toUpperCase(),
++                route.path,
++                route.keys.map(function(k) { return format(':%s(%s)', k.name, k.optional ? 't' : 'f'); } ).join(','),
++                route.callbacks.length
++            );
++        });
++    console.log(routesNotes.join('\n'));
++
+     return ws;
+ };
+
+
+```

docs/anonymous_maps.md

@@ -0,0 +1,192 @@
+# Anonymous Maps
+
+Anonymous maps allows you to instantiate a map given SQL and CartoCSS. It also allows you to add interaction capabilities using [UTF Grid.](https://github.com/mapbox/utfgrid-spec)
+
+
+## Instantiate
+
+#### Definition
+
+```html
+POST /api/v1/map
+```
+
+#### Params
+
+```javascript
+{
+  "version": "1.3.0",
+  "layers": [{
+    "type": "mapnik",
+    "options": {
+      "cartocss_version": "2.1.1",
+      "cartocss": "#layer { polygon-fill: #FFF; }",
+      "sql": "select * from european_countries_e",
+      "interactivity": ["cartodb_id", "iso3"]
+    }
+  }]
+}
+```
+
+See [MapConfig File Formats](http://docs.cartodb.com/cartodb-platform/maps-api/mapconfig/) for details.
+
+#### Response
+
+The response includes:
+
+Attributes | Description
+--- | ---
+layergroupid | The ID for that map, used to compose the URL for the tiles. The final URL is: `https://{account}.cartodb.com/api/v1/map/:layergroupid/{z}/{x}/{y}.png`
+updated_at | The ISO date of the last time the data involved in the query was updated.
+metadata | Includes information about the layers.
+cdn_url | URLs to fetch the data using the best CDN for your zone.
+
+### Example
+
+#### Call
+
+```bash
+curl 'https://documentation.cartodb.com/api/v1/map' -H 'Content-Type: application/json' -d @mapconfig.json
+```
+
+#### Response
+
+```javascript
+{
+  "layergroupid": "c01a54877c62831bb51720263f91fb33:0",
+  "last_updated": "1970-01-01T00:00:00.000Z",
+  "metadata": {
+    "layers": [
+      {
+        "type": "mapnik",
+        "meta": {}
+      }
+    ]
+  },
+  "cdn_url": {
+    "http": "http://cdb.com",
+    "https": "https://cdb.com"
+  }
+}
+```
+
+### Retrieve resources from the layergroup
+
+#### Mapnik tiles can be accessed using
+
+These tiles will get just the mapnik layers. To get individual layers see next section.
+
+```bash
+https://documentation.cartodb.com/api/v1/map/c01a54877c62831bb51720263f91fb33:0/{z}/{x}/{y}.png
+```
+
+#### Individual layers
+
+The MapConfig specification holds the layers definition in a 0-based index. Layers can be requested individually in different formats depending on the layer type.
+
+Individual layers can be accessed using that 0-based index. For UTF grid tiles:
+
+```bash
+https://documentation.cartodb.com/api/v1/map/c01a54877c62831bb51720263f91fb33:0/:layer/{z}/{x}/{y}.grid.json
+```
+
+In this case, `:layer` as 0 returns the UTF grid tiles/attributes for layer 0, the only layer in the example MapConfig.
+
+If the MapConfig had a Torque layer at index 1 it could be possible to request it with:
+
+```bash
+https://documentation.cartodb.com/api/v1/map/c01a54877c62831bb51720263f91fb33:0/1/{z}/{x}/{y}.torque.json
+```
+
+#### Attributes defined in `attributes` section
+
+```bash
+https://documentation.cartodb.com/api/v1/map/c01a54877c62831bb51720263f91fb33:0/:layer/attributes/:feature_id
+```
+
+Which returns JSON with the attributes defined, like:
+
+```javascript
+{ "c": 1, "d": 2 }
+```
+
+#### Blending and layer selection
+
+```bash
+https://documentation.cartodb.com/api/v1/map/c01a54877c62831bb51720263f91fb33:0/:layer_filter/{z}/{x}/{y}.png
+```
+
+Note: currently format is limited to `png`.
+
+`:layer_filter` can be used to select some layers to be rendered together. `:layer_filter` supports two formats:
+
+- `all` alias
+
+Using `all` as `:layer_filter` will blend all layers in the layergroup
+
+```bash
+https://documentation.cartodb.com/api/v1/map/c01a54877c62831bb51720263f91fb33:0/all/{z}/{x}/{y}.png
+```
+
+- Filter by layer index
+
+A list of comma separated layer indexes can be used to just render a subset of layers. For example `0,3,4` will filter and blend layers with indexes 0, 3, and 4.
+
+```bash
+https://documentation.cartodb.com/api/v1/map/c01a54877c62831bb51720263f91fb33:0/0,3,4/{z}/{x}/{y}.png
+```
+
+Some notes about filtering:
+
+  - Invalid index values or out of bounds indexes will end in `Invalid layer filtering` errors.
+  - Once a mapnik layer is selected, all mapnik layers will get blended. As this may change in the future **it is
+  recommended** to always select all mapnik layers if you want to select at least one so you will get a consistent
+  behavior in the future.
+  - Ordering is not considered. So right now filtering layers 0,3,4 is the very same thing as filtering 3,4,0. As this
+  may change in the future **it is recommended** to always select the layers in ascending order so you will get a
+  consistent behavior in the future.
+
+
+## Create JSONP
+
+The JSONP endpoint is provided in order to allow web browsers access which don't support CORS.
+
+#### Definition
+
+```bash
+GET /api/v1/map?callback=method
+```
+
+#### Params
+
+Param | Description
+--- | ---
+config | Encoded JSON with the params for creating named maps (the variables defined in the template).
+lmza | This attribute contains the same as config but LZMA compressed. It cannot be used at the same time as `config`.
+callback | JSON callback name.
+
+### Example
+
+#### Call
+
+```bash
+curl "https://documentation.cartodb.com/api/v1/map?callback=callback&config=%7B%22version%22%3A%221.0.1%22%2C%22layers%22%3A%5B%7B%22type%22%3A%22cartodb%22%2C%22options%22%3A%7B%22sql%22%3A%22select+%2A+from+european_countries_e%22%2C%22cartocss%22%3A%22%23european_countries_e%7B+polygon-fill%3A+%23FF6600%3B+%7D%22%2C%22cartocss_version%22%3A%222.3.0%22%2C%22interactivity%22%3A%5B%22cartodb_id%22%5D%7D%7D%5D%7D"
+```
+
+#### Response
+
+```javascript
+callback({
+  layergroupid: "d9034c133262dfb90285cea26c5c7ad7:0",
+  cdn_url: {
+    "http": "http://cdb.com",
+    "https": "https://cdb.com"
+  },
+  last_updated: "1970-01-01T00:00:00.000Z"
+})
+```
+
+
+## Remove
+
+Anonymous maps cannot be removed by an API call. They will expire after about five minutes but sometimes longer. If an anonymous map expires and tiles are requested from it, an error will be raised. This could happen if a user leaves a map open and after time, returns to the map and attempts to interact with it in a way that requires new tiles (e.g. zoom). The client will need to go through the steps of creating the map again to fix the problem.

docs/general_concepts.md

@@ -0,0 +1,27 @@
+# General Concepts
+
+The following concepts are the same for every endpoint in the API except when it's noted explicitly.
+
+## Auth
+
+By default, users do not have access to private tables in CartoDB. In order to instantiate a map from private table data an API Key is required. Additionally, to include some endpoints, an API Key must be included (e.g. creating a named map).
+
+To execute an authorized request, `api_key=YOURAPIKEY` should be added to the request URL. The param can be also passed as POST param. Using HTTPS is mandatory when you are performing requests that include your `api_key`.
+
+## Errors
+
+Errors are reported using standard HTTP codes and extended information encoded in JSON with this format:
+
+```javascript
+{
+  "errors": [
+    "access forbidden to table TABLE"
+  ]
+}
+```
+
+If you use JSONP, the 200 HTTP code is always returned so the JavaScript client can receive errors from the JSON object.
+
+## CORS support
+
+All the endpoints, which might be accessed using a web browser, add CORS headers and allow OPTIONS method.

docs/metrics.md

@@ -0,0 +1,42 @@
+Windshaft-cartodb metrics
+=========================
+See [Windshaft metrics documentation](https://github.com/CartoDB/Windshaft/blob/master/doc/metrics.md) to understand the full picture.
+
+The next list includes the API endpoints, each endpoint may have several inner timers, some of them are displayed within this list as subitems. Find the description for them in the Inner timers section.
+## Timers
+- **windshaft-cartodb.flush_cache**: time to flush the tile and sql cache
+- **windshaft-cartodb.get_template**: time to retrieve an specific template
+- **windshaft-cartodb.delete_template**: time to delete an specific template
+- **windshaft-cartodb.get_template_list**: time to retrieve the list of owned templates
+- **windshaft-cartodb.instance_template_post**: time to create a template via HTTP POST
+- **windshaft-cartodb.instance_template_get**: time to create a template via HTTP GET
+    + TemplateMaps_instance
+    + createLayergroup
+
+There are some endpoints that are not being tracked:
+- Adding a template
+- Updating a template
+
+### Inner timers
+Again, each inner timer may have several inner timers.
+
+- **addCacheChannel**: time to add X-Cache-Channel header based on table last modifications
+- **LZMA decompress**: time to decompress request params with LZMA
+- **TemplateMaps_instance**: time to retrieve a map template instance, see *getTemplate* and *authorizedByCert*
+- **affectedTables**: time to check what are the affected tables for adding the cache channel, see *addCacheChannel*
+- **authorize**: time to authorize a request, see *authorizedByAPIKey*, *authorizedByCert*, *authorizedBySigner*
+- **authorizedByCert**: time to authorize a template instantiation
+- **findLastUpdated**: time to retrieve the last update time for a list of tables, see *affectedTables*
+- **generateCacheChannel**: time to generate the headers for the cache channel based on the request, see *addCacheChannel*
+- **getSignerMapKey**: time to retrieve from redis the authorized user for a template map
+- **getTablePrivacy**: time to retrieve from redis the privacy of a table
+- **getTemplate**: time to retrieve from redis the template for a map
+- **getUserMapKey**: time to retrieve from redis the user key for a map
+- **incMapviewCount**: time to incremenent in redis the map views
+- **mapStore_load**: time to retrieve from redis a map configuration
+- **req2params.setup**: time to prepare the params from a request, see *req2params* in Windshaft documentation
+- **setDBAuth**: time to retrieve from redis and set db user and db password from a user
+- **setDBConn**: time to retrieve from redis and set db host and db name from a user
+- **setDBParams**: time to prepare all db params to be able to connect/query a database, see *setDBAuth* and *setDBConn*
+- **tablePrivacy_getUserDBName**: time to retrieve from redis the database for a user
+

docs/named_maps.md

@@ -0,0 +1,475 @@
+# Named Maps
+
+Named maps are essentially the same as anonymous maps except the MapConfig is stored on the server, and the map is given a unique name. You can create named maps from private data, and users without an API Key can view your Named Map (while keeping your data private). The Named map workflow consists of making a call to your database, referencing a table, inserting your variables into the template where placeholders are defined, and creating custom queries.
+
+The main two differences compared to anonymous maps are:
+
+- **auth layer**  
+  This allows you to control who is able to see the map based on a token auth
+
+- **templates**  
+  Since the MapConfig is static it can contain some variables so the client can modify the map's appearance using those variables.
+
+Template maps are persistent with no preset expiration. They can only be created or deleted by a CartoDB user with a valid API_KEY (see auth section).
+
+**Note:** There is a limit of 4,096 named maps allowed per account. If you need to create more Named maps, it is recommended to use templates.
+
+## Create
+
+#### Definition
+
+```html
+POST /api/v1/map/named
+```
+
+#### Params
+
+Params | Description
+--- | ---
+api_key | is required
+
+#### template.json
+
+```javascript
+{
+  "version": "0.0.1",
+  "name": "template_name",
+  "auth": {
+    "method": "token",
+    "valid_tokens": [
+      "auth_token1",
+      "auth_token2"
+    ]
+  },
+  "placeholders": {
+    "color": {
+      "type": "css_color",
+      "default": "red"
+    },
+    "cartodb_id": {
+      "type": "number",
+      "default": 1
+    }
+  },
+  "layergroup": {
+    "version": "1.0.1",
+    "layers": [
+      {
+        "type": "cartodb",
+        "options": {
+          "cartocss_version": "2.1.1",
+          "cartocss": "#layer { polygon-fill: <%= color %>; }",
+          "sql": "select * from european_countries_e WHERE cartodb_id = <%= cartodb_id %>"
+        }
+      }
+    ]
+  },
+  "view": {
+    "zoom": 4,
+    "center": {
+      "lng": 0,
+      "lat": 0
+    },
+    "bounds": {
+      "west": -45,
+      "south": -45,
+      "east": 45,
+      "north": 45
+    }
+  }
+}
+```
+
+#### Arguments
+
+Params | Description
+--- | ---
+name | There can be at most _one_ template with the same name for any user. Valid names start with a letter or a number, and only contain letters, numbers, dashes (-) or underscores (_).
+
+auth | 
+--- | ---
+&#124;_ method | `"token"` or `"open"` (the default if no `"method"` is given).
+&#124;_ valid_tokens | when `"method"` is set to `"token"`, the values listed here allow you to instantiate the named map.
+placeholders | Variables not listed here are not substituted. Variables not provided at instantiation time trigger an error. A default is required for optional variables. Type specification is used for quoting, to avoid injections see template format section below.
+layergroup | the layer list definition. This is the MapConfig explained in anonymous maps. See [MapConfig File Format](http://docs.cartodb.com/cartodb-platform/maps-api/mapconfig/) for more info.
+
+view (optional) | extra keys to specify the compelling area for the map. It can be used to have a static preview of a named map without having to instantiate it. It is possible to specify it with `center` + `zoom` or with a bounding box `bbox`. Center+zoom takes precedence over bounding box.
+--- | ---
+&#124;_ zoom | The zoom level to use
+
+&#124;_ center | 
+--- | ---
+&#124;_ &#124;_ lng | The longitude to use for the center
+&#124;_ &#124;_ lat | The latitude to use for the center
+
+&#124;_ bounds | 
+--- | ---
+&#124;_ &#124;_ west | LowerCorner longitude for the bounding box, in decimal degrees (aka most western)
+&#124;_ &#124;_ south | LowerCorner latitude for the bounding box, in decimal degrees (aka most southern)
+&#124;_ &#124;_ east | UpperCorner longitude for the bounding box, in decimal degrees (aka most eastern)
+&#124;_ &#124;_ north | UpperCorner latitude for the bounding box, in decimal degrees (aka most northern)
+
+### Template Format
+
+A templated `layergroup` allows the use of placeholders in the "cartocss" and "sql" elements of the "option" object in any "layer" of a `layergroup` configuration
+
+Valid placeholder names start with a letter and can only contain letters, numbers, or underscores. They have to be written between the `<%=` and `%>` strings in order to be replaced.
+
+#### Example
+
+```javascript
+<%= my_color %>
+```
+
+The set of supported placeholders for a template will need to be explicitly defined with a specific type and default value for each.
+
+### Placeholder Types
+
+The placeholder type will determine the kind of escaping for the associated value. Supported types are:
+
+Types | Description
+--- | ---
+sql_literal | internal single-quotes will be sql-escaped
+sql_ident | internal double-quotes will be sql-escaped
+number | can only contain numerical representation
+css_color | can only contain color names or hex-values
+
+Placeholder default values will be used whenever new values are not provided as options at the time of creation on the client. They can also be used to test the template by creating a default version with new options provided.
+
+When using templates, be very careful about your selections as they can give broad access to your data if they are defined losely.
+
+#### Call
+
+```html
+curl -X POST \
+   -H 'Content-Type: application/json' \
+   -d @template.json \
+   'https://documentation.cartodb.com/api/v1/map/named?api_key=APIKEY'
+```
+
+#### Response
+
+```javascript
+{
+  "template_id":"name",
+}
+```
+
+## Instantiate
+
+Instantiating a map allows you to get the information needed to fetch tiles. That temporal map is an anonymous map.
+
+#### Definition
+
+```html
+POST /api/v1/map/named/:template_name
+```
+
+#### Param
+
+Param | Description
+--- | ---
+auth_token | optional, but required when `"method"` is set to `"token"`
+
+```javascript
+// params.json
+{
+ "color": "#ff0000",
+ "cartodb_id": 3
+}
+```
+
+The fields you pass as `params.json` depend on the variables allowed by the named map. If there are variables missing it will raise an error (HTTP 400)
+
+- **auth_token** *optional* if the named map needs auth
+
+### Example
+
+You can initialize a template map by passing all of the required parameters in a POST to `/api/v1/map/named/:template_name`.
+
+Valid credentials will be needed if required by the template.
+
+
+#### Call
+
+```bash
+curl -X POST \
+  -H 'Content-Type: application/json' \
+  -d @params.json \
+  'https://documentation.cartodb.com/api/v1/map/named/@template_name?auth_token=AUTH_TOKEN'
+```
+
+#### Response
+
+```javascript
+{
+  "layergroupid": "docs@fd2861af@c01a54877c62831bb51720263f91fb33:123456788",
+  "last_updated": "2013-11-14T11:20:15.000Z"
+}
+```
+
+#### Error
+
+```javascript
+{
+  "errors" : ["Some error string here"]
+}
+```
+
+You can then use the `layergroupid` for fetching tiles and grids as you would normally (see anonymous map section). However you'll need to show the `auth_token`, if required by the template.
+
+## Using JSONP
+
+There is also a special endpoint to be able to initialize a map using JSONP (for old browsers).
+
+#### Definition
+
+```bash
+GET /api/v1/map/named/:template_name/jsonp
+```
+
+#### Params
+
+Params | Description
+--- | ---
+auth_token | optional, but required when `"method"` is set to `"token"`
+config | Encoded JSON with the params for creating named maps (the variables defined in the template)
+lmza | This attribute contains the same as config but LZMA compressed. It cannot be used at the same time than `config`.
+callback | JSON callback name
+
+#### Call
+
+```bash
+curl 'https://documentation.cartodb.com/api/v1/map/named/:template_name/jsonp?auth_token=AUTH_TOKEN&callback=callback&config=template_params_json'
+```
+
+#### Response
+
+```javascript
+callback({
+  "layergroupid":"c01a54877c62831bb51720263f91fb33:0",
+  "last_updated":"1970-01-01T00:00:00.000Z"
+  "cdn_url": {
+    "http": "http://cdb.com",
+    "https": "https://cdb.com"
+  }
+})
+```
+
+This takes the `callback` function (required), `auth_token` if the template needs auth, and `config` which is the variable for the template (in cases where it has variables).
+
+```javascript
+url += "config=" + encodeURIComponent(
+JSON.stringify({ color: 'red' });
+```
+
+The response is in this format:
+
+```javascript
+callback({
+  layergroupid: "dev@744bd0ed9b047f953fae673d56a47b4d:1390844463021.1401",
+  last_updated: "2014-01-27T17:41:03.021Z"
+})
+```
+
+## Update
+
+#### Definition
+
+```bash
+PUT /api/v1/map/named/:template_name
+```
+
+#### Params
+
+Param | Description
+--- | ---
+api_key | is required
+
+#### Response
+
+Same as updating a map.
+
+### Other Info
+
+Updating a named map removes all the named map instances so they need to be initialized again.
+
+### Example
+
+#### Call
+
+```bash
+curl -X PUT \
+  -H 'Content-Type: application/json' \
+  -d @template.json \
+  'https://documentation.cartodb.com/api/v1/map/named/:template_name?api_key=APIKEY'
+```
+
+#### Response
+
+```javascript
+{
+  "template_id": "@template_name"
+}
+```
+
+If any template has the same name, it will be updated.
+
+If a template with the same name does NOT exist, a 400 HTTP response is generated with an error in this format:
+
+```javascript
+{
+  "errors" : ["error string here"]
+}
+```
+
+## Delete
+
+Delete the specified template map from the server and it disables any previously initialized versions of the map.
+
+#### Definition
+
+```bash
+DELETE /api/v1/map/named/:template_name
+```
+
+#### Params
+
+Param | Description
+--- | ---
+api_key | is required
+
+### Example
+
+#### Call
+
+```bash
+curl -X DELETE 'https://documentation.cartodb.com/api/v1/map/named/:template_name?api_key=APIKEY'
+```
+
+#### Response
+
+```javascript
+{
+  "errors" : ["Some error string here"]
+}
+```
+
+On success, a 204 (No Content) response will be issued. Otherwise a 4xx response with an error will be returned.
+
+## Listing Available Templates
+
+This allows you to get a list of all available templates.
+
+#### Definition
+
+```bash
+GET /api/v1/map/named/
+```
+
+#### Params
+
+Param | Description
+--- | ---
+api_key | is required
+
+### Example
+
+#### Call
+
+```bash
+curl -X GET 'https://documentation.cartodb.com/api/v1/map/named?api_key=APIKEY'
+```
+
+#### Response
+
+```javascript
+{
+   "template_ids": ["@template_name1","@template_name2"]
+}
+```
+
+#### Error
+
+```javascript
+{
+  "errors" : ["Some error string here"]
+}
+```
+
+## Getting a Specific Template
+
+This gets the definition of a template.
+
+#### Definition
+
+```bash
+GET /api/v1/map/named/:template_name
+```
+
+#### Params
+
+Param | Description
+--- | ---
+api_key | is required
+
+### Example
+
+#### Call
+
+```bash
+curl -X GET 'https://documentation.cartodb.com/api/v1/map/named/:template_name?api_key=APIKEY'
+```
+
+#### Response
+
+```javascript
+{
+  "template": {...} // see template.json above
+}
+```
+
+#### Error
+
+```javascript
+{
+  "errors" : ["Some error string here"]
+}
+```
+
+## Use CartoDB.js to Create Named Maps
+Named maps can be used with CartoDB.js by specifying a named map in a layer source as follows. Named maps are treated almost the same as other layer source types in most other ways.
+
+```js
+var layerSource = {
+  user_name: '{your_user_name}',
+  type: 'namedmap',
+  named_map: {
+    name: '{template_name}',
+	layers: [{
+	  layer_name: "layer1",
+      interactivity: "column1, column2, ..."
+	}]
+  }
+}
+
+cartodb.createLayer('map_dom_id',layerSource)
+  .addTo(map_object);
+
+```
+
+[CartoDB.js](http://docs.cartodb.com/cartodb-platform/cartodb-js/) has methods for accessing your named maps.
+
+1. [layer.setParams()](http://docs.cartodb.com/cartodb-platform/cartodb-js/api-methods/#layersetparamskey-value) allows you to change the template variables (in the placeholders object) via JavaScript
+
+    **Note:** The CartoDB.js `layer.setParams()` function is not supported when using Named maps for Torque.
+
+2. [layer.setAuthToken()](http://docs.cartodb.com/cartodb-platform/cartodb-js/api-methods/#layersetauthtokenauthtoken) allows you to set the auth tokens to create the layer
+
+### Complete Examples of Named Maps created with CartoDB.js
+
+- [Named map selectors with interaction](http://bl.ocks.org/ohasselblad/515a8af1f99d5e690484)
+
+- [Named map with interactivity and config file used to create it](http://bl.ocks.org/ohasselblad/d1a45b8ff5e7bd90cd68)
+
+- [Toggling sublayers in a Named Map](http://bl.ocks.org/ohasselblad/c1a0f4913610eec53cd3)

docs/quickstart.md

@@ -0,0 +1,100 @@
+# Quickstart
+
+## Anonymous maps
+
+Here is an example of how to create an anonymous map with JavaScript:
+
+```javascript
+var mapconfig = {
+  "version": "1.3.1",
+  "layers": [{
+    "type": "cartodb",
+    "options": {
+      "cartocss_version": "2.1.1",
+      "cartocss": "#layer { polygon-fill: #FFF; }",
+      "sql": "select * from european_countries_e"
+    }
+  }]
+}
+
+$.ajax({
+  crossOrigin: true,
+  type: 'POST',
+  dataType: 'json',
+  contentType: 'application/json',
+  url: 'https://documentation.cartodb.com/api/v1/map',
+  data: JSON.stringify(mapconfig),
+  success: function(data) {
+    var templateUrl = 'https://documentation.cartodb.com/api/v1/map/' + data.layergroupid + '/{z}/{x}/{y}.png'
+    console.log(templateUrl);
+  }
+})
+```
+
+## Named maps
+
+Let's create a named map using some private tables in a CartoDB account.
+The following map config sets up a map of European countries that have a white fill color:
+
+```javascript
+{
+  "version": "0.0.1",
+  "name": "test",
+  "auth": {
+    "method": "open"
+  },
+  "layergroup": {
+    "layers": [{
+      "type": "mapnik",
+      "options": {
+        "cartocss_version": "2.1.1",
+        "cartocss": "#layer { polygon-fill: #FFF; }",
+        "sql": "select * from european_countries_e"
+      }
+    }]
+  }
+}
+```
+
+The map config needs to be sent to CartoDB's Map API using an authenticated call. Here we will use a command line tool called `curl`. For more info about this tool, see [this blog post](http://quickleft.com/blog/command-line-tutorials-curl), or type `man curl` in bash. Using `curl`, and storing the config from above in a file `mapconfig.json`, the call would look like:
+
+#### Call
+
+```bash
+curl 'https://{account}.cartodb.com/api/v1/map/named?api_key=APIKEY' -H 'Content-Type: application/json' -d @mapconfig.json
+```
+
+To get the `URL` to fetch the tiles you need to instantiate the map, where `template_id` is the template name from the previous response.
+
+#### Call
+
+```bash
+curl -X POST 'https://{account}.cartodb.com/api/v1/map/named/:template_id' -H 'Content-Type: application/json'
+```
+
+The response will return JSON with properties for the `layergroupid`, the timestamp (`last_updated`) of the last data modification and some key/value pairs with `metadata` for the `layers`.
+
+Note: all `layers` in `metadata` will always have a `type` string and a `meta` dictionary with the key/value pairs.
+
+#### Response
+
+```javascript
+{
+  "layergroupid": "c01a54877c62831bb51720263f91fb33:0",
+  "last_updated": "1970-01-01T00:00:00.000Z",
+  "metadata": {
+    "layers": [
+      {
+        "type": "mapnik",
+        "meta": {}
+      }
+    ]
+  }
+}
+```
+
+You can use the `layergroupid` to instantiate a URL template for accessing tiles on the client. Here we use the `layergroupid` from the example response above in this URL template:
+
+```bash
+https://documentation.cartodb.com/api/v1/map/c01a54877c62831bb51720263f91fb33:0/{z}/{x}/{y}.png
+```

docs/static_maps_api.md

@@ -0,0 +1,224 @@
+# Static Maps API
+
+The Static Maps API can be initiated using both named and anonymous maps using the 'layergroupid' token. The API can be used to create static images of parts of maps and thumbnails for use in web design, graphic design, print, field work, and many other applications that require standard image formats.
+
+## Maps API endpoints
+
+Begin by instantiating either a named or anonymous map using the `layergroupid token` as demonstrated in the Maps API documentation above. The `layergroupid` token calls to the map and allows for parameters in the definition to generate static images.
+
+### Zoom + center
+
+#### Definition
+
+```bash
+GET /api/v1/map/static/center/:token/:z/:lat/:lng/:width/:height.:format
+```
+
+#### Params
+
+Param | Description
+--- | ---
+:token | the layergroupid token from the map instantiation
+:z | the zoom level of the map
+:lat | the latitude for the center of the map
+
+:format | the format for the image, supported types: `png`, `jpg`
+--- | ---
+|_ jpg | will have a default quality of 85.
+
+### Bounding Box
+
+#### Definition
+
+```bash
+GET /api/v1/map/static/bbox/:token/:bbox/:width/:height.:format`
+```
+
+#### Params
+
+Param | Description
+--- | ---
+:token | the layergroupid token from the map instantiation
+
+:bbox | the bounding box in WGS 84 (EPSG:4326), comma separated values for:
+--- | ---
+ | LowerCorner longitude, in decimal degrees (aka most western)
+ | LowerCorner latitude, in decimal degrees (aka most southern)
+ | UpperCorner longitude, in decimal degrees (aka most eastern)
+ | UpperCorner latitude, in decimal degrees (aka most northern)
+:width | the width in pixels for the output image
+:height | the height in pixels for the output image
+:format | the format for the image, supported types: `png`, `jpg`
+
+:format | the bounding box in WGS 84 (EPSG:4326), comma separated values for:
+--- | ---
+|_ jpg | will have a default quality of 85.
+
+Note: you can see this endpoint as
+
+```bash
+GET /api/v1/map/static/bbox/:token/:west,:south,:east,:north/:width/:height.:format`
+```
+
+### Named map
+
+#### Definition
+
+```bash
+GET /api/v1/map/static/named/:name/:width/:height.:format
+```
+
+#### Params
+
+Param | Description
+--- | ---
+:name | the name of the named map
+:width | the width in pixels for the output image
+:height | the height in pixels for the output image
+:height | the height in pixels for the output image
+
+:format | the format for the image, supported types: `png`, `jpg`
+--- | ---
+|_ jpg | will have a default quality of 85.
+
+A named maps static image will get its constraints from the [view in the template](#Arguments), if `view` is not present it will estimate the extent based on the involved tables otherwise it fallback to `"zoom": 1`, `"lng": 0` and `"lat": 0`.
+
+#### Layers
+
+The Static Maps API allows for multiple layers of incorporation into the `MapConfig` to allow for maximum versatility in creating a static map. The examples below were used to generate the static image example in the next section, and appear in the specific order designated.
+
+**Basemaps**
+
+```javascript
+{
+  "type": "http",
+  "options": {
+    "urlTemplate": "http://{s}.basemaps.cartocdn.com/dark_nolabels/{z}/{x}/{y}.png",
+    "subdomains": [
+      "a",
+      "b",
+      "c"
+    ]
+  }
+}
+```
+
+By manipulating the `"urlTemplate"` custom basemaps can be used in generating static images. Supported map types for the Static Maps API are:
+
+```javascript
+'http://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png',
+'http://{s}.basemaps.cartocdn.com/dark_nolabels/{z}/{x}/{y}.png',
+'http://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png',
+'http://{s}.basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}.png',
+```
+
+**Mapnik**
+
+```javascript
+{
+  "type": "mapnik",
+  "options": {
+    "sql": "select null::geometry the_geom_webmercator",
+    "cartocss": "#layer {\n\tpolygon-fill: #FF3300;\n\tpolygon-opacity: 0;\n\tline-color: #333;\n\tline-width: 0;\n\tline-opacity: 0;\n}",
+    "cartocss_version": "2.2.0"
+  }
+},
+```
+
+**CartoDB**
+
+As described in the [MapConfig File Format](http://docs.cartodb.com/cartodb-platform/maps-api/mapconfig/), a "cartodb" type layer is now just an alias to a "mapnik" type layer as above, intended for backwards compatibility.
+
+```javascript
+{
+  "type": "cartodb",
+  "options": {
+    "sql": "select * from park",
+    "cartocss": "/** simple visualization */\n\n#park{\n  polygon-fill: #229A00;\n  polygon-opacity: 0.7;\n  line-color: #FFF;\n  line-width: 0;\n  line-opacity: 1;\n}",
+    "cartocss_version": "2.1.1"
+  }
+}
+```
+
+Additionally, static images from Torque maps and other map layers can be used together to generate highly customizable and versatile static maps.
+
+
+### Caching
+
+It is important to note that generated images are cached from the live data referenced with the `layergroupid token` on the specified CartoDB account. This means that if the data changes, the cached image will also change. When linking dynamically, it is important to take into consideration the state of the data and longevity of the static image to avoid broken images or changes in how the image is displayed. To obtain a static snapshot of the map as it is today and preserve the image long-term regardless of changes in data, the image must be saved and stored locally.
+
+### Limits
+
+* While images can encompass an entirety of a map, the default limit for pixel range is 8192 x 8192.
+* Image resolution by default is set to 72 DPI
+* JPEG quality by default is 85%
+* Timeout limits for generating static maps are the same across the CartoDB Editor and Platform. It is important to ensure timely processing of queries.
+
+## Examples
+
+After instantiating a map from a CartoDB account:
+
+#### Call
+
+```bash
+ GET /api/v1/map/static/center/4b615ff367e498e770e7d05e99181873:1420231989550.8699/14/40.71502926732618/-73.96039009094238/600/400.png
+```
+
+#### Response
+
+<p class="wrap-border"><img src="https://raw.githubusercontent.com/namessanti/Pictures/master/static_api.png" alt="static-api"/></p>
+
+### MapConfig
+
+For this map, the multiple layers, order, and stylings are defined by the MapConfig.
+
+```javascript
+{
+  "version": "1.3.0",
+  "layers": [
+    {
+      "type": "http",
+      "options": {
+        "urlTemplate": "http://{s}.basemaps.cartocdn.com/dark_nolabels/{z}/{x}/{y}.png",
+        "subdomains": [
+          "a",
+          "b",
+          "c"
+        ]
+      }
+    },
+    {
+      "type": "mapnik",
+      "options": {
+        "sql": "select null::geometry the_geom_webmercator",
+        "cartocss": "#layer {\n\tpolygon-fill: #FF3300;\n\tpolygon-opacity: 0;\n\tline-color: #333;\n\tline-width: 0;\n\tline-opacity: 0;\n}",
+        "cartocss_version": "2.2.0"
+      }
+    },
+    {
+      "type": "cartodb",
+      "options": {
+        "sql": "select * from park",
+        "cartocss": "/** simple visualization */\n\n#park{\n  polygon-fill: #229A00;\n  polygon-opacity: 0.7;\n  line-color: #FFF;\n  line-width: 0;\n  line-opacity: 1;\n}",
+        "cartocss_version": "2.1.1"
+      }
+    },
+    {
+      "type": "cartodb",
+      "options": {
+        "sql": "select * from residential_zoning_2009",
+        "cartocss": "/** simple visualization */\n\n#residential_zoning_2009{\n  polygon-fill: #c7eae5;\n  polygon-opacity: 1;\n  line-color: #FFF;\n  line-width: 0.2;\n  line-opacity: 0.5;\n}",
+        "cartocss_version": "2.1.1"
+      }
+    },
+    {
+      "type": "cartodb",
+      "options": {
+        "sql": "select * from nycha_developments_july2011",
+        "cartocss": "/** simple visualization */\n\n#nycha_developments_july2011{\n  polygon-fill: #ef3b2c;\n  polygon-opacity: 0.7;\n  line-color: #FFF;\n  line-width: 0;\n  line-opacity: 1;\n}",
+        "cartocss_version": "2.1.1"
+      }
+    }
+  ]
+}
+```

lib/cartodb/api/auth_api.js

@@ -0,0 +1,141 @@
+var assert = require('assert');
+var step = require('step');
+
+/**
+ *
+ * @param {PgConnection} pgConnection
+ * @param metadataBackend
+ * @param {MapStore} mapStore
+ * @param {TemplateMaps} templateMaps
+ * @constructor
+ * @type {AuthApi}
+ */
+function AuthApi(pgConnection, metadataBackend, mapStore, templateMaps) {
+    this.pgConnection = pgConnection;
+    this.metadataBackend = metadataBackend;
+    this.mapStore = mapStore;
+    this.templateMaps = templateMaps;
+}
+
+module.exports = AuthApi;
+
+// Check if a request is authorized by a signer
+//
+// @param req express request object
+// @param callback function(err, signed_by) signed_by will be
+//                 null if the request is not signed by anyone
+//                 or will be a string cartodb username otherwise.
+//
+AuthApi.prototype.authorizedBySigner = function(req, callback) {
+    if ( ! req.params.token || ! req.params.signer ) {
+        return callback(null, false); // no signer requested
+    }
+
+    var self = this;
+
+    var layergroup_id = req.params.token;
+    var auth_token = req.params.auth_token;
+
+    this.mapStore.load(layergroup_id, function(err, mapConfig) {
+        if (err) {
+            return callback(err);
+        }
+
+        var authorized = self.templateMaps.isAuthorized(mapConfig.obj().template, auth_token);
+
+        return callback(null, authorized);
+    });
+};
+
+// Check if a request is authorized by api_key
+//
+// @param user
+// @param req express request object
+// @param callback function(err, authorized)
+//        NOTE: authorized is expected to be 0 or 1 (integer)
+//
+AuthApi.prototype.authorizedByAPIKey = function(user, req, callback) {
+    var givenKey = req.query.api_key || req.query.map_key;
+    if ( ! givenKey && req.body ) {
+        // check also in request body
+        givenKey = req.body.api_key || req.body.map_key;
+    }
+    if ( ! givenKey ) {
+        return callback(null, 0); // no api key, no authorization...
+    }
+
+    var self = this;
+
+    step(
+        function () {
+            self.metadataBackend.getUserMapKey(user, this);
+        },
+        function checkApiKey(err, val){
+            assert.ifError(err);
+            return val && givenKey === val;
+        },
+        function finish(err, authorized) {
+            callback(err, authorized);
+        }
+    );
+};
+
+/**
+ * Check access authorization
+ *
+ * @param req - standard req object. Importantly contains table and host information
+ * @param callback function(err, allowed) is access allowed not?
+ */
+AuthApi.prototype.authorize = function(req, callback) {
+    var self = this;
+    var user = req.context.user;
+
+    step(
+        function () {
+            self.authorizedByAPIKey(user, req, this);
+        },
+        function checkApiKey(err, authorized){
+            if (req.profiler) {
+                req.profiler.done('authorizedByAPIKey');
+            }
+            assert.ifError(err);
+
+            // if not authorized by api_key, continue
+            if (!authorized)  {
+                // not authorized by api_key, check if authorized by signer
+                return self.authorizedBySigner(req, this);
+            }
+
+            // authorized by api key, login as the given username and stop
+            self.pgConnection.setDBAuth(user, req.params, function(err) {
+                callback(err, true); // authorized (or error)
+            });
+        },
+        function checkSignAuthorized(err, authorized) {
+            if (err) {
+                return callback(err);
+            }
+
+            if ( ! authorized ) {
+                // request not authorized by signer.
+
+                // if no signer name was given, let dbparams and
+                // PostgreSQL do the rest.
+                //
+                if ( ! req.params.signer ) {
+                    return callback(null, true); // authorized so far
+                }
+
+                // if signer name was given, return no authorization
+                return callback(null, false);
+            }
+
+            self.pgConnection.setDBAuth(user, req.params, function(err) {
+                if (req.profiler) {
+                    req.profiler.done('setDBAuth');
+                }
+                callback(err, true); // authorized (or error)
+            });
+        }
+    );
+};

lib/cartodb/api/overviews_metadata_api.js

@@ -0,0 +1,44 @@
+function OverviewsMetadataApi(pgQueryRunner) {
+   this.pgQueryRunner = pgQueryRunner;
+}
+
+module.exports = OverviewsMetadataApi;
+
+// TODO: share this with QueryTablesApi? ... or maintain independence?
+var affectedTableRegexCache = {
+    bbox: /!bbox!/g,
+    scale_denominator: /!scale_denominator!/g,
+    pixel_width: /!pixel_width!/g,
+    pixel_height: /!pixel_height!/g
+};
+
+function prepareSql(sql) {
+    return sql
+        .replace(affectedTableRegexCache.bbox, 'ST_MakeEnvelope(0,0,0,0)')
+        .replace(affectedTableRegexCache.scale_denominator, '0')
+        .replace(affectedTableRegexCache.pixel_width, '1')
+        .replace(affectedTableRegexCache.pixel_height, '1')
+    ;
+}
+
+OverviewsMetadataApi.prototype.getOverviewsMetadata = function (username, sql, callback) {
+    var query = 'SELECT * FROM CDB_Overviews(CDB_QueryTablesText($windshaft$' + prepareSql(sql) + '$windshaft$))';
+    this.pgQueryRunner.run(username, query, function handleOverviewsRows(err, rows) {
+        if (err){
+            var msg = err.message ? err.message : err;
+            callback(new Error('could not get overviews metadata: ' + msg));
+            return;
+        }
+        var metadata = {};
+        rows.forEach(function(row) {
+            var table = row.base_table;
+            var table_metadata = metadata[table];
+            if ( !table_metadata ) {
+              table_metadata = metadata[table] = {};
+            }
+            table_metadata[row.z] = { table: row.overview_table };
+        });
+        return callback(null, metadata);
+    });
+
+};

lib/cartodb/api/query_tables_api.js

@@ -0,0 +1,96 @@
+function QueryTablesApi(pgQueryRunner) {
+    this.pgQueryRunner = pgQueryRunner;
+}
+
+var affectedTableRegexCache = {
+    bbox: /!bbox!/g,
+    scale_denominator: /!scale_denominator!/g,
+    pixel_width: /!pixel_width!/g,
+    pixel_height: /!pixel_height!/g
+};
+
+module.exports = QueryTablesApi;
+
+
+QueryTablesApi.prototype.getAffectedTablesInQuery = function (username, sql, callback) {
+    var query = 'SELECT CDB_QueryTablesText($windshaft$' + prepareSql(sql) + '$windshaft$)';
+
+    this.pgQueryRunner.run(username, query, function handleAffectedTablesInQueryRows (err, rows) {
+        if (err){
+            var msg = err.message ? err.message : err;
+            callback(new Error('could not fetch source tables: ' + msg));
+            return;
+        }
+
+        // This is an Array, so no need to split into parts
+        var tableNames = rows[0].cdb_querytablestext;
+        return callback(null, tableNames);
+    });
+};
+
+QueryTablesApi.prototype.getAffectedTablesAndLastUpdatedTime = function (username, sql, callback) {
+    var query = [
+        'WITH querytables AS (',
+            'SELECT * FROM CDB_QueryTablesText($windshaft$' + prepareSql(sql) + '$windshaft$) as tablenames',
+        ')',
+        'SELECT (SELECT tablenames FROM querytables), EXTRACT(EPOCH FROM max(updated_at)) as max',
+        'FROM CDB_TableMetadata m',
+        'WHERE m.tabname = any ((SELECT tablenames from querytables)::regclass[])'
+    ].join(' ');
+
+    this.pgQueryRunner.run(username, query, function handleAffectedTablesAndLastUpdatedTimeRows (err, rows) {
+        if (err || rows.length === 0) {
+            var msg = err.message ? err.message : err;
+            callback(new Error('could not fetch affected tables or last updated time: ' + msg));
+            return;
+        }
+
+        var result = rows[0];
+
+        // This is an Array, so no need to split into parts
+        var tableNames = result.tablenames;
+
+        var lastUpdatedTime = result.max || 0;
+
+        callback(null, {
+            affectedTables: tableNames,
+            lastUpdatedTime: lastUpdatedTime * 1000
+        });
+    });
+};
+
+QueryTablesApi.prototype.getLastUpdatedTime = function (username, tableNames, callback) {
+    if (!Array.isArray(tableNames) || tableNames.length === 0) {
+        return callback(null, 0);
+    }
+
+    var query = [
+        'SELECT EXTRACT(EPOCH FROM max(updated_at)) as max',
+        'FROM CDB_TableMetadata m WHERE m.tabname = any (ARRAY[',
+            tableNames.map(function(t) { return "'" + t + "'::regclass"; }).join(','),
+        '])'
+    ].join(' ');
+
+    this.pgQueryRunner.run(username, query, function handleLastUpdatedTimeRows (err, rows) {
+        if (err) {
+            var msg = err.message ? err.message : err;
+            return callback(new Error('could not fetch affected tables or last updated time: ' + msg));
+        }
+        // when the table has not updated_at means it hasn't been changed so a default last_updated is set
+        var lastUpdated = 0;
+        if (rows.length !== 0) {
+            lastUpdated = rows[0].max || 0;
+        }
+
+        return callback(null, lastUpdated*1000);
+    });
+};
+
+function prepareSql(sql) {
+    return sql
+        .replace(affectedTableRegexCache.bbox, 'ST_MakeEnvelope(0,0,0,0)')
+        .replace(affectedTableRegexCache.scale_denominator, '0')
+        .replace(affectedTableRegexCache.pixel_width, '1')
+        .replace(affectedTableRegexCache.pixel_height, '1')
+    ;
+}

lib/cartodb/api/tables_extent_api.js

@@ -0,0 +1,51 @@
+function TablesExtentApi(pgQueryRunner) {
+    this.pgQueryRunner = pgQueryRunner;
+}
+
+module.exports = TablesExtentApi;
+
+/**
+ * Given a username and a list of tables it will return the estimated extent in SRID 4326 for all the tables based on
+ * the_geom_webmercator (SRID 3857) column.
+ *
+ * @param {String} username
+ * @param {Array} tableNames The named can be schema qualified, so this accepts both `schema_name.table_name` and
+ *  `table_name` format as valid input
+ * @param {Function} callback function(err, result) {Object} result with `west`, `south`, `east`, `north`
+ */
+TablesExtentApi.prototype.getBounds = function (username, tableNames, callback) {
+    var estimatedExtentSQLs = tableNames.map(function(tableName) {
+        var schemaTable = tableName.split('.');
+        if (schemaTable.length > 1) {
+            return "ST_EstimatedExtent('" + schemaTable[0] + "', '" + schemaTable[1] + "', 'the_geom_webmercator')";
+        }
+        return "ST_EstimatedExtent('" + schemaTable[0] + "', 'the_geom_webmercator')";
+    });
+
+    var query = [
+        "WITH ext as (" +
+            "SELECT ST_Transform(ST_SetSRID(ST_Extent(ST_Union(ARRAY[",
+                estimatedExtentSQLs.join(','),
+            "])), 3857), 4326) geom)",
+        "SELECT",
+            "ST_XMin(geom) west,",
+            "ST_YMin(geom) south,",
+            "ST_XMax(geom) east,",
+            "ST_YMax(geom) north",
+        "FROM ext"
+    ].join(' ');
+
+    this.pgQueryRunner.run(username, query, function handleBoundsResult (err, rows) {
+        if (err) {
+            var msg = err.message ? err.message : err;
+            return callback(new Error('could not fetch source tables: ' + msg));
+        }
+        var result = null;
+        if (rows.length > 0) {
+            result = {
+                bounds: rows[0]
+            };
+        }
+        callback(null, result);
+    });
+};

lib/cartodb/api/user_limits_api.js

@@ -0,0 +1,28 @@
+/**
+ *
+ * @param metadataBackend
+ * @param options
+ * @constructor
+ * @type {UserLimitsApi}
+ */
+function UserLimitsApi(metadataBackend, options) {
+    this.metadataBackend = metadataBackend;
+    this.options = options || {};
+    this.options.limits = this.options.limits || {};
+}
+
+module.exports = UserLimitsApi;
+
+UserLimitsApi.prototype.getRenderLimits = function (username, callback) {
+    var self = this;
+    this.metadataBackend.getTilerRenderLimit(username, function handleTilerLimits(err, renderLimit) {
+        if (err) {
+            return callback(err);
+        }
+
+        return callback(null, {
+            cacheOnTimeout: self.options.limits.cacheOnTimeout || false,
+            render: renderLimit || self.options.limits.render || 0
+        });
+    });
+};

lib/cartodb/backends/pg_connection.js

@@ -0,0 +1,101 @@
+var assert = require('assert');
+var step = require('step');
+var _ = require('underscore');
+
+function PgConnection(metadataBackend) {
+    this.metadataBackend = metadataBackend;
+}
+
+module.exports = PgConnection;
+
+
+// Set db authentication parameters to those of the given username
+//
+// @param username the cartodb username, mapped to a database username
+//                 via CartodbRedis metadata records
+//
+// @param params the parameters to set auth options into
+//               added params are: "dbuser" and "dbpassword"
+//
+// @param callback function(err)
+//
+PgConnection.prototype.setDBAuth = function(username, params, callback) {
+    var self = this;
+
+    var user_params = {};
+    var auth_user = global.environment.postgres_auth_user;
+    var auth_pass = global.environment.postgres_auth_pass;
+    step(
+        function getId() {
+            self.metadataBackend.getUserId(username, this);
+        },
+        function(err, user_id) {
+            assert.ifError(err);
+            user_params.user_id = user_id;
+            var dbuser = _.template(auth_user, user_params);
+            _.extend(params, {dbuser:dbuser});
+
+            // skip looking up user_password if postgres_auth_pass
+            // doesn't contain the "user_password" label
+            if (!auth_pass || ! auth_pass.match(/\buser_password\b/) ) {
+                return null;
+            }
+
+            self.metadataBackend.getUserDBPass(username, this);
+        },
+        function(err, user_password) {
+            assert.ifError(err);
+            user_params.user_password = user_password;
+            if ( auth_pass ) {
+                var dbpass = _.template(auth_pass, user_params);
+                _.extend(params, {dbpassword:dbpass});
+            }
+            return true;
+        },
+        function finish(err) {
+            callback(err);
+        }
+    );
+};
+
+// Set db connection parameters to those for the given username
+//
+// @param dbowner cartodb username of database owner,
+//                mapped to a database username
+//                via CartodbRedis metadata records
+//
+// @param params the parameters to set connection options into
+//               added params are: "dbname", "dbhost"
+//
+// @param callback function(err)
+//
+PgConnection.prototype.setDBConn = function(dbowner, params, callback) {
+    var self = this;
+    // Add default database connection parameters
+    // if none given
+    _.defaults(params, {
+        dbuser: global.environment.postgres.user,
+        dbpassword: global.environment.postgres.password,
+        dbhost: global.environment.postgres.host,
+        dbport: global.environment.postgres.port
+    });
+    step(
+        function getConnectionParams() {
+            self.metadataBackend.getUserDBConnectionParams(dbowner, this);
+        },
+        function extendParams(err, dbParams){
+            assert.ifError(err);
+            // we don't want null values or overwrite a non public user
+            if (params.dbuser !== 'publicuser' || !dbParams.dbuser) {
+                delete dbParams.dbuser;
+            }
+            if ( dbParams ) {
+                _.extend(params, dbParams);
+            }
+            return null;
+        },
+        function finish(err) {
+            callback(err);
+        }
+    );
+};

lib/cartodb/backends/pg_query_runner.js

@@ -0,0 +1,46 @@
+var assert = require('assert');
+var PSQL = require('cartodb-psql');
+var step = require('step');
+
+function PgQueryRunner(pgConnection) {
+    this.pgConnection = pgConnection;
+}
+
+module.exports = PgQueryRunner;
+
+/**
+ * Runs `query` with `username`'s PostgreSQL role, callback receives error and rows array.
+ *
+ * @param {String} username
+ * @param {String} query
+ * @param {Function} callback function({Error}, {Array}) second argument is guaranteed to be an array
+ */
+PgQueryRunner.prototype.run = function(username, query, callback) {
+    var self = this;
+
+    var params = {};
+
+    step(
+        function setAuth() {
+            self.pgConnection.setDBAuth(username, params, this);
+        },
+        function setConn(err) {
+            assert.ifError(err);
+            self.pgConnection.setDBConn(username, params, this);
+        },
+        function executeQuery(err) {
+            assert.ifError(err);
+            var psql = new PSQL({
+                user: params.dbuser,
+                pass: params.dbpass,
+                host: params.dbhost,
+                port: params.dbport,
+                dbname: params.dbname
+            });
+            psql.query(query, function(err, resultSet) {
+                resultSet = resultSet || {};
+                return callback(err, resultSet.rows || []);
+            });
+        }
+    );
+};

lib/cartodb/backends/template_maps.js

@@ -0,0 +1,515 @@
+var assert = require('assert');
+var crypto = require('crypto');
+var debug = require('debug')('windshaft:templates');
+var step = require('step');
+var _ = require('underscore');
+var dot = require('dot');
+
+
+var EventEmitter = require('events').EventEmitter;
+var util = require('util');
+
+
+// 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 opts TemplateMap options. Supported elements:
+//    'max_user_templates' limit on the number of per-user
+//
+//
+function TemplateMaps(redis_pool, opts) {
+  if (!(this instanceof TemplateMaps)) {
+      return new TemplateMaps();
+  }
+
+  EventEmitter.call(this);
+
+  this.redis_pool = redis_pool;
+  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
+
+  // User templates (HASH:tpl_id->tpl_val)
+  this.key_usr_tpl = dot.template("map_tpl|{{=it.owner}}");
+}
+
+util.inherits(TemplateMaps, EventEmitter);
+
+module.exports = TemplateMaps;
+
+
+var o = TemplateMaps.prototype;
+
+//--------------- PRIVATE METHODS --------------------------------
+
+o._userTemplateLimit = function() {
+  return this.opts.max_user_templates || 0;
+};
+
+/**
+ * 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) {
+      assert.ifError(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);
+    }
+  );
+};
+
+var _reValidNameIdentifier = /^[a-z0-9][0-9a-z_\-]*$/i;
+var _reValidPlaceholderIdentifier = /^[a-z][0-9a-z_]*$/i;
+// jshint maxcomplexity:15
+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(_reValidNameIdentifier) ) {
+    return new Error("Invalid characters in template name '" + tplname + "'");
+  }
+
+  var invalidError = isInvalidLayergroup(template.layergroup);
+  if (invalidError) {
+    return invalidError;
+  }
+
+  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(_reValidPlaceholderIdentifier)) {
+          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 + "'");
+      }
+  }
+
+    var auth = template.auth || {};
+
+    switch ( auth.method ) {
+        case 'open':
+            break;
+        case 'token':
+            if ( ! _.isArray(auth.valid_tokens) ) {
+                return new Error("Invalid 'token' authentication: missing valid_tokens");
+            }
+            if ( ! auth.valid_tokens.length ) {
+                return new Error("Invalid 'token' authentication: no valid_tokens");
+            }
+            break;
+        default:
+            return new Error("Unsupported authentication method: " + auth.method);
+    }
+
+    return false;
+};
+
+function isInvalidLayergroup(layergroup) {
+    if (!layergroup) {
+        return new Error('Missing layergroup');
+    }
+
+    var layers = layergroup.layers;
+
+    if (!_.isArray(layers) || layers.length === 0) {
+        return new Error('Missing or empty layers array from layergroup config');
+    }
+
+    var invalidLayers = layers
+        .map(function(layer, layerIndex) {
+            return layer.options ? null : layerIndex;
+        })
+        .filter(function(layerIndex) {
+            return layerIndex !== null;
+        });
+
+    if (invalidLayers.length) {
+        return new Error('Missing `options` in layergroup config for layers: ' + invalidLayers.join(', '));
+    }
+
+    return false;
+}
+
+function templateDefaults(template) {
+    var templateAuth = _.defaults({}, template.auth || {}, {
+        method: 'open'
+    });
+    return _.defaults({ auth: templateAuth }, template, {
+        placeholders: {}
+    });
+}
+
+//--------------- PUBLIC API -------------------------------------
+
+// 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 self = this;
+
+    template = templateDefaults(template);
+
+    var invalidError = this._checkInvalidTemplate(template);
+    if ( invalidError ) {
+        return callback(invalidError);
+    }
+
+    var templateName = template.name;
+    var userTemplatesKey = this.key_usr_tpl({ owner:owner });
+    var limit = this._userTemplateLimit();
+
+    step(
+        function checkLimit() {
+            if ( ! limit ) {
+                return 0;
+            }
+            self._redisCmd('HLEN', [ userTemplatesKey ], this);
+        },
+        function installTemplateIfDoesNotExist(err, numberOfTemplates) {
+            assert.ifError(err);
+            if ( limit && numberOfTemplates >= limit ) {
+                var limitReachedError = new Error("User '" + owner + "' reached limit on number of templates (" +
+                    numberOfTemplates + "/" + limit + ")");
+                limitReachedError.http_status = 409;
+                throw limitReachedError;
+            }
+            self._redisCmd('HSETNX', [ userTemplatesKey, templateName, JSON.stringify(template) ], this);
+        },
+        function validateInstallation(err, wasSet) {
+            assert.ifError(err);
+            if ( ! wasSet ) {
+                throw new Error("Template '" + templateName + "' of user '" + owner + "' already exists");
+            }
+
+            return true;
+        },
+        function finish(err) {
+            if (!err) {
+                self.emit('add', owner, templateName, template);
+            }
+
+            callback(err, templateName, template);
+        }
+  );
+};
+
+// Delete a template
+//
+// @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 self = this;
+    step(
+        function deleteTemplate() {
+            self._redisCmd('HDEL', [ self.key_usr_tpl({ owner:owner }), tpl_id ], this);
+        },
+        function handleDeletion(err, deleted) {
+            assert.ifError(err);
+            if (!deleted) {
+                throw new Error("Template '" + tpl_id + "' of user '" + owner + "' does not exist");
+            }
+            return true;
+        },
+        function finish(err) {
+            if (!err) {
+                self.emit('delete', owner, tpl_id);
+            }
+
+            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 self = this;
+
+    template = templateDefaults(template);
+
+    var invalidError = this._checkInvalidTemplate(template);
+
+    if ( invalidError ) {
+        return callback(invalidError);
+    }
+
+    var templateName = template.name;
+
+    if ( tpl_id !== templateName ) {
+        return callback(new Error("Cannot update name of a map template ('" + tpl_id + "' != '" + templateName + "')"));
+    }
+
+    var userTemplatesKey = this.key_usr_tpl({ owner:owner });
+
+    var previousTemplate = null;
+
+    step(
+        function getExistingTemplate() {
+            self._redisCmd('HGET', [ userTemplatesKey, tpl_id ], this);
+        },
+        function updateTemplate(err, _currentTemplate) {
+            assert.ifError(err);
+            if (!_currentTemplate) {
+                throw new Error("Template '" + tpl_id + "' of user '" + owner + "' does not exist");
+            }
+            previousTemplate = _currentTemplate;
+            self._redisCmd('HSET', [ userTemplatesKey, templateName, JSON.stringify(template) ], this);
+        },
+        function handleTemplateUpdate(err, didSetNewField) {
+            assert.ifError(err);
+            if (didSetNewField) {
+                debug('New template created on update operation');
+            }
+            return true;
+        },
+        function finish(err) {
+            if (!err) {
+                if (self.fingerPrint(JSON.parse(previousTemplate)) !== self.fingerPrint(template)) {
+                    self.emit('update', owner, templateName, template);
+                }
+            }
+
+            callback(err, template);
+        }
+    );
+};
+
+// 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 self = this;
+    step(
+        function getTemplate() {
+            self._redisCmd('HGET', [ self.key_usr_tpl({owner:owner}), tpl_id ], this);
+        },
+        function parseTemplate(err, tpl_val) {
+            assert.ifError(err);
+            return JSON.parse(tpl_val);
+        },
+        function finish(err, tpl) {
+            callback(err, tpl);
+        }
+    );
+};
+
+o.isAuthorized = function(template, authTokens) {
+    if (!template) {
+        return false;
+    }
+
+    authTokens = _.isArray(authTokens) ? authTokens : [authTokens];
+
+    var templateAuth = template.auth;
+
+    if (!templateAuth) {
+        return false;
+    }
+
+    if (_.isString(templateAuth) && templateAuth === 'open') {
+        return true;
+    }
+
+    if (templateAuth.method === 'open') {
+        return true;
+    }
+
+    if (templateAuth.method === 'token') {
+        return _.intersection(templateAuth.valid_tokens, authTokens).length > 0;
+    }
+
+    return false;
+};
+
+// 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}$/;
+
+function _replaceVars (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 ?
+  }
+
+  // extra information about the template
+  layergroup.template = {
+    name: template.name,
+    auth: template.auth
+  };
+
+  return layergroup;
+};
+
+// Return a fingerPrint of the object
+o.fingerPrint = function(template) {
+  return crypto.createHash('md5')
+    .update(JSON.stringify(template))
+    .digest('hex')
+  ;
+};
+
+module.exports.templateName = function templateName(templateId) {
+    var templateIdTokens = templateId.split('@');
+    var name = templateIdTokens[0];
+
+    if (templateIdTokens.length > 1) {
+        name = templateIdTokens[1];
+    }
+
+    return name;
+};

lib/cartodb/cache/backend/fastly.js

@@ -0,0 +1,16 @@
+var FastlyPurge = require('fastly-purge');
+
+function FastlyCacheBackend(apiKey, serviceId) {
+    this.serviceId = serviceId;
+    this.fastlyPurge = new FastlyPurge(apiKey, { softPurge: false });
+}
+
+module.exports = FastlyCacheBackend;
+
+/**
+ * @param cacheObject should respond to `key() -> String` method
+ * @param {Function} callback
+ */
+FastlyCacheBackend.prototype.invalidate = function(cacheObject, callback) {
+    this.fastlyPurge.key(this.serviceId, cacheObject.key(), callback);
+};

lib/cartodb/cache/backend/varnish_http.js

@@ -0,0 +1,30 @@
+var request = require('request');
+
+function VarnishHttpCacheBackend(host, port) {
+    this.host = host;
+    this.port = port;
+}
+
+module.exports = VarnishHttpCacheBackend;
+
+/**
+ * @param cacheObject should respond to `key() -> String` method
+ * @param {Function} callback
+ */
+VarnishHttpCacheBackend.prototype.invalidate = function(cacheObject, callback) {
+    request(
+        {
+            method: 'PURGE',
+            url: 'http://' + this.host + ':' + this.port + '/key',
+            headers: {
+                'Invalidation-Match': '\\b' + cacheObject.key() + '\\b'
+            }
+        },
+        function(err, response) {
+            if (err || response.statusCode !== 204) {
+                return callback(new Error('Unable to invalidate Varnish object'));
+            }
+            return callback(null);
+        }
+    );
+};

lib/cartodb/cache/layergroup_affected_tables.js

@@ -0,0 +1,24 @@
+var LruCache = require('lru-cache');
+
+function LayergroupAffectedTables() {
+    // dbname + layergroupId -> affected tables cache
+    this.cache = new LruCache({ max: 2000 });
+}
+
+module.exports = LayergroupAffectedTables;
+
+LayergroupAffectedTables.prototype.hasAffectedTables = function(dbName, layergroupId) {
+    return this.cache.has(createKey(dbName, layergroupId));
+};
+
+LayergroupAffectedTables.prototype.set = function(dbName, layergroupId, affectedTables) {
+    this.cache.set(createKey(dbName, layergroupId), affectedTables);
+};
+
+LayergroupAffectedTables.prototype.get = function(dbName, layergroupId) {
+    return this.cache.get(createKey(dbName, layergroupId));
+};
+
+function createKey(dbName, layergroupId) {
+    return dbName + ':' + layergroupId;
+}

lib/cartodb/cache/model/database_tables_entry.js

@@ -0,0 +1,24 @@
+var crypto = require('crypto');
+
+function DatabaseTables(dbName, tableNames) {
+    this.namespace = 't';
+    this.dbName = dbName;
+    this.tableNames = tableNames;
+}
+
+module.exports = DatabaseTables;
+
+
+DatabaseTables.prototype.key = function() {
+    return this.tableNames.map(function(tableName) {
+        return this.namespace + ':' + shortHashKey(this.dbName + ':' + tableName);
+    }.bind(this));
+};
+
+DatabaseTables.prototype.getCacheChannel = function() {
+    return this.dbName + ':' + this.tableNames.join(',');
+};
+
+function shortHashKey(target) {
+    return crypto.createHash('sha256').update(target).digest('base64').substring(0,6);
+}

lib/cartodb/cache/model/named_maps_entry.js

@@ -0,0 +1,18 @@
+var crypto = require('crypto');
+
+function NamedMaps(owner, name) {
+    this.namespace = 'n';
+    this.owner = owner;
+    this.name = name;
+}
+
+module.exports = NamedMaps;
+
+
+NamedMaps.prototype.key = function() {
+    return this.namespace + ':' + shortHashKey(this.owner + ':' + this.name);
+};
+
+function shortHashKey(target) {
+    return crypto.createHash('sha256').update(target).digest('base64').substring(0,6);
+}

lib/cartodb/cache/named_map_provider_cache.js

@@ -0,0 +1,88 @@
+var _ = require('underscore');
+var dot = require('dot');
+var NamedMapMapConfigProvider = require('../models/mapconfig/named_map_provider');
+var MapConfigNamedLayersAdapter = require('../models/mapconfig_named_layers_adapter');
+var templateName = require('../backends/template_maps').templateName;
+var queue = require('queue-async');
+
+var LruCache = require("lru-cache");
+
+function NamedMapProviderCache(templateMaps, pgConnection, userLimitsApi, queryTablesApi) {
+    this.templateMaps = templateMaps;
+    this.pgConnection = pgConnection;
+    this.userLimitsApi = userLimitsApi;
+    this.queryTablesApi = queryTablesApi;
+
+    this.namedLayersAdapter = new MapConfigNamedLayersAdapter(templateMaps);
+
+    this.providerCache = new LruCache({ max: 2000 });
+}
+
+module.exports = NamedMapProviderCache;
+
+NamedMapProviderCache.prototype.get = function(user, templateId, config, authToken, params, callback) {
+    var namedMapKey = createNamedMapKey(user, templateId);
+    var namedMapProviders = this.providerCache.get(namedMapKey) || {};
+
+    var providerKey = createProviderKey(config, authToken, params);
+    if (!namedMapProviders.hasOwnProperty(providerKey)) {
+        namedMapProviders[providerKey] = new NamedMapMapConfigProvider(
+            this.templateMaps,
+            this.pgConnection,
+            this.userLimitsApi,
+            this.queryTablesApi,
+            this.namedLayersAdapter,
+            user,
+            templateId,
+            config,
+            authToken,
+            params
+        );
+        this.providerCache.set(namedMapKey, namedMapProviders);
+
+        // early exit, if provider did not exist we just return it
+        return callback(null, namedMapProviders[providerKey]);
+    }
+
+    var namedMapProvider = namedMapProviders[providerKey];
+
+    var self = this;
+    queue(2)
+        .defer(namedMapProvider.getTemplate.bind(namedMapProvider))
+        .defer(this.templateMaps.getTemplate.bind(this.templateMaps), user, templateId)
+        .awaitAll(function templatesQueueDone(err, results) {
+            if (err) {
+                return callback(err);
+            }
+
+            // We want to reset provider its template has changed
+            // Ideally this should be done in a passive mode where this cache gets notified of template changes
+            var uniqueFingerprints = _.uniq(results.map(self.templateMaps.fingerPrint)).length;
+            if (uniqueFingerprints > 1) {
+                namedMapProvider.reset();
+            }
+            return callback(null, namedMapProvider);
+        });
+};
+
+NamedMapProviderCache.prototype.invalidate = function(user, templateId) {
+    this.providerCache.del(createNamedMapKey(user, templateId));
+};
+
+function createNamedMapKey(user, templateId) {
+    return user + ':' + templateName(templateId);
+}
+
+var providerKey = '{{=it.authToken}}:{{=it.configHash}}:{{=it.format}}:{{=it.layer}}:{{=it.scale_factor}}';
+var providerKeyTpl = dot.template(providerKey);
+
+function createProviderKey(config, authToken, params) {
+    var tplValues = _.defaults({}, params, {
+        authToken: authToken || '',
+        configHash: NamedMapMapConfigProvider.configHash(config),
+        layer: '',
+        format: '',
+        scale_factor: 1
+    });
+    return providerKeyTpl(tplValues);
+}

lib/cartodb/cache/surrogate_keys_cache.js

@@ -0,0 +1,53 @@
+var queue = require('queue-async');
+
+/**
+ * @param {Array|Object} cacheBackends each backend backend should respond to `invalidate(cacheObject, callback)` method
+ * @constructor
+ */
+function SurrogateKeysCache(cacheBackends) {
+    this.cacheBackends = Array.isArray(cacheBackends) ? cacheBackends : [cacheBackends];
+}
+
+module.exports = SurrogateKeysCache;
+
+
+/**
+ * @param response should respond to `header(key, value)` method
+ * @param cacheObject should respond to `key() -> String` method
+ */
+SurrogateKeysCache.prototype.tag = function(response, cacheObject) {
+    var newKey = cacheObject.key();
+    response.set('Surrogate-Key', appendSurrogateKey(
+        response.get('Surrogate-Key'),
+        Array.isArray(newKey) ? cacheObject.key().join(' ') : newKey
+    ));
+
+};
+
+function appendSurrogateKey(currentKey, newKey) {
+    if (!!currentKey) {
+        newKey = currentKey + ' ' + newKey;
+    }
+    return newKey;
+}
+
+/**
+ * @param cacheObject should respond to `key() -> String` method
+ * @param {Function} callback
+ */
+SurrogateKeysCache.prototype.invalidate = function(cacheObject, callback) {
+    var invalidationQueue = queue(this.cacheBackends.length);
+
+    this.cacheBackends.forEach(function(cacheBackend) {
+        invalidationQueue.defer(function(cacheBackend, done) {
+            cacheBackend.invalidate(cacheObject, done);
+        }, cacheBackend);
+    });
+
+    invalidationQueue.awaitAll(function(err, result) {
+        if (err) {
+            return callback(err);
+        }
+        callback(null, result);
+    });
+};

lib/cartodb/cache_validator.js

@@ -1,21 +0,0 @@
-var _             = require('underscore'),
-    Varnish       = require('node-varnish'),
-    varnish_queue = null;
-
-function init(host, port) {
-    varnish_queue = new Varnish.VarnishQueue(host, port);
-}
-
-function invalidate_db(dbname, table) {
-    try{
-        varnish_queue.run_cmd('purge obj.http.X-Cache-Channel ~ "^' + dbname + ':(.*'+ table +'.*)|(table)$"');
-        console.log('[SUCCESS FLUSHING CACHE]');
-    } catch (e) {
-        console.log("[ERROR FLUSHING CACHE] Is enable_cache set to true? Failed for: " + 'purge obj.http.X-Cache-Channel ~ "^' + dbname + ':(.*'+ table +'.*)|(table)$"');
-    }
-}
-
-module.exports = {
-    init: init,
-    invalidate_db: invalidate_db
-}

lib/cartodb/cartodb_windshaft.js

@@ -1,546 +0,0 @@
-
-var _ = require('underscore')
-    , Step       = require('step')
-    , Windshaft = require('windshaft')
-    , redisPool = new require('redis-mpool')(global.environment.redis)
-    // TODO: instanciate cartoData with redisPool
-    , cartoData  = require('cartodb-redis')(global.environment.redis)
-    , SignedMaps = require('./signed_maps.js')
-    , TemplateMaps = require('./template_maps.js')
-    , Cache = require('./cache_validator');
-
-var CartodbWindshaft = function(serverOptions) {
-
-    if(serverOptions.cache_enabled) {
-        console.log("cache invalidation enabled, varnish on ", serverOptions.varnish_host, ' ', serverOptions.varnish_port);
-        Cache.init(serverOptions.varnish_host, serverOptions.varnish_port);
-        serverOptions.afterStateChange = function(req, data, callback) {
-            Cache.invalidate_db(req.params.dbname, req.params.table);
-            callback(null, data);
-        }
-    }
-
-    serverOptions.beforeStateChange = function(req, callback) {
-        var err = null;
-        if ( ! req.params.hasOwnProperty('dbuser') ) {
-          err = new Error("map state cannot be changed by unauthenticated request!");
-        }
-        callback(err, req);
-    }
-
-    serverOptions.signedMaps = new SignedMaps(redisPool);
-    var templateMaps = new TemplateMaps(redisPool, serverOptions.signedMaps);
-
-    // boot
-    var ws = new Windshaft.Server(serverOptions);
-
-    // Override getVersion to include cartodb-specific versions
-    var wsversion = ws.getVersion;
-    ws.getVersion = function() {
-      var version = wsversion();
-      version.windshaft_cartodb = require('../../package.json').version;
-      return version;
-    }
-
-    // Override sendError to drop added cache headers (if any)
-    // See http://github.com/CartoDB/Windshaft-cartodb/issues/107
-    var ws_sendError = ws.sendError;
-    ws.sendError = function(res) {
-      // NOTE: the "res" object will have no _headers when
-      //       faked by Windshaft, see
-      //       http://github.com/CartoDB/Windshaft-cartodb/issues/109
-      //
-      if ( res._headers ) {
-        delete res._headers['cache-control'];
-        delete res._headers['last-modified'];
-        delete res._headers['x-cache-channel'];
-      } 
-      ws_sendError.apply(this, arguments);
-    };
-
-    /**
-     * Helper to allow access to the layer to be used in the maps infowindow popup.
-     */
-    ws.get(serverOptions.base_url + '/infowindow', function(req, res){
-        ws.doCORS(res);
-        Step(
-            function(){
-                serverOptions.getInfowindow(req, this);
-            },
-            function(err, data){
-                if (err){
-                    ws.sendError(res, {error: err.message}, 500, 'GET INFOWINDOW');
-                    //res.send({error: err.message}, 500);
-                } else {
-                    res.send({infowindow: data}, 200);
-                }
-            }
-        );
-    });
-
-
-    /**
-     * Helper to allow access to metadata to be used in embedded maps.
-     */
-    ws.get(serverOptions.base_url + '/map_metadata', function(req, res){
-        ws.doCORS(res);
-        Step(
-            function(){
-                serverOptions.getMapMetadata(req, this);
-            },
-            function(err, data){
-                if (err){
-                    ws.sendError(res, {error: err.message}, 500, 'GET MAP_METADATA');
-                    //res.send(err.message, 500);
-                } else {
-                    res.send({map_metadata: data}, 200);
-                }
-            }
-        );
-    });
-
-    /**
-     * Helper API to allow per table tile cache (and sql cache) to be invalidated remotely.
-     * TODO: Move?
-     */
-    ws.del(serverOptions.base_url + '/flush_cache', function(req, res){
-        ws.doCORS(res);
-        Step(
-            function flushCache(){
-                serverOptions.flushCache(req, serverOptions.cache_enabled ? Cache : null, this);
-            },
-            function sendResponse(err, data){
-                if (err){
-                    ws.sendError(res, {error: err.message}, 500, 'DELETE CACHE');
-                    //res.send(500);
-                } else {
-                    res.send({status: 'ok'}, 200);
-                }
-            }
-        );
-    });
-
-    // ---- Template maps interface starts @{
-
-    ws.userByReq = function(req) {
-        return serverOptions.userByReq(req);
-    }
-
-    var template_baseurl = serverOptions.base_url_notable + '/template';
-
-    // Add a template
-    ws.post(template_baseurl, function(req, res) {
-      ws.doCORS(res);
-      var that = this;
-      var response = {};
-      var cdbuser = ws.userByReq(req);
-      Step(
-        function checkPerms(){
-            serverOptions.authorizedByAPIKey(req, this);
-        },
-        function addTemplate(err, authenticated) {
-          if ( err ) throw err;
-          if (authenticated !== 1) {
-            err = new Error("Only authenticated user can create templated maps");
-            err.http_status = 401;
-            throw err;
-          }
-          var next = this;
-          if ( ! req.headers['content-type'] || req.headers['content-type'].split(';')[0] != 'application/json' )
-            throw new Error('template POST data must be of type application/json');
-          var cfg = req.body;
-          templateMaps.addTemplate(cdbuser, cfg, this);
-        },
-        function prepareResponse(err, tpl_id){
-          if ( err ) throw err;
-          // NOTE: might omit "cdbuser" if == dbowner ...
-          return { template_id: cdbuser + '@' + tpl_id };
-        },
-        function finish(err, response){
-            if (err){
-                response = { error: ''+err };
-                var statusCode = 400;
-                if ( ! _.isUndefined(err.http_status) ) {
-                  statusCode = err.http_status;
-                }
-                ws.sendError(res, response, statusCode, 'POST TEMPLATE', err.message);
-            } else {
-              res.send(response, 200);
-            }
-        }
-      );
-    });
-
-    // Update a template
-    ws.put(template_baseurl + '/:template_id', function(req, res) {
-      ws.doCORS(res);
-      var that = this;
-      var response = {};
-      var cdbuser = ws.userByReq(req);
-      var template;
-      var tpl_id;
-      Step(
-        function checkPerms(){
-            serverOptions.authorizedByAPIKey(req, this);
-        },
-        function updateTemplate(err, authenticated) {
-          if ( err ) throw err;
-          if (authenticated !== 1) {
-            err = new Error("Only authenticated user can list templated maps");
-            err.http_status = 401;
-            throw err;
-          }
-          if ( ! req.headers['content-type'] || req.headers['content-type'].split(';')[0] != 'application/json' )
-            throw new Error('template PUT data must be of type application/json');
-          template = req.body;
-          tpl_id = req.params.template_id.split('@');
-          if ( tpl_id.length > 1 ) {
-            if ( tpl_id[0] != cdbuser ) {
-              err = new Error("Invalid template id '"
-                + req.params.template_id + "' for user '" + cdbuser + "'");
-              err.http_status = 404;
-              throw err;
-            }
-            tpl_id = tpl_id[1];
-          }
-          templateMaps.updTemplate(cdbuser, tpl_id, template, this);
-        },
-        function prepareResponse(err){
-          if ( err ) throw err;
-          return { template_id: cdbuser + '@' + tpl_id };
-        },
-        function finish(err, response){
-            if (err){
-                var statusCode = 400;
-                response = { error: ''+err };
-                if ( ! _.isUndefined(err.http_status) ) {
-                  statusCode = err.http_status;
-                }
-                ws.sendError(res, response, statusCode, 'PUT TEMPLATE', err.message);
-            } else {
-              res.send(response, 200);
-            }
-        }
-      );
-    });
-
-    // Get a specific template
-    ws.get(template_baseurl + '/:template_id', function(req, res) {
-      ws.doCORS(res);
-      var that = this;
-      var response = {};
-      var cdbuser = ws.userByReq(req);
-      var template;
-      var tpl_id;
-      Step(
-        function checkPerms(){
-            serverOptions.authorizedByAPIKey(req, this);
-        },
-        function updateTemplate(err, authenticated) {
-          if ( err ) throw err;
-          if (authenticated !== 1) {
-            err = new Error("Only authenticated users can get template maps");
-            err.http_status = 401;
-            throw err;
-          }
-          tpl_id = req.params.template_id.split('@');
-          if ( tpl_id.length > 1 ) {
-            if ( tpl_id[0] != cdbuser ) {
-              var err = new Error("Cannot get template id '"
-                + req.params.template_id + "' for user '" + cdbuser + "'");
-              err.http_status = 404;
-              throw err;
-            }
-            tpl_id = tpl_id[1];
-          }
-          templateMaps.getTemplate(cdbuser, tpl_id, this);
-        },
-        function prepareResponse(err, tpl_val){
-          if ( err ) throw err;
-          if ( ! tpl_val ) {
-            err = new Error("Cannot find template '" + tpl_id + "' of user '" + cdbuser + "'");
-            err.http_status = 404;
-            throw err;
-          }
-          // auth_id was added by ourselves,
-          // so we remove it before returning to the user
-          delete tpl_val.auth_id;
-          return { template: tpl_val };
-        },
-        function finish(err, response){
-            if (err){
-                var statusCode = 400;
-                response = { error: ''+err };
-                if ( ! _.isUndefined(err.http_status) ) {
-                  statusCode = err.http_status;
-                }
-                ws.sendError(res, response, statusCode, 'GET TEMPLATE', err.message);
-            } else {
-              res.send(response, 200);
-            }
-        }
-      );
-    });
-
-    // Delete a specific template
-    ws.delete(template_baseurl + '/:template_id', function(req, res) {
-      ws.doCORS(res);
-      var that = this;
-      var response = {};
-      var cdbuser = ws.userByReq(req);
-      var template;
-      var tpl_id;
-      Step(
-        function checkPerms(){
-            serverOptions.authorizedByAPIKey(req, this);
-        },
-        function updateTemplate(err, authenticated) {
-          if ( err ) throw err;
-          if (authenticated !== 1) {
-            err = new Error("Only authenticated users can delete template maps");
-            err.http_status = 401;
-            throw err;
-          }
-          tpl_id = req.params.template_id.split('@');
-          if ( tpl_id.length > 1 ) {
-            if ( tpl_id[0] != cdbuser ) {
-              var err = new Error("Cannot find template id '"
-                + req.params.template_id + "' for user '" + cdbuser + "'");
-              err.http_status = 404;
-              throw err;
-            }
-            tpl_id = tpl_id[1];
-          }
-          templateMaps.delTemplate(cdbuser, tpl_id, this);
-        },
-        function prepareResponse(err, tpl_val){
-          if ( err ) throw err;
-          return { status: 'ok' };
-        },
-        function finish(err, response){
-            if (err){
-                var statusCode = 400;
-                response = { error: ''+err };
-                if ( ! _.isUndefined(err.http_status) ) {
-                  statusCode = err.http_status;
-                }
-                ws.sendError(res, response, statusCode, 'DELETE TEMPLATE', err.message);
-            } else {
-              res.send('', 204);
-            }
-        }
-      );
-    });
-
-    // Get a list of owned templates 
-    ws.get(template_baseurl, function(req, res) {
-      ws.doCORS(res);
-      var that = this;
-      var response = {};
-      var cdbuser = ws.userByReq(req);
-      Step(
-        function checkPerms(){
-            serverOptions.authorizedByAPIKey(req, this);
-        },
-        function listTemplates(err, authenticated) {
-          if ( err ) throw err;
-          if (authenticated !== 1) {
-            err = new Error("Only authenticated user can list templated maps");
-            err.http_status = 401;
-            throw err;
-          }
-          templateMaps.listTemplates(cdbuser, this);
-        },
-        function prepareResponse(err, tpl_ids){
-          if ( err ) throw err;
-          // NOTE: might omit "cbduser" if == dbowner ...
-          var ids = _.map(tpl_ids, function(id) { return cdbuser + '@' + id; })
-          return { template_ids: ids };
-        },
-        function finish(err, response){
-            var statusCode = 200;
-            if (err){
-                response = { error: ''+err };
-                if ( ! _.isUndefined(err.http_status) ) {
-                  statusCode = err.http_status;
-                }
-                ws.sendError(res, response, statusCode, 'GET TEMPLATE LIST', err.message);
-            } else {
-              res.send(response, statusCode);
-            }
-        }
-      );
-    });
-
-    ws.setDBParams = function(cdbuser, params, callback) {
-      Step(
-        function setAuth() {
-          serverOptions.setDBAuth(cdbuser, params, this);
-        },
-        function setConn(err) {
-          if ( err ) throw err;
-          serverOptions.setDBConn(cdbuser, params, this);
-        },
-        function finish(err) {
-          callback(err);
-        }
-      );
-    };
-
-    ws.options(template_baseurl + '/:template_id', function(req, res) {
-      ws.doCORS(res, "Content-Type");
-      return next();
-    });
-
-    // Instantiate a template
-    function instanciateTemplate(req, res, template_params, callback) {
-      ws.doCORS(res);
-      var that = this;
-      var response = {};
-      var template;
-      var signedMaps = serverOptions.signedMaps;
-      var layergroup;
-      var layergroupid;
-      var fakereq; // used for call to createLayergroup
-      var cdbuser = ws.userByReq(req);
-      // Format of template_id: [<template_owner>]@<template_id>
-      var tpl_id = req.params.template_id.split('@');
-      if ( tpl_id.length > 1 ) {
-        if ( tpl_id[0] ) cdbuser = tpl_id[0];
-        tpl_id = tpl_id[1];
-      }
-      var auth_token = req.query.auth_token;
-      Step(
-        function getTemplate(){
-          templateMaps.getTemplate(cdbuser, tpl_id, this);
-        },
-        function checkAuthorized(err, data) {
-          if ( err ) throw err;
-          if ( ! data ) {
-            err = new Error("Template '" + tpl_id + "' of user '" + cdbuser + "' not found");
-            err.http_status = 404;
-            throw err;
-          }
-          template = data;
-          var cert = templateMaps.getTemplateCertificate(template);
-          var authorized = false;
-          try {
-            // authorizedByCert will throw if unauthorized
-            authorized = signedMaps.authorizedByCert(cert, auth_token);
-          } catch (err) {
-            // we catch to add http_status
-            err.http_status = 401;
-            throw err;
-          }
-          if ( ! authorized ) {
-            err = new Error('Unauthorized template instanciation');
-            err.http_status = 401;
-            throw err;
-          }
-          /*if ( (! req.headers['content-type'] || req.headers['content-type'].split(';')[0] != 'application/json') && req.query.callback === undefined) {
-            throw new Error('template POST data must be of type application/json, it is instead ');
-          }*/
-          //var template_params = req.body;
-          return templateMaps.instance(template, template_params);
-        },
-        function prepareParams(err, instance){
-          if ( err ) throw err;
-          layergroup = instance;
-          fakereq = { query: {}, params: {}, headers: _.clone(req.headers) };
-          ws.setDBParams(cdbuser, fakereq.params, this);
-        },
-        function setApiKey(err){
-          if ( err ) throw err;
-          cartoData.getUserMapKey(cdbuser, this);
-        },
-        function createLayergroup(err, val) {
-          if ( err ) throw err;
-          fakereq.params.api_key = val;
-          ws.createLayergroup(layergroup, fakereq, this);
-        },
-        function signLayergroup(err, resp) {
-          if ( err ) throw err;
-          response = resp;
-          var signer = cdbuser;
-          var map_id = response.layergroupid.split(':')[0]; // dropping last_updated 
-          var crt_id = template.auth_id; // check ?
-          if ( ! crt_id ) {
-            var errmsg = "Template '" + tpl_id + "' of user '" + cdbuser + "' has no signature";
-            // Is this really illegal ?
-            // Maybe we could just return an unsigned layergroupid
-            // in this case...
-            err = new Error(errmsg);
-            err.http_status = 403; // Forbidden, we refuse to respond to this
-            throw err;
-          }
-          signedMaps.signMap(signer, map_id, crt_id, this);
-        },
-        function prepareResponse(err) {
-          if ( err ) throw err;
-          //console.log("Response from createLayergroup: "); console.dir(response);
-          // Add the signature part to the token!
-          response.layergroupid = cdbuser + '@' + response.layergroupid;
-          return response;
-        },
-        callback
-      );
-    }
-
-    function finish_instanciation(err, response, res) {
-        if (err) {
-            var statusCode = 400;
-            response = { error: ''+err };
-            if ( ! _.isUndefined(err.http_status) ) {
-              statusCode = err.http_status;
-            }
-            ws.sendError(res, response, statusCode, 'POST INSTANCE TEMPLATE', err.message);
-        } else {
-          res.send(response, 200);
-        }
-    }
-
-    ws.post(template_baseurl + '/:template_id', function(req, res) {
-      Step(
-        function() {
-          if ( ! req.headers['content-type'] || req.headers['content-type'].split(';')[0] != 'application/json') {
-            throw new Error('template POST data must be of type application/json, it is instead ');
-          }
-          instanciateTemplate(req, res, req.body, this);
-        }, function(err, response) {
-          finish_instanciation(err, response, res);
-        }
-      );
-    });
-
-    /**
-     * jsonp endpoint, allows to instanciate a template with a json call.
-     * callback query argument is mandartoy
-     */
-    ws.get(template_baseurl + '/:template_id/jsonp', function(req, res) {
-      Step(
-        function() {
-          if ( req.query.callback === undefined || req.query.callback.length === 0) {
-            throw new Error('callback parameter should be present and be a function name');
-          }
-          var config = {};
-          if(req.query.config) {
-            try {
-              config = JSON.parse(req.query.config);
-            } catch(e) {
-              throw new Error('badformed config parameter, should be a valid JSON');
-            }
-          }
-          instanciateTemplate(req, res, config, this);
-        }, function(err, response) {
-          finish_instanciation(err, response, res);
-        }
-      );
-    });
-
-
-    // ---- Template maps interface ends @}
-
-    return ws;
-}
-
-module.exports = CartodbWindshaft;

lib/cartodb/controllers/base.js

@@ -0,0 +1,263 @@
+var assert = require('assert');
+
+var _ = require('underscore');
+var step = require('step');
+var debug = require('debug')('windshaft:cartodb');
+
+var LZMA = require('lzma').LZMA;
+var lzmaWorker = new LZMA();
+
+// Whitelist query parameters and attach format
+var REQUEST_QUERY_PARAMS_WHITELIST = [
+    'config',
+    'map_key',
+    'api_key',
+    'auth_token',
+    'callback',
+    // widgets & filters
+    'filters', // json
+    'own_filter', // 0, 1
+    'bbox', // w,s,e,n
+    'bins', // number
+    'start', // number
+    'end', // number
+    'column_type', // string
+    // widgets search
+    'q'
+];
+
+function BaseController(authApi, pgConnection) {
+    this.authApi = authApi;
+    this.pgConnection = pgConnection;
+}
+
+module.exports = BaseController;
+
+// jshint maxcomplexity:9
+/**
+ * Whitelist input and get database name & default geometry type from
+ * subdomain/user metadata held in CartoDB Redis
+ * @param req - standard express request obj. Should have host & table
+ * @param callback
+ */
+BaseController.prototype.req2params = function(req, callback){
+    var self = this;
+
+    if ( req.query.lzma ) {
+
+        // Decode (from base64)
+        var lzma = new Buffer(req.query.lzma, 'base64')
+            .toString('binary')
+            .split('')
+            .map(function(c) {
+                return c.charCodeAt(0) - 128;
+            });
+
+
+        // Decompress
+        lzmaWorker.decompress(
+            lzma,
+            function(result) {
+                if (req.profiler) {
+                    req.profiler.done('lzma');
+                }
+                try {
+                    delete req.query.lzma;
+                    _.extend(req.query, JSON.parse(result));
+                    self.req2params(req, callback);
+                } catch (err) {
+                    req.profiler.done('req2params');
+                    callback(new Error('Error parsing lzma as JSON: ' + err));
+                }
+            }
+        );
+        return;
+    }
+
+    req.query = _.pick(req.query, REQUEST_QUERY_PARAMS_WHITELIST);
+    req.params = _.extend({}, req.params); // shuffle things as request is a strange array/object
+
+    var user = req.context.user;
+
+    if ( req.params.token ) {
+        // Token might match the following patterns:
+        // - {user}@{tpl_id}@{token}:{cache_buster}
+        var tksplit = req.params.token.split(':');
+        req.params.token = tksplit[0];
+        if ( tksplit.length > 1 ) {
+            req.params.cache_buster= tksplit[1];
+        }
+        tksplit = req.params.token.split('@');
+        if ( tksplit.length > 1 ) {
+            req.params.signer = tksplit.shift();
+            if ( ! req.params.signer ) {
+                req.params.signer = user;
+            }
+            else if ( req.params.signer !== user ) {
+                var err = new Error(
+                        'Cannot use map signature of user "' + req.params.signer + '" on db of user "' + user + '"'
+                );
+                err.http_status = 403;
+                req.profiler.done('req2params');
+                callback(err);
+                return;
+            }
+            if ( tksplit.length > 1 ) {
+                /*var template_hash = */tksplit.shift(); // unused
+            }
+            req.params.token = tksplit.shift();
+        }
+    }
+
+    // bring all query values onto req.params object
+    _.extend(req.params, req.query);
+
+    if (req.profiler) {
+        req.profiler.done('req2params.setup');
+    }
+
+    step(
+        function getPrivacy(){
+            self.authApi.authorize(req, this);
+        },
+        function validateAuthorization(err, authorized) {
+            if (req.profiler) {
+                req.profiler.done('authorize');
+            }
+            assert.ifError(err);
+            if(!authorized) {
+                err = new Error("Sorry, you are unauthorized (permission denied)");
+                err.http_status = 403;
+                throw err;
+            }
+            return null;
+        },
+        function getDatabase(err){
+            assert.ifError(err);
+            self.pgConnection.setDBConn(user, req.params, this);
+        },
+        function finishSetup(err) {
+            if ( err ) {
+                req.profiler.done('req2params');
+                return callback(err, req);
+            }
+
+            // Add default database connection parameters
+            // if none given
+            _.defaults(req.params, {
+                dbuser: global.environment.postgres.user,
+                dbpassword: global.environment.postgres.password,
+                dbhost: global.environment.postgres.host,
+                dbport: global.environment.postgres.port
+            });
+
+            req.profiler.done('req2params');
+            callback(null, req);
+        }
+    );
+};
+// jshint maxcomplexity:6
+
+// jshint maxcomplexity:9
+BaseController.prototype.send = function(req, res, body, status, headers) {
+    if (req.params.dbhost) {
+        res.set('X-Served-By-DB-Host', req.params.dbhost);
+    }
+
+    if (req.profiler) {
+        res.set('X-Tiler-Profiler', req.profiler.toJSONString());
+    }
+
+    if (headers) {
+        res.set(headers);
+    }
+
+    res.status(status);
+
+    if (!Buffer.isBuffer(body) && typeof body === 'object') {
+        if (req.query && req.query.callback) {
+            res.jsonp(body);
+        } else {
+            res.json(body);
+        }
+    } else {
+        res.send(body);
+    }
+
+    if (req.profiler) {
+        try {
+            // May throw due to dns, see
+            // See http://github.com/CartoDB/Windshaft/issues/166
+            req.profiler.sendStats();
+        } catch (err) {
+            debug("error sending profiling stats: " + err);
+        }
+    }
+};
+// jshint maxcomplexity:6
+
+BaseController.prototype.sendError = function(req, res, err, label) {
+    label = label || 'UNKNOWN';
+
+    var statusCode = findStatusCode(err);
+
+    debug('[%s ERROR] -- %d: %s, %s', label, statusCode, err, err.stack);
+
+    // If a callback was requested, force status to 200
+    if (req.query && req.query.callback) {
+        statusCode = 200;
+    }
+
+    var errorResponseBody = { errors: [errorMessage(err)] };
+
+    this.send(req, res, errorResponseBody, statusCode);
+};
+
+function errorMessage(err) {
+    // See https://github.com/Vizzuality/Windshaft-cartodb/issues/68
+    var message = (_.isString(err) ? err : err.message) || 'Unknown error';
+
+    // Strip connection info, if any
+    return message
+        // See https://github.com/CartoDB/Windshaft/issues/173
+        .replace(/Connection string: '[^']*'\n\s/im, '')
+        // See https://travis-ci.org/CartoDB/Windshaft/jobs/20703062#L1644
+        .replace(/is the server.*encountered/im, 'encountered');
+}
+module.exports.errorMessage = errorMessage;
+
+function findStatusCode(err) {
+    var statusCode;
+    if ( err.http_status ) {
+        statusCode = err.http_status;
+    } else {
+        statusCode = statusFromErrorMessage('' + err);
+    }
+    return statusCode;
+}
+module.exports.findStatusCode = findStatusCode;
+
+function statusFromErrorMessage(errMsg) {
+    // Find an appropriate statusCode based on message
+    // jshint maxcomplexity:7
+    var statusCode = 400;
+    if ( -1 !== errMsg.indexOf('permission denied') ) {
+        statusCode = 403;
+    }
+    else if ( -1 !== errMsg.indexOf('authentication failed') ) {
+        statusCode = 403;
+    }
+    else if (errMsg.match(/Postgis Plugin.*[\s|\n].*column.*does not exist/)) {
+        statusCode = 400;
+    }
+    else if ( -1 !== errMsg.indexOf('does not exist') ) {
+        if ( -1 !== errMsg.indexOf(' role ') ) {
+            statusCode = 403; // role 'xxx' does not exist
+        } else if ( errMsg.match(/function .* does not exist/) ) {
+            statusCode = 400; // invalid SQL (SQL function does not exist)
+        } else {
+            statusCode = 404;
+        }
+    }
+    return statusCode;
+}

lib/cartodb/controllers/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+    Layergroup: require('./layergroup'),
+    Map: require('./map'),
+    NamedMaps: require('./named_maps'),
+    NamedMapsAdmin: require('./named_maps_admin'),
+    ServerInfo: require('./server_info')
+};

lib/cartodb/controllers/layergroup.js

@@ -0,0 +1,382 @@
+var assert = require('assert');
+var step = require('step');
+
+var util = require('util');
+var BaseController = require('./base');
+
+var cors = require('../middleware/cors');
+var userMiddleware = require('../middleware/user');
+
+var MapStoreMapConfigProvider = require('../models/mapconfig/map_store_provider');
+var TablesCacheEntry = require('../cache/model/database_tables_entry');
+
+/**
+ * @param {AuthApi} authApi
+ * @param {PgConnection} pgConnection
+ * @param {MapStore} mapStore
+ * @param {TileBackend} tileBackend
+ * @param {PreviewBackend} previewBackend
+ * @param {AttributesBackend} attributesBackend
+ * @param {WidgetBackend} widgetBackend
+ * @param {SurrogateKeysCache} surrogateKeysCache
+ * @param {UserLimitsApi} userLimitsApi
+ * @param {QueryTablesApi} queryTablesApi
+ * @param {LayergroupAffectedTables} layergroupAffectedTables
+ * @constructor
+ */
+function LayergroupController(authApi, pgConnection, mapStore, tileBackend, previewBackend, attributesBackend,
+                          widgetBackend, surrogateKeysCache, userLimitsApi, queryTablesApi, layergroupAffectedTables) {
+    BaseController.call(this, authApi, pgConnection);
+
+    this.mapStore = mapStore;
+    this.tileBackend = tileBackend;
+    this.previewBackend = previewBackend;
+    this.attributesBackend = attributesBackend;
+    this.widgetBackend = widgetBackend;
+    this.surrogateKeysCache = surrogateKeysCache;
+    this.userLimitsApi = userLimitsApi;
+    this.queryTablesApi = queryTablesApi;
+    this.layergroupAffectedTables = layergroupAffectedTables;
+}
+
+util.inherits(LayergroupController, BaseController);
+
+module.exports = LayergroupController;
+
+
+LayergroupController.prototype.register = function(app) {
+    app.get(app.base_url_mapconfig +
+        '/:token/:z/:x/:y@:scale_factor?x.:format', cors(), userMiddleware,
+        this.tile.bind(this));
+
+    app.get(app.base_url_mapconfig +
+        '/:token/:z/:x/:y.:format', cors(), userMiddleware,
+        this.tile.bind(this));
+
+    app.get(app.base_url_mapconfig +
+        '/:token/:layer/:z/:x/:y.(:format)', cors(), userMiddleware,
+        this.layer.bind(this));
+
+    app.get(app.base_url_mapconfig +
+        '/:token/:layer/attributes/:fid', cors(), userMiddleware,
+        this.attributes.bind(this));
+
+    app.get(app.base_url_mapconfig +
+        '/static/center/:token/:z/:lat/:lng/:width/:height.:format', cors(), userMiddleware,
+        this.center.bind(this));
+
+    app.get(app.base_url_mapconfig +
+        '/static/bbox/:token/:west,:south,:east,:north/:width/:height.:format', cors(), userMiddleware,
+        this.bbox.bind(this));
+
+    // Undocumented/non-supported API endpoint methods.
+    // Use at your own peril.
+    app.get(app.base_url_mapconfig +
+        '/:token/:layer/widget/:widgetName', cors(), userMiddleware,
+        this.widget.bind(this));
+
+    app.get(app.base_url_mapconfig +
+            '/:token/:layer/widget/:widgetName/search', cors(), userMiddleware,
+        this.widgetSearch.bind(this));
+};
+
+LayergroupController.prototype.widget = function(req, res) {
+    var self = this;
+
+    step(
+        function setupParams() {
+            self.req2params(req, this);
+        },
+        function retrieveList(err) {
+            assert.ifError(err);
+
+            var mapConfigProvider = new MapStoreMapConfigProvider(
+                self.mapStore, req.context.user, self.userLimitsApi, req.params
+            );
+            self.widgetBackend.getWidget(mapConfigProvider, req.params, this);
+        },
+        function finish(err, tile, stats) {
+            req.profiler.add(stats || {});
+
+            if (err) {
+                self.sendError(req, res, err, 'GET WIDGET');
+            } else {
+                self.sendResponse(req, res, tile, 200);
+            }
+        }
+    );
+
+};
+
+LayergroupController.prototype.widgetSearch = function(req, res) {
+    var self = this;
+
+    step(
+        function setupParams() {
+            self.req2params(req, this);
+        },
+        function retrieveList(err) {
+            assert.ifError(err);
+
+            var mapConfigProvider = new MapStoreMapConfigProvider(
+                self.mapStore, req.context.user, self.userLimitsApi, req.params
+            );
+            self.widgetBackend.search(mapConfigProvider, req.params, this);
+        },
+        function finish(err, tile, stats) {
+            req.profiler.add(stats || {});
+
+            if (err) {
+                self.sendError(req, res, err, 'GET WIDGET');
+            } else {
+                self.sendResponse(req, res, tile, 200);
+            }
+        }
+    );
+
+};
+
+LayergroupController.prototype.attributes = function(req, res) {
+    var self = this;
+
+    req.profiler.start('windshaft.maplayer_attribute');
+
+    step(
+        function setupParams() {
+            self.req2params(req, this);
+        },
+        function retrieveFeatureAttributes(err) {
+            assert.ifError(err);
+
+            var mapConfigProvider = new MapStoreMapConfigProvider(
+                self.mapStore, req.context.user, self.userLimitsApi, req.params
+            );
+            self.attributesBackend.getFeatureAttributes(mapConfigProvider, req.params, false, this);
+        },
+        function finish(err, tile, stats) {
+            req.profiler.add(stats || {});
+
+            if (err) {
+                self.sendError(req, res, err, 'GET ATTRIBUTES');
+            } else {
+                self.sendResponse(req, res, tile, 200);
+            }
+        }
+    );
+
+};
+
+// Gets a tile for a given token and set of tile ZXY coords. (OSM style)
+LayergroupController.prototype.tile = function(req, res) {
+    req.profiler.start('windshaft.map_tile');
+    this.tileOrLayer(req, res);
+};
+
+// Gets a tile for a given token, layer set of tile ZXY coords. (OSM style)
+LayergroupController.prototype.layer = function(req, res, next) {
+    if (req.params.token === 'static') {
+        return next();
+    }
+    req.profiler.start('windshaft.maplayer_tile');
+    this.tileOrLayer(req, res);
+};
+
+LayergroupController.prototype.tileOrLayer = function (req, res) {
+    var self = this;
+
+    step(
+        function mapController$prepareParams() {
+            self.req2params(req, this);
+        },
+        function mapController$getTileOrGrid(err) {
+            assert.ifError(err);
+            self.tileBackend.getTile(
+                new MapStoreMapConfigProvider(self.mapStore, req.context.user, self.userLimitsApi, req.params),
+                req.params, this
+            );
+        },
+        function mapController$finalize(err, tile, headers, stats) {
+            req.profiler.add(stats);
+            self.finalizeGetTileOrGrid(err, req, res, tile, headers);
+        }
+    );
+};
+
+// This function is meant for being called as the very last
+// step by all endpoints serving tiles or grids
+LayergroupController.prototype.finalizeGetTileOrGrid = function(err, req, res, tile, headers) {
+    var supportedFormats = {
+        grid_json: true,
+        json_torque: true,
+        torque_json: true,
+        png: true
+    };
+
+    var formatStat = 'invalid';
+    if (req.params.format) {
+        var format = req.params.format.replace('.', '_');
+        if (supportedFormats[format]) {
+            formatStat = format;
+        }
+    }
+
+    if (err) {
+        // See https://github.com/Vizzuality/Windshaft-cartodb/issues/68
+        var errMsg = err.message ? ( '' + err.message ) : ( '' + err );
+
+        // Rewrite mapnik parsing errors to start with layer number
+        var matches = errMsg.match("(.*) in style 'layer([0-9]+)'");
+        if (matches) {
+            errMsg = 'style'+matches[2]+': ' + matches[1];
+        }
+        err.message = errMsg;
+
+        this.sendError(req, res, err, 'TILE RENDER');
+        global.statsClient.increment('windshaft.tiles.error');
+        global.statsClient.increment('windshaft.tiles.' + formatStat + '.error');
+    } else {
+        this.sendResponse(req, res, tile, 200, headers);
+        global.statsClient.increment('windshaft.tiles.success');
+        global.statsClient.increment('windshaft.tiles.' + formatStat + '.success');
+    }
+};
+
+LayergroupController.prototype.bbox = function(req, res) {
+    this.staticMap(req, res, +req.params.width, +req.params.height, {
+        west: +req.params.west,
+        north: +req.params.north,
+        east: +req.params.east,
+        south: +req.params.south
+    });
+};
+
+LayergroupController.prototype.center = function(req, res) {
+    this.staticMap(req, res, +req.params.width, +req.params.height, +req.params.z, {
+        lng: +req.params.lng,
+        lat: +req.params.lat
+    });
+};
+
+LayergroupController.prototype.staticMap = function(req, res, width, height, zoom /* bounds */, center) {
+    var format = req.params.format === 'jpg' ? 'jpeg' : 'png';
+    req.params.layer = 'all';
+    req.params.format = 'png';
+
+    var self = this;
+
+    step(
+        function reqParams() {
+            self.req2params(req, this);
+        },
+        function getImage(err) {
+            assert.ifError(err);
+            if (center) {
+                self.previewBackend.getImage(
+                    new MapStoreMapConfigProvider(self.mapStore, req.context.user, self.userLimitsApi, req.params),
+                    format, width, height, zoom, center, this);
+            } else {
+                self.previewBackend.getImage(
+                    new MapStoreMapConfigProvider(self.mapStore, req.context.user, self.userLimitsApi, req.params),
+                    format, width, height, zoom /* bounds */, this);
+            }
+        },
+        function handleImage(err, image, headers, stats) {
+            req.profiler.done('render-' + format);
+            req.profiler.add(stats || {});
+
+            if (err) {
+                self.sendError(req, res, err, 'STATIC_MAP');
+            } else {
+                res.set('Content-Type', headers['Content-Type'] || 'image/' + format);
+                self.sendResponse(req, res, image, 200);
+            }
+        }
+    );
+};
+
+LayergroupController.prototype.sendResponse = function(req, res, body, status, headers) {
+    var self = this;
+
+    res.set('Cache-Control', 'public,max-age=31536000');
+
+    // Set Last-Modified header
+    var lastUpdated;
+    if (req.params.cache_buster) {
+        // Assuming cache_buster is a timestamp
+        lastUpdated = new Date(parseInt(req.params.cache_buster));
+    } else {
+        lastUpdated = new Date();
+    }
+    res.set('Last-Modified', lastUpdated.toUTCString());
+
+    var dbName = req.params.dbname;
+    step(
+        function getAffectedTables() {
+            self.getAffectedTables(req.context.user, dbName, req.params.token, this);
+        },
+        function sendResponse(err, affectedTables) {
+            req.profiler.done('affectedTables');
+            if (err) {
+                global.logger.warn('ERROR generating cache channel: ' + err);
+            }
+            if (!!affectedTables) {
+                var tablesCacheEntry = new TablesCacheEntry(dbName, affectedTables);
+                res.set('X-Cache-Channel', tablesCacheEntry.getCacheChannel());
+                self.surrogateKeysCache.tag(res, tablesCacheEntry);
+            }
+            self.send(req, res, body, status, headers);
+        }
+    );
+
+};
+
+LayergroupController.prototype.getAffectedTables = function(user, dbName, layergroupId, callback) {
+
+    if (this.layergroupAffectedTables.hasAffectedTables(dbName, layergroupId)) {
+        return callback(null, this.layergroupAffectedTables.get(dbName, layergroupId));
+    }
+
+    var self = this;
+    step(
+        function extractSQL() {
+            step(
+                function loadFromStore() {
+                    self.mapStore.load(layergroupId, this);
+                },
+                function getSQL(err, mapConfig) {
+                    assert.ifError(err);
+
+                    var queries = mapConfig.getLayers()
+                        .map(function(lyr) {
+                            return lyr.options.sql;
+                        })
+                        .filter(function(sql) {
+                            return !!sql;
+                        });
+
+                    return queries.length ? queries.join(';') : null;
+                },
+                this
+            );
+        },
+        function findAffectedTables(err, sql) {
+            assert.ifError(err);
+
+            if ( ! sql ) {
+                throw new Error("this request doesn't need an X-Cache-Channel generated");
+            }
+
+            self.queryTablesApi.getAffectedTablesInQuery(user, sql, this); // in addCacheChannel
+        },
+        function buildCacheChannel(err, tableNames) {
+            assert.ifError(err);
+
+            self.layergroupAffectedTables.set(dbName, layergroupId, tableNames);
+
+            return tableNames;
+        },
+        function finish(err, affectedTables) {
+            callback(err, affectedTables);
+        }
+    );
+};

lib/cartodb/controllers/map.js

@@ -0,0 +1,398 @@
+var _ = require('underscore');
+var assert = require('assert');
+var step = require('step');
+var windshaft = require('windshaft');
+
+var util = require('util');
+var BaseController = require('./base');
+
+var cors = require('../middleware/cors');
+var userMiddleware = require('../middleware/user');
+
+var MapConfig = windshaft.model.MapConfig;
+var Datasource = windshaft.model.Datasource;
+
+var NamedMapsCacheEntry = require('../cache/model/named_maps_entry');
+var TablesCacheEntry = require('../cache/model/database_tables_entry');
+
+var MapConfigNamedLayersAdapter = require('../models/mapconfig_named_layers_adapter');
+var NamedMapMapConfigProvider = require('../models/mapconfig/named_map_provider');
+var CreateLayergroupMapConfigProvider = require('../models/mapconfig/create_layergroup_provider');
+var MapConfigOverviewsAdapter = require('../models/mapconfig_overviews_adapter');
+
+/**
+ * @param {AuthApi} authApi
+ * @param {PgConnection} pgConnection
+ * @param {TemplateMaps} templateMaps
+ * @param {MapBackend} mapBackend
+ * @param metadataBackend
+ * @param {QueryTablesApi} queryTablesApi
+ * @param {OverviewsMetadataApi} overviewsMetadataApi
+ * @param {SurrogateKeysCache} surrogateKeysCache
+ * @param {UserLimitsApi} userLimitsApi
+ * @param {LayergroupAffectedTables} layergroupAffectedTables
+ * @constructor
+ */
+function MapController(authApi, pgConnection, templateMaps, mapBackend, metadataBackend,
+                       queryTablesApi, overviewsMetadataApi,
+                       surrogateKeysCache, userLimitsApi, layergroupAffectedTables) {
+
+    BaseController.call(this, authApi, pgConnection);
+
+    this.pgConnection = pgConnection;
+    this.templateMaps = templateMaps;
+    this.mapBackend = mapBackend;
+    this.metadataBackend = metadataBackend;
+    this.queryTablesApi = queryTablesApi;
+    this.overviewsMetadataApi = overviewsMetadataApi;
+    this.surrogateKeysCache = surrogateKeysCache;
+    this.userLimitsApi = userLimitsApi;
+    this.layergroupAffectedTables = layergroupAffectedTables;
+
+    this.namedLayersAdapter = new MapConfigNamedLayersAdapter(templateMaps);
+    this.overviewsAdapter = new MapConfigOverviewsAdapter(this.overviewsMetadataApi);
+}
+
+util.inherits(MapController, BaseController);
+
+module.exports = MapController;
+
+
+MapController.prototype.register = function(app) {
+    app.get(app.base_url_mapconfig, cors(), userMiddleware, this.createGet.bind(this));
+    app.post(app.base_url_mapconfig, cors(), userMiddleware, this.createPost.bind(this));
+    app.get(app.base_url_templated + '/:template_id/jsonp', cors(), userMiddleware, this.jsonp.bind(this));
+    app.post(app.base_url_templated + '/:template_id', cors(), userMiddleware, this.instantiate.bind(this));
+    app.options(app.base_url_mapconfig, cors('Content-Type'));
+};
+
+MapController.prototype.createGet = function(req, res){
+    req.profiler.start('windshaft.createmap_get');
+
+    this.create(req, res, function createGet$prepareConfig(err, req) {
+        assert.ifError(err);
+        if ( ! req.params.config ) {
+            throw new Error('layergroup GET needs a "config" parameter');
+        }
+        return JSON.parse(req.params.config);
+    });
+};
+
+MapController.prototype.createPost = function(req, res) {
+    req.profiler.start('windshaft.createmap_post');
+
+    this.create(req, res, function createPost$prepareConfig(err, req) {
+        assert.ifError(err);
+        if (!req.is('application/json')) {
+            throw new Error('layergroup POST data must be of type application/json');
+        }
+        return req.body;
+    });
+};
+
+MapController.prototype.instantiate = function(req, res) {
+    if (req.profiler) {
+        req.profiler.start('windshaft-cartodb.instance_template_post');
+    }
+
+    this.instantiateTemplate(req, res, function prepareTemplateParams(callback) {
+        if (!req.is('application/json')) {
+            return callback(new Error('Template POST data must be of type application/json'));
+        }
+        return callback(null, req.body);
+    });
+};
+
+MapController.prototype.jsonp = function(req, res) {
+    if (req.profiler) {
+        req.profiler.start('windshaft-cartodb.instance_template_get');
+    }
+
+    this.instantiateTemplate(req, res, function prepareJsonTemplateParams(callback) {
+        var err = null;
+        if ( req.query.callback === undefined || req.query.callback.length === 0) {
+            err = new Error('callback parameter should be present and be a function name');
+        }
+
+        var templateParams = {};
+        if (req.query.config) {
+            try {
+                templateParams = JSON.parse(req.query.config);
+            } catch(e) {
+                err = new Error('Invalid config parameter, should be a valid JSON');
+            }
+        }
+
+        return callback(err, templateParams);
+    });
+};
+
+MapController.prototype.create = function(req, res, prepareConfigFn) {
+    var self = this;
+
+    var mapConfig;
+
+    step(
+        function setupParams(){
+            self.req2params(req, this);
+        },
+        prepareConfigFn,
+        function beforeLayergroupCreate(err, requestMapConfig) {
+            assert.ifError(err);
+            var next = this;
+            self.namedLayersAdapter.getLayers(req.context.user, requestMapConfig.layers, self.pgConnection,
+                function(err, layers, datasource) {
+                    if (err) {
+                        return next(err);
+                    }
+
+                    if (layers) {
+                        requestMapConfig.layers = layers;
+                    }
+                    return next(null, requestMapConfig, datasource);
+                }
+            );
+        },
+        function addOverviewsInformation(err, requestMapConfig, datasource) {
+          assert.ifError(err);
+          var next = this;
+          self.overviewsAdapter.getLayers(req.context.user, requestMapConfig.layers,
+              function(err, layers) {
+                  if (err) {
+                      return next(err);
+                  }
+
+                  if (layers) {
+                      requestMapConfig.layers = layers;
+                  }
+                  return next(null, requestMapConfig, datasource);
+              }
+          );
+        },
+        function createLayergroup(err, requestMapConfig, datasource) {
+            assert.ifError(err);
+            mapConfig = new MapConfig(requestMapConfig, datasource || Datasource.EmptyDatasource());
+            self.mapBackend.createLayergroup(
+                mapConfig, req.params,
+                new CreateLayergroupMapConfigProvider(mapConfig, req.context.user, self.userLimitsApi, req.params),
+                this
+            );
+        },
+        function afterLayergroupCreate(err, layergroup) {
+            assert.ifError(err);
+            self.afterLayergroupCreate(req, res, mapConfig, layergroup, this);
+        },
+        function finish(err, layergroup) {
+            if (err) {
+                self.sendError(req, res, err, 'ANONYMOUS LAYERGROUP');
+            } else {
+                addWidgetsUrl(req.context.user, layergroup);
+
+                res.set('X-Layergroup-Id', layergroup.layergroupid);
+                self.send(req, res, layergroup, 200);
+            }
+        }
+    );
+};
+
+MapController.prototype.instantiateTemplate = function(req, res, prepareParamsFn) {
+    var self = this;
+
+    var cdbuser = req.context.user;
+
+    var mapConfigProvider;
+    var mapConfig;
+
+    step(
+        function setupParams(){
+            self.req2params(req, this);
+        },
+        function getTemplateParams() {
+            prepareParamsFn(this);
+        },
+        function getTemplate(err, templateParams) {
+            assert.ifError(err);
+            mapConfigProvider = new NamedMapMapConfigProvider(
+                self.templateMaps,
+                self.pgConnection,
+                self.userLimitsApi,
+                self.queryTablesApi,
+                self.namedLayersAdapter,
+                cdbuser,
+                req.params.template_id,
+                templateParams,
+                req.query.auth_token,
+                req.params
+            );
+            mapConfigProvider.getMapConfig(this);
+        },
+        function addOverviewsInformation(err, requestMapConfig, rendererParams/*, context*/) {
+          assert.ifError(err);
+          var next = this;
+          self.overviewsAdapter.getLayers(req.context.user, requestMapConfig.layers,
+              function(err, layers) {
+                  if (err) {
+                      return next(err);
+                  }
+
+                  if (layers) {
+                      requestMapConfig.layers = layers;
+                  }
+                  return next(null, requestMapConfig, rendererParams);
+              }
+          );
+        },
+        function createLayergroup(err, mapConfig_, rendererParams) {
+            assert.ifError(err);
+            mapConfig = mapConfig_;
+            self.mapBackend.createLayergroup(
+                mapConfig, rendererParams,
+                new CreateLayergroupMapConfigProvider(mapConfig, cdbuser, self.userLimitsApi, rendererParams),
+                this
+            );
+        },
+        function afterLayergroupCreate(err, layergroup) {
+            assert.ifError(err);
+            self.afterLayergroupCreate(req, res, mapConfig, layergroup, this);
+        },
+        function finishTemplateInstantiation(err, layergroup) {
+            if (err) {
+                self.sendError(req, res, err, 'NAMED MAP LAYERGROUP');
+            } else {
+                var templateHash = self.templateMaps.fingerPrint(mapConfigProvider.template).substring(0, 8);
+                layergroup.layergroupid = cdbuser + '@' + templateHash + '@' + layergroup.layergroupid;
+
+                addWidgetsUrl(req.context.user, layergroup);
+
+                res.set('X-Layergroup-Id', layergroup.layergroupid);
+                self.surrogateKeysCache.tag(res, new NamedMapsCacheEntry(cdbuser, mapConfigProvider.getTemplateName()));
+
+                self.send(req, res, layergroup, 200);
+            }
+        }
+    );
+};
+
+
+MapController.prototype.afterLayergroupCreate = function(req, res, mapconfig, layergroup, callback) {
+    var self = this;
+
+    var username = req.context.user;
+
+    var tasksleft = 2; // redis key and affectedTables
+    var errors = [];
+
+    var done = function(err) {
+        if ( err ) {
+            errors.push('' + err);
+        }
+        if ( ! --tasksleft ) {
+            err = errors.length ? new Error(errors.join('\n')) : null;
+            callback(err, layergroup);
+        }
+    };
+
+    // include in layergroup response the variables in serverMedata
+    // those variables are useful to send to the client information
+    // about how to reach this server or information about it
+    _.extend(layergroup, global.environment.serverMetadata);
+
+    // Don't wait for the mapview count increment to
+    // take place before proceeding. Error will be logged
+    // asynchronously
+    this.metadataBackend.incMapviewCount(username, mapconfig.obj().stat_tag, function(err) {
+        if (req.profiler) {
+            req.profiler.done('incMapviewCount');
+        }
+        if ( err ) {
+            global.logger.log("ERROR: failed to increment mapview count for user '" + username + "': " + err);
+        }
+        done();
+    });
+
+    var sql = mapconfig.getLayers().map(function(layer) {
+        return layer.options.sql;
+    }).join(';');
+
+    var dbName = req.params.dbname;
+    var layergroupId = layergroup.layergroupid;
+
+    step(
+        function checkCachedAffectedTables() {
+            return self.layergroupAffectedTables.hasAffectedTables(dbName, layergroupId);
+        },
+        function getAffectedTablesAndLastUpdatedTime(err, hasCache) {
+            assert.ifError(err);
+            if (hasCache) {
+                var next = this;
+                var affectedTables = self.layergroupAffectedTables.get(dbName, layergroupId);
+                self.queryTablesApi.getLastUpdatedTime(username, affectedTables, function(err, lastUpdatedTime) {
+                    if (err) {
+                        return next(err);
+                    }
+                    return next(null, { affectedTables: affectedTables, lastUpdatedTime: lastUpdatedTime });
+                });
+            } else {
+                self.queryTablesApi.getAffectedTablesAndLastUpdatedTime(username, sql, this);
+            }
+        },
+        function handleAffectedTablesAndLastUpdatedTime(err, result) {
+            if (req.profiler) {
+                req.profiler.done('queryTablesAndLastUpdated');
+            }
+            assert.ifError(err);
+            self.layergroupAffectedTables.set(dbName, layergroupId, result.affectedTables);
+
+            // last update for layergroup cache buster
+            layergroup.layergroupid = layergroup.layergroupid + ':' + result.lastUpdatedTime;
+            layergroup.last_updated = new Date(result.lastUpdatedTime).toISOString();
+
+            if (req.method === 'GET') {
+                var tableCacheEntry = new TablesCacheEntry(dbName, result.affectedTables);
+                var ttl = global.environment.varnish.layergroupTtl || 86400;
+                res.set('Cache-Control', 'public,max-age='+ttl+',must-revalidate');
+                res.set('Last-Modified', (new Date()).toUTCString());
+                res.set('X-Cache-Channel', tableCacheEntry.getCacheChannel());
+                if (result.affectedTables && result.affectedTables.length > 0) {
+                    self.surrogateKeysCache.tag(res, tableCacheEntry);
+                }
+            }
+
+            return null;
+        },
+        function finish(err) {
+            done(err);
+        }
+    );
+};
+
+function addWidgetsUrl(username, layergroup) {
+
+    if (layergroup.metadata && Array.isArray(layergroup.metadata.layers)) {
+        layergroup.metadata.layers = layergroup.metadata.layers.map(function(layer, layerIndex) {
+            if (layer.widgets) {
+                Object.keys(layer.widgets).forEach(function(widgetName) {
+                    var resource = layergroup.layergroupid + '/' + layerIndex + '/widget/' + widgetName;
+                    layer.widgets[widgetName].url = getUrls(username, resource);
+                });
+            }
+            return layer;
+        });
+    }
+
+}
+
+function getUrls(username, resource) {
+    var cdnUrl = global.environment.serverMetadata && global.environment.serverMetadata.cdn_url;
+    if (cdnUrl) {
+        return {
+            http: 'http://' + cdnUrl.http + '/' + username + '/api/v1/map/' + resource,
+            https: 'https://' + cdnUrl.https + '/' + username + '/api/v1/map/' + resource
+        };
+    } else {
+        var port = global.environment.port;
+        return {
+            http: 'http://' + username + '.' + 'localhost.lan:' + port +  '/api/v1/map/' + resource
+        };
+    }
+}

lib/cartodb/controllers/named_maps.js

@@ -0,0 +1,281 @@
+var step = require('step');
+var assert = require('assert');
+var _ = require('underscore');
+var NamedMapsCacheEntry = require('../cache/model/named_maps_entry');
+
+var util = require('util');
+var BaseController = require('./base');
+
+var cors = require('../middleware/cors');
+var userMiddleware = require('../middleware/user');
+
+var TablesCacheEntry = require('../cache/model/database_tables_entry');
+
+function NamedMapsController(authApi, pgConnection, namedMapProviderCache, tileBackend, previewBackend,
+                             surrogateKeysCache, tablesExtentApi, metadataBackend) {
+    BaseController.call(this, authApi, pgConnection);
+
+    this.namedMapProviderCache = namedMapProviderCache;
+    this.tileBackend = tileBackend;
+    this.previewBackend = previewBackend;
+    this.surrogateKeysCache = surrogateKeysCache;
+    this.tablesExtentApi = tablesExtentApi;
+    this.metadataBackend = metadataBackend;
+}
+
+util.inherits(NamedMapsController, BaseController);
+
+module.exports = NamedMapsController;
+
+NamedMapsController.prototype.register = function(app) {
+    app.get(app.base_url_templated +
+        '/:template_id/:layer/:z/:x/:y.(:format)', cors(), userMiddleware,
+        this.tile.bind(this));
+
+    app.get(app.base_url_mapconfig +
+        '/static/named/:template_id/:width/:height.:format', cors(), userMiddleware,
+        this.staticMap.bind(this));
+};
+
+NamedMapsController.prototype.sendResponse = function(req, res, resource, headers, namedMapProvider) {
+    this.surrogateKeysCache.tag(res, new NamedMapsCacheEntry(req.context.user, namedMapProvider.getTemplateName()));
+    res.set('Content-Type', headers['content-type'] || headers['Content-Type'] || 'image/png');
+    res.set('Cache-Control', 'public,max-age=7200,must-revalidate');
+
+    var self = this;
+
+    var dbName = req.params.dbname;
+    step(
+        function getAffectedTablesAndLastUpdatedTime() {
+            namedMapProvider.getAffectedTablesAndLastUpdatedTime(this);
+        },
+        function sendResponse(err, result) {
+            req.profiler.done('affectedTables');
+            if (err) {
+                global.logger.log('ERROR generating cache channel: ' + err);
+            }
+            if (!result || !!result.affectedTables) {
+                // we increase cache control as we can invalidate it
+                res.set('Cache-Control', 'public,max-age=31536000');
+
+                var lastModifiedDate;
+                if (Number.isFinite(result.lastUpdatedTime)) {
+                    lastModifiedDate = new Date(result.lastUpdatedTime);
+                } else {
+                    lastModifiedDate = new Date();
+                }
+                res.set('Last-Modified', lastModifiedDate.toUTCString());
+
+                var tablesCacheEntry = new TablesCacheEntry(dbName, result.affectedTables);
+                res.set('X-Cache-Channel', tablesCacheEntry.getCacheChannel());
+                if (result.affectedTables.length > 0) {
+                    self.surrogateKeysCache.tag(res, tablesCacheEntry);
+                }
+            }
+            self.send(req, res, resource, 200);
+        }
+    );
+};
+
+NamedMapsController.prototype.tile = function(req, res) {
+    var self = this;
+
+    var cdbUser = req.context.user;
+
+    var namedMapProvider;
+    step(
+        function reqParams() {
+            self.req2params(req, this);
+        },
+        function getNamedMapProvider(err) {
+            assert.ifError(err);
+            self.namedMapProviderCache.get(
+                cdbUser,
+                req.params.template_id,
+                req.query.config,
+                req.query.auth_token,
+                req.params,
+                this
+            );
+        },
+        function getTile(err, _namedMapProvider) {
+            assert.ifError(err);
+            namedMapProvider = _namedMapProvider;
+            self.tileBackend.getTile(namedMapProvider, req.params, this);
+        },
+        function handleImage(err, tile, headers, stats) {
+            if (req.profiler) {
+                req.profiler.add(stats);
+            }
+            if (err) {
+                self.sendError(req, res, err, 'NAMED_MAP_TILE');
+            } else {
+                self.sendResponse(req, res, tile, headers, namedMapProvider);
+            }
+        }
+    );
+};
+
+NamedMapsController.prototype.staticMap = function(req, res) {
+    var self = this;
+
+    var cdbUser = req.context.user;
+
+    var format = req.params.format === 'jpg' ? 'jpeg' : 'png';
+    req.params.format = 'png';
+    req.params.layer = 'all';
+
+    var namedMapProvider;
+    step(
+        function reqParams() {
+            self.req2params(req, this);
+        },
+        function getNamedMapProvider(err) {
+            assert.ifError(err);
+            self.namedMapProviderCache.get(
+                cdbUser,
+                req.params.template_id,
+                req.query.config,
+                req.query.auth_token,
+                req.params,
+                this
+            );
+        },
+        function prepareImageOptions(err, _namedMapProvider) {
+            assert.ifError(err);
+            namedMapProvider = _namedMapProvider;
+            self.getStaticImageOptions(cdbUser, namedMapProvider, this);
+        },
+        function getImage(err, imageOpts) {
+            assert.ifError(err);
+
+            var width = +req.params.width;
+            var height = +req.params.height;
+
+            if (!_.isUndefined(imageOpts.zoom) && imageOpts.center) {
+                self.previewBackend.getImage(
+                    namedMapProvider, format, width, height, imageOpts.zoom, imageOpts.center, this);
+            } else {
+                self.previewBackend.getImage(
+                    namedMapProvider, format, width, height, imageOpts.bounds, this);
+            }
+        },
+        function incrementMapViews(err, image, headers, stats) {
+            assert.ifError(err);
+
+            var next = this;
+            namedMapProvider.getMapConfig(function(mapConfigErr, mapConfig) {
+                self.metadataBackend.incMapviewCount(cdbUser, mapConfig.obj().stat_tag, function(sErr) {
+                    if (err) {
+                        global.logger.log("ERROR: failed to increment mapview count for user '%s': %s", cdbUser, sErr);
+                    }
+                    next(err, image, headers, stats);
+                });
+            });
+        },
+        function handleImage(err, image, headers, stats) {
+            if (req.profiler) {
+                req.profiler.done('render-' + format);
+                req.profiler.add(stats || {});
+            }
+
+            if (err) {
+                self.sendError(req, res, err, 'STATIC_VIZ_MAP');
+            } else {
+                self.sendResponse(req, res, image, headers, namedMapProvider);
+            }
+        }
+    );
+};
+
+var DEFAULT_ZOOM_CENTER = {
+    zoom: 1,
+    center: {
+        lng: 0,
+        lat: 0
+    }
+};
+
+NamedMapsController.prototype.getStaticImageOptions = function(cdbUser, namedMapProvider, callback) {
+    var self = this;
+
+    step(
+        function getTemplate() {
+            namedMapProvider.getTemplate(this);
+        },
+        function handleTemplateView(err, template) {
+            assert.ifError(err);
+
+            if (template.view) {
+                var zoomCenter = templateZoomCenter(template.view);
+                if (zoomCenter) {
+                    return zoomCenter;
+                }
+
+                var bounds = templateBounds(template.view);
+                if (bounds) {
+                    return bounds;
+                }
+            }
+
+            return false;
+        },
+        function estimateBoundsIfNoImageOpts(err, imageOpts) {
+            if (imageOpts) {
+                return imageOpts;
+            }
+
+            var next = this;
+            namedMapProvider.getAffectedTablesAndLastUpdatedTime(function(err, affectedTablesAndLastUpdate) {
+                if (err) {
+                    return next(null);
+                }
+
+                var affectedTables = affectedTablesAndLastUpdate.affectedTables || [];
+
+                if (affectedTables.length === 0) {
+                    return next(null);
+                }
+
+                self.tablesExtentApi.getBounds(cdbUser, affectedTables, function(err, result) {
+                    return next(null, result);
+                });
+            });
+
+        },
+        function returnCallback(err, imageOpts) {
+            return callback(err, imageOpts || DEFAULT_ZOOM_CENTER);
+        }
+    );
+};
+
+function templateZoomCenter(view) {
+    if (!_.isUndefined(view.zoom) && view.center) {
+        return {
+            zoom: view.zoom,
+            center: view.center
+        };
+    }
+    return false;
+}
+
+function templateBounds(view) {
+    if (view.bounds) {
+        var hasAllBounds = _.every(['west', 'south', 'east', 'north'], function(prop) {
+            return Number.isFinite(view.bounds[prop]);
+        });
+        if (hasAllBounds) {
+            return {
+                bounds: {
+                    west: view.bounds.west,
+                    south: view.bounds.south,
+                    east: view.bounds.east,
+                    north: view.bounds.north
+                }
+            };
+        } else {
+            return false;
+        }
+    }
+    return false;
+}

lib/cartodb/controllers/named_maps_admin.js

@@ -0,0 +1,202 @@
+var step = require('step');
+var assert = require('assert');
+var templateName = require('../backends/template_maps').templateName;
+
+var util = require('util');
+var BaseController = require('./base');
+
+var cors = require('../middleware/cors');
+var userMiddleware = require('../middleware/user');
+
+
+/**
+ * @param {AuthApi} authApi
+ * @param {PgConnection} pgConnection
+ * @param {TemplateMaps} templateMaps
+ * @constructor
+ */
+function NamedMapsAdminController(authApi, pgConnection, templateMaps) {
+    BaseController.call(this, authApi, pgConnection);
+
+    this.authApi = authApi;
+    this.templateMaps = templateMaps;
+}
+
+util.inherits(NamedMapsAdminController, BaseController);
+
+module.exports = NamedMapsAdminController;
+
+NamedMapsAdminController.prototype.register = function(app) {
+    app.post(app.base_url_templated, cors(), userMiddleware, this.create.bind(this));
+    app.put(app.base_url_templated + '/:template_id', cors(), userMiddleware, this.update.bind(this));
+    app.get(app.base_url_templated + '/:template_id', cors(), userMiddleware, this.retrieve.bind(this));
+    app.delete(app.base_url_templated + '/:template_id', cors(), userMiddleware, this.destroy.bind(this));
+    app.get(app.base_url_templated, cors(), userMiddleware, this.list.bind(this));
+    app.options(app.base_url_templated + '/:template_id', cors('Content-Type'));
+};
+
+NamedMapsAdminController.prototype.create = function(req, res) {
+    var self = this;
+
+    var cdbuser = req.context.user;
+
+    step(
+        function checkPerms(){
+            self.authApi.authorizedByAPIKey(cdbuser, req, this);
+        },
+        function addTemplate(err, authenticated) {
+            assert.ifError(err);
+            ifUnauthenticated(authenticated, 'Only authenticated users can get template maps');
+            ifInvalidContentType(req, 'template POST data must be of type application/json');
+            var cfg = req.body;
+            self.templateMaps.addTemplate(cdbuser, cfg, this);
+        },
+        function prepareResponse(err, tpl_id){
+            assert.ifError(err);
+            return { template_id: tpl_id };
+        },
+        finishFn(self, req, res, 'POST TEMPLATE')
+    );
+};
+
+NamedMapsAdminController.prototype.update = function(req, res) {
+    var self = this;
+
+    var cdbuser = req.context.user;
+    var template;
+    var tpl_id;
+    step(
+        function checkPerms(){
+            self.authApi.authorizedByAPIKey(cdbuser, req, this);
+        },
+        function updateTemplate(err, authenticated) {
+            assert.ifError(err);
+            ifUnauthenticated(authenticated, 'Only authenticated user can update templated maps');
+            ifInvalidContentType(req, 'template PUT data must be of type application/json');
+
+            template = req.body;
+            tpl_id = templateName(req.params.template_id);
+            self.templateMaps.updTemplate(cdbuser, tpl_id, template, this);
+        },
+        function prepareResponse(err){
+            assert.ifError(err);
+
+            return { template_id: tpl_id };
+        },
+        finishFn(self, req, res, 'PUT TEMPLATE')
+    );
+};
+
+NamedMapsAdminController.prototype.retrieve = function(req, res) {
+    var self = this;
+
+    if (req.profiler) {
+        req.profiler.start('windshaft-cartodb.get_template');
+    }
+
+    var cdbuser = req.context.user;
+    var tpl_id;
+    step(
+        function checkPerms(){
+            self.authApi.authorizedByAPIKey(cdbuser, req, this);
+        },
+        function getTemplate(err, authenticated) {
+            assert.ifError(err);
+            ifUnauthenticated(authenticated, 'Only authenticated users can get template maps');
+
+            tpl_id = templateName(req.params.template_id);
+            self.templateMaps.getTemplate(cdbuser, tpl_id, this);
+        },
+        function prepareResponse(err, tpl_val) {
+            assert.ifError(err);
+            if ( ! tpl_val ) {
+                err = new Error("Cannot find template '" + tpl_id + "' of user '" + cdbuser + "'");
+                err.http_status = 404;
+                throw err;
+            }
+            // auth_id was added by ourselves,
+            // so we remove it before returning to the user
+            delete tpl_val.auth_id;
+            return { template: tpl_val };
+        },
+        finishFn(self, req, res, 'GET TEMPLATE')
+    );
+};
+
+NamedMapsAdminController.prototype.destroy = function(req, res) {
+    var self = this;
+
+    if (req.profiler) {
+        req.profiler.start('windshaft-cartodb.delete_template');
+    }
+
+    var cdbuser = req.context.user;
+    var tpl_id;
+    step(
+        function checkPerms(){
+            self.authApi.authorizedByAPIKey(cdbuser, req, this);
+        },
+        function deleteTemplate(err, authenticated) {
+            assert.ifError(err);
+            ifUnauthenticated(authenticated, 'Only authenticated users can delete template maps');
+
+            tpl_id = templateName(req.params.template_id);
+            self.templateMaps.delTemplate(cdbuser, tpl_id, this);
+        },
+        function prepareResponse(err/*, tpl_val*/){
+            assert.ifError(err);
+            return '';
+        },
+        finishFn(self, req, res, 'DELETE TEMPLATE', 204)
+    );
+};
+
+NamedMapsAdminController.prototype.list = function(req, res) {
+    var self = this;
+    if ( req.profiler ) {
+        req.profiler.start('windshaft-cartodb.get_template_list');
+    }
+
+    var cdbuser = req.context.user;
+
+    step(
+        function checkPerms(){
+            self.authApi.authorizedByAPIKey(cdbuser, req, this);
+        },
+        function listTemplates(err, authenticated) {
+            assert.ifError(err);
+            ifUnauthenticated(authenticated, 'Only authenticated user can list templated maps');
+
+            self.templateMaps.listTemplates(cdbuser, this);
+        },
+        function prepareResponse(err, tpl_ids){
+            assert.ifError(err);
+            return { template_ids: tpl_ids };
+        },
+        finishFn(self, req, res, 'GET TEMPLATE LIST')
+    );
+};
+
+function finishFn(controller, req, res, description, status) {
+    return function finish(err, response){
+        if (err) {
+            controller.sendError(req, res, err, description);
+        } else {
+            controller.send(req, res, response, status || 200);
+        }
+    };
+}
+
+function ifUnauthenticated(authenticated, description) {
+    if (!authenticated) {
+        var err = new Error(description);
+        err.http_status = 403;
+        throw err;
+    }
+}
+
+function ifInvalidContentType(req, description) {
+    if (!req.is('application/json')) {
+        throw new Error(description);
+    }
+}

lib/cartodb/controllers/server_info.js

@@ -0,0 +1,56 @@
+var windshaft = require('windshaft');
+var HealthCheck = require('../monitoring/health_check');
+
+var WELCOME_MSG = "This is the CartoDB Maps API, " +
+    "see the documentation at http://docs.cartodb.com/cartodb-platform/maps-api.html";
+
+
+var versions = {
+    windshaft: windshaft.version,
+    grainstore: windshaft.grainstore.version(),
+    node_mapnik: windshaft.mapnik.version,
+    mapnik: windshaft.mapnik.versions.mapnik,
+    windshaft_cartodb: require('../../../package.json').version
+};
+
+function ServerInfoController() {
+    this.healthConfig = global.environment.health || {};
+    this.healthCheck = new HealthCheck(global.environment.disabled_file);
+}
+
+module.exports = ServerInfoController;
+
+ServerInfoController.prototype.register = function(app) {
+    app.get('/health', this.health.bind(this));
+    app.get('/', this.welcome.bind(this));
+    app.get('/version', this.version.bind(this));
+};
+
+ServerInfoController.prototype.welcome = function(req, res) {
+    res.status(200).send(WELCOME_MSG);
+};
+
+ServerInfoController.prototype.version = function(req, res) {
+    res.status(200).send(versions);
+};
+
+ServerInfoController.prototype.health = function(req, res) {
+    if (!!this.healthConfig.enabled) {
+        var startTime = Date.now();
+        this.healthCheck.check(function(err) {
+            var ok = !err;
+            var response = {
+                enabled: true,
+                ok: ok,
+                elapsed: Date.now() - startTime
+            };
+            if (err) {
+                response.err = err.message;
+            }
+            res.status(ok ? 200 : 503).send(response);
+
+        });
+    } else {
+        res.status(200).send({enabled: false, ok: true});
+    }
+};

lib/cartodb/middleware/cors.js

@@ -0,0 +1,11 @@
+module.exports = function cors(extraHeaders) {
+    return function(req, res, next) {
+        var baseHeaders = "X-Requested-With, X-Prototype-Version, X-CSRF-Token";
+        if(extraHeaders) {
+            baseHeaders += ", " + extraHeaders;
+        }
+        res.set("Access-Control-Allow-Origin", "*");
+        res.set("Access-Control-Allow-Headers", baseHeaders);
+        next();
+    };
+};

lib/cartodb/middleware/user.js

@@ -0,0 +1,7 @@
+var CdbRequest = require('../models/cdb_request');
+var cdbRequest = new CdbRequest();
+
+module.exports = function userMiddleware(req, res, next) {
+    req.context.user = cdbRequest.userByReq(req);
+    next();
+};

lib/cartodb/models/cdb_request.js

@@ -0,0 +1,25 @@
+function CdbRequest() {
+    this.RE_USER_FROM_HOST = new RegExp(global.environment.user_from_host ||
+            '^([^\\.]+)\\.' // would extract "strk" from "strk.cartodb.com"
+    );
+}
+
+module.exports = CdbRequest;
+
+
+CdbRequest.prototype.userByReq = function(req) {
+    var host = req.headers.host || '';
+    if (req.params.user) {
+        return req.params.user;
+    }
+    var mat = host.match(this.RE_USER_FROM_HOST);
+    if ( ! mat ) {
+        global.logger.error("Pattern '%s' does not match hostname '%s'", this.RE_USER_FROM_HOST, host);
+        return;
+    }
+    if ( mat.length !== 2 ) {
+        global.logger.error("Pattern '%s' gave unexpected matches against '%s': %s", this.RE_USER_FROM_HOST, host, mat);
+        return;
+    }
+    return mat[1];
+};

lib/cartodb/models/layergroup_token.js

@@ -0,0 +1,29 @@
+/**
+ * @param {String} token might match the following pattern: {user}@{tpl_id}@{token}:{cache_buster}
+ */
+function parse(token) {
+    var signer, cacheBuster;
+
+    var tokenSplit = token.split(':');
+
+    token = tokenSplit[0];
+    if (tokenSplit.length > 1) {
+        cacheBuster = tokenSplit[1];
+    }
+
+    tokenSplit = token.split('@');
+    if ( tokenSplit.length > 1 ) {
+        signer = tokenSplit.shift();
+        if ( tokenSplit.length > 1 ) {
+            /*var template_hash = */tokenSplit.shift(); // unused
+        }
+        token = tokenSplit.shift();
+    }
+
+    return {
+        token: token,
+        signer: signer,
+        cacheBuster: cacheBuster
+    };
+}
+module.exports.parse = parse;

lib/cartodb/models/mapconfig/create_layergroup_provider.js

@@ -0,0 +1,48 @@
+var assert = require('assert');
+var step = require('step');
+
+var MapStoreMapConfigProvider = require('./map_store_provider');
+
+/**
+ * @param {MapConfig} mapConfig
+ * @param {String} user
+ * @param {UserLimitsApi} userLimitsApi
+ * @param {Object} params
+ * @constructor
+ * @type {CreateLayergroupMapConfigProvider}
+ */
+function CreateLayergroupMapConfigProvider(mapConfig, user, userLimitsApi, params) {
+    this.mapConfig = mapConfig;
+    this.user = user;
+    this.userLimitsApi = userLimitsApi;
+    this.params = params;
+    this.cacheBuster = params.cache_buster || 0;
+}
+
+module.exports = CreateLayergroupMapConfigProvider;
+
+CreateLayergroupMapConfigProvider.prototype.getMapConfig = function(callback) {
+    var self = this;
+    var context = {};
+    step(
+        function prepareContextLimits() {
+            self.userLimitsApi.getRenderLimits(self.user, this);
+        },
+        function handleRenderLimits(err, renderLimits) {
+            assert.ifError(err);
+            context.limits = renderLimits;
+            return null;
+        },
+        function finish(err) {
+            return callback(err, self.mapConfig, self.params, context);
+        }
+    );
+};
+
+CreateLayergroupMapConfigProvider.prototype.getKey = MapStoreMapConfigProvider.prototype.getKey;
+
+CreateLayergroupMapConfigProvider.prototype.getCacheBuster = MapStoreMapConfigProvider.prototype.getCacheBuster;
+
+CreateLayergroupMapConfigProvider.prototype.filter = MapStoreMapConfigProvider.prototype.filter;
+
+CreateLayergroupMapConfigProvider.prototype.createKey = MapStoreMapConfigProvider.prototype.createKey;

lib/cartodb/models/mapconfig/map_store_provider.js

@@ -0,0 +1,77 @@
+var _ = require('underscore');
+var assert = require('assert');
+var dot = require('dot');
+var step = require('step');
+
+/**
+ * @param {MapStore} mapStore
+ * @param {String} user
+ * @param {UserLimitsApi} userLimitsApi
+ * @param {Object} params
+ * @constructor
+ * @type {MapStoreMapConfigProvider}
+ */
+function MapStoreMapConfigProvider(mapStore, user, userLimitsApi, params) {
+    this.mapStore = mapStore;
+    this.user = user;
+    this.userLimitsApi = userLimitsApi;
+    this.params = params;
+    this.token = params.token;
+    this.cacheBuster = params.cache_buster || 0;
+}
+
+module.exports = MapStoreMapConfigProvider;
+
+MapStoreMapConfigProvider.prototype.getMapConfig = function(callback) {
+    var self = this;
+    var context = {};
+    step(
+        function prepareContextLimits() {
+            self.userLimitsApi.getRenderLimits(self.user, this);
+        },
+        function handleRenderLimits(err, renderLimits) {
+            assert.ifError(err);
+            context.limits = renderLimits;
+            return null;
+        },
+        function loadMapConfig(err) {
+            assert.ifError(err);
+            self.mapStore.load(self.token, this);
+        },
+        function finish(err, mapConfig) {
+            return callback(err, mapConfig, self.params, context);
+        }
+    );
+};
+
+MapStoreMapConfigProvider.prototype.getKey = function() {
+    return this.createKey(false);
+};
+
+MapStoreMapConfigProvider.prototype.getCacheBuster = function() {
+    return this.cacheBuster;
+};
+
+MapStoreMapConfigProvider.prototype.filter = function(key) {
+    var regex = new RegExp('^' + this.createKey(true) + '.*');
+    return key && key.match(regex);
+};
+
+// Configure bases for cache keys suitable for string interpolation
+var baseKey   = '{{=it.dbname}}:{{=it.token}}';
+var rendererKey = baseKey + ':{{=it.dbuser}}:{{=it.format}}:{{=it.layer}}:{{=it.scale_factor}}';
+
+var baseKeyTpl = dot.template(baseKey);
+var rendererKeyTpl = dot.template(rendererKey);
+
+MapStoreMapConfigProvider.prototype.createKey = function(base) {
+    var tplValues = _.defaults({}, this.params, {
+        dbname: '',
+        token: '',
+        dbuser: '',
+        format: '',
+        layer: '',
+        scale_factor: 1
+    });
+    return (base) ? baseKeyTpl(tplValues) : rendererKeyTpl(tplValues);
+};

lib/cartodb/models/mapconfig/named_map_provider.js

@@ -0,0 +1,266 @@
+var _ = require('underscore');
+var assert = require('assert');
+var crypto = require('crypto');
+var dot = require('dot');
+var step = require('step');
+var MapConfig = require('windshaft').model.MapConfig;
+var templateName = require('../../backends/template_maps').templateName;
+
+/**
+ * @constructor
+ * @type {NamedMapMapConfigProvider}
+ */
+function NamedMapMapConfigProvider(templateMaps, pgConnection, userLimitsApi, queryTablesApi, namedLayersAdapter,
+                                   owner, templateId, config, authToken, params) {
+    this.templateMaps = templateMaps;
+    this.pgConnection = pgConnection;
+    this.userLimitsApi = userLimitsApi;
+    this.queryTablesApi = queryTablesApi;
+    this.namedLayersAdapter = namedLayersAdapter;
+
+    this.owner = owner;
+    this.templateName = templateName(templateId);
+    this.config = config;
+    this.authToken = authToken;
+    this.params = params;
+
+    this.cacheBuster = Date.now();
+
+    // use template after call to mapConfig
+    this.template = null;
+
+    this.affectedTablesAndLastUpdate = null;
+
+    // providing
+    this.err = null;
+    this.mapConfig = null;
+    this.rendererParams = null;
+    this.context = {};
+}
+
+module.exports = NamedMapMapConfigProvider;
+
+NamedMapMapConfigProvider.prototype.getMapConfig = function(callback) {
+    if (!!this.err || this.mapConfig !== null) {
+        return callback(this.err, this.mapConfig, this.rendererParams, this.context);
+    }
+
+    var self = this;
+
+    var mapConfig = null;
+    var datasource = null;
+    var rendererParams;
+
+    step(
+        function getTemplate() {
+            self.getTemplate(this);
+        },
+        function prepareParams(err, tpl) {
+            assert.ifError(err);
+
+            self.template = tpl;
+
+            var templateParams = {};
+            if (self.config) {
+                try {
+                    templateParams = _.isString(self.config) ? JSON.parse(self.config) : self.config;
+                } catch (e) {
+                    throw new Error('malformed config parameter, should be a valid JSON');
+                }
+            }
+
+            return templateParams;
+        },
+        function instantiateTemplate(err, templateParams) {
+            assert.ifError(err);
+            return self.templateMaps.instance(self.template, templateParams);
+        },
+        function prepareLayergroup(err, _mapConfig) {
+            assert.ifError(err);
+            var next = this;
+            self.namedLayersAdapter.getLayers(self.owner, _mapConfig.layers, self.pgConnection,
+                function(err, layers, datasource) {
+                    if (err) {
+                        return next(err);
+                    }
+
+                    if (layers) {
+                        _mapConfig.layers = layers;
+                    }
+                    return next(null, _mapConfig, datasource);
+                }
+            );
+        },
+        function beforeLayergroupCreate(err, _mapConfig, _datasource) {
+            assert.ifError(err);
+            mapConfig = _mapConfig;
+            datasource = _datasource;
+            rendererParams = _.extend({}, self.params, {
+                user: self.owner
+            });
+            self.setDBParams(self.owner, rendererParams, this);
+        },
+        function prepareContextLimits(err) {
+            assert.ifError(err);
+            self.userLimitsApi.getRenderLimits(self.owner, this);
+        },
+        function cacheAndReturnMapConfig(err, renderLimits) {
+            self.err = err;
+            self.mapConfig = (mapConfig === null) ? null : new MapConfig(mapConfig, datasource);
+            self.rendererParams = rendererParams;
+            self.context.limits = renderLimits || {};
+            return callback(self.err, self.mapConfig, self.rendererParams, self.context);
+        }
+    );
+};
+
+NamedMapMapConfigProvider.prototype.getTemplate = function(callback) {
+    var self = this;
+
+    if (!!this.err || this.template !== null) {
+        return callback(this.err, this.template);
+    }
+
+    step(
+        function getTemplate() {
+            self.templateMaps.getTemplate(self.owner, self.templateName, this);
+        },
+        function checkExists(err, tpl) {
+            assert.ifError(err);
+            if (!tpl) {
+                var notFoundErr = new Error(
+                        "Template '" + self.templateName + "' of user '" + self.owner + "' not found"
+                );
+                notFoundErr.http_status = 404;
+                throw notFoundErr;
+            }
+            return tpl;
+        },
+        function checkAuthorized(err, tpl) {
+            assert.ifError(err);
+
+            var authorized = false;
+            try {
+                authorized = self.templateMaps.isAuthorized(tpl, self.authToken);
+            } catch (err) {
+                // we catch to add http_status
+                var authorizationFailedErr = new Error('Failed to authorize template');
+                authorizationFailedErr.http_status = 403;
+                throw authorizationFailedErr;
+            }
+            if ( ! authorized ) {
+                var unauthorizedErr = new Error('Unauthorized template instantiation');
+                unauthorizedErr.http_status = 403;
+                throw unauthorizedErr;
+            }
+
+            return tpl;
+        },
+        function cacheAndReturnTemplate(err, template) {
+            self.err = err;
+            self.template = template;
+            return callback(self.err, self.template);
+        }
+    );
+};
+
+NamedMapMapConfigProvider.prototype.getKey = function() {
+    return this.createKey(false);
+};
+
+NamedMapMapConfigProvider.prototype.getCacheBuster = function() {
+    return this.cacheBuster;
+};
+
+NamedMapMapConfigProvider.prototype.reset = function() {
+    this.template = null;
+
+    this.affectedTablesAndLastUpdate = null;
+
+    this.err = null;
+    this.mapConfig = null;
+
+    this.cacheBuster = Date.now();
+};
+
+NamedMapMapConfigProvider.prototype.filter = function(key) {
+    var regex = new RegExp('^' + this.createKey(true) + '.*');
+    return key && key.match(regex);
+};
+
+// Configure bases for cache keys suitable for string interpolation
+var baseKey = '{{=it.dbname}}:{{=it.owner}}:{{=it.templateName}}';
+var rendererKey = baseKey + ':{{=it.authToken}}:{{=it.configHash}}:{{=it.format}}:{{=it.layer}}:{{=it.scale_factor}}';
+
+var baseKeyTpl = dot.template(baseKey);
+var rendererKeyTpl = dot.template(rendererKey);
+
+NamedMapMapConfigProvider.prototype.createKey = function(base) {
+    var tplValues = _.defaults({}, this.params, {
+        dbname: '',
+        owner: this.owner,
+        templateName: this.templateName,
+        authToken: this.authToken || '',
+        configHash: configHash(this.config),
+        layer: '',
+        scale_factor: 1
+    });
+    return (base) ? baseKeyTpl(tplValues) : rendererKeyTpl(tplValues);
+};
+
+function configHash(config) {
+    if (!config) {
+        return '';
+    }
+    return crypto.createHash('md5').update(JSON.stringify(config)).digest('hex').substring(0,8);
+}
+
+module.exports.configHash = configHash;
+
+NamedMapMapConfigProvider.prototype.setDBParams = function(cdbuser, params, callback) {
+    var self = this;
+    step(
+        function setAuth() {
+            self.pgConnection.setDBAuth(cdbuser, params, this);
+        },
+        function setConn(err) {
+            assert.ifError(err);
+            self.pgConnection.setDBConn(cdbuser, params, this);
+        },
+        function finish(err) {
+            callback(err);
+        }
+    );
+};
+
+NamedMapMapConfigProvider.prototype.getTemplateName = function() {
+    return this.templateName;
+};
+
+NamedMapMapConfigProvider.prototype.getAffectedTablesAndLastUpdatedTime = function(callback) {
+    var self = this;
+
+    if (this.affectedTablesAndLastUpdate !== null) {
+        return callback(null, this.affectedTablesAndLastUpdate);
+    }
+
+    step(
+        function getMapConfig() {
+            self.getMapConfig(this);
+        },
+        function getSql(err, mapConfig) {
+            assert.ifError(err);
+            return mapConfig.getLayers().map(function(layer) {
+                return layer.options.sql;
+            }).join(';');
+        },
+        function getAffectedTables(err, sql) {
+            assert.ifError(err);
+            self.queryTablesApi.getAffectedTablesAndLastUpdatedTime(self.owner, sql, this);
+        },
+        function finish(err, result) {
+            self.affectedTablesAndLastUpdate = result;
+            return callback(err, result);
+        }
+    );
+};

lib/cartodb/models/mapconfig_named_layers_adapter.js

@@ -0,0 +1,124 @@
+var queue = require('queue-async');
+var _ = require('underscore');
+var Datasource = require('windshaft').model.Datasource;
+
+function MapConfigNamedLayersAdapter(templateMaps) {
+    this.templateMaps = templateMaps;
+}
+
+module.exports = MapConfigNamedLayersAdapter;
+
+MapConfigNamedLayersAdapter.prototype.getLayers = function(username, layers, dbMetadata, callback) {
+    var self = this;
+
+    if (!layers) {
+        return callback(null);
+    }
+
+    var adaptLayersQueue = queue(layers.length);
+
+    function adaptLayer(layer, done) {
+        if (isNamedTypeLayer(layer)) {
+
+            if (!layer.options.name) {
+                return done(new Error('Missing Named Map `name` in layer options'));
+            }
+
+            var templateName = layer.options.name;
+            var templateConfigParams = layer.options.config || {};
+            var templateAuthTokens = layer.options.auth_tokens;
+
+            self.templateMaps.getTemplate(username, templateName, function(err,  template) {
+                if (err || !template) {
+                    return done(new Error("Template '" + templateName + "' of user '" + username + "' not found"));
+                }
+
+                if (self.templateMaps.isAuthorized(template, templateAuthTokens)) {
+                    var nestedNamedLayers = template.layergroup.layers.filter(function(layer) {
+                        return layer.type === 'named';
+                    });
+
+                    if (nestedNamedLayers.length > 0) {
+                        var nestedNamedMapsError = new Error('Nested named layers are not allowed');
+                        // nestedNamedMapsError.http_status = 400;
+                        return done(nestedNamedMapsError);
+                    }
+
+                    try {
+                        var templateLayergroupConfig = self.templateMaps.instance(template, templateConfigParams);
+                        return done(null, {
+                            datasource: true,
+                            layers: templateLayergroupConfig.layers
+                        });
+                    } catch (err) {
+                        return done(err);
+                    }
+                } else {
+                    var unauthorizedError = new Error("Unauthorized '" + templateName + "' template instantiation");
+                    unauthorizedError.http_status = 403;
+                    return done(unauthorizedError);
+                }
+            });
+
+        } else {
+            return done(null, {
+                datasource: false,
+                layers: [layer]
+            });
+        }
+    }
+
+    var datasourceBuilder = new Datasource.Builder();
+
+    function layersAdaptQueueFinish(err, layersResults) {
+        if (err) {
+            return callback(err);
+        }
+
+        if (!layersResults || layersResults.length === 0) {
+            return callback(new Error('Missing layers array from layergroup config'));
+        }
+
+        var layers = [],
+            currentLayerIndex = 0;
+
+        layersResults.forEach(function(layersResult) {
+
+            layersResult.layers.forEach(function(layer) {
+                layers.push(layer);
+                if (layersResult.datasource) {
+                    datasourceBuilder.withLayerDatasource(currentLayerIndex, {
+                        user: dbAuth.dbuser
+                    });
+                }
+                currentLayerIndex++;
+            });
+
+        });
+
+        return callback(null, layers, datasourceBuilder.build());
+    }
+
+
+    var dbAuth = {};
+
+    if (_.some(layers, isNamedTypeLayer)) {
+        // Lazy load dbAuth
+        dbMetadata.setDBAuth(username, dbAuth, function(err) {
+            if (err) {
+                return callback(err);
+            }
+            layers.forEach(function(layer) {
+                adaptLayersQueue.defer(adaptLayer, layer);
+            });
+            adaptLayersQueue.awaitAll(layersAdaptQueueFinish);
+        });
+    } else {
+        return callback(null, layers, datasourceBuilder.build());
+    }
+
+};
+
+function isNamedTypeLayer(layer) {
+    return layer.type === 'named';
+}

lib/cartodb/models/mapconfig_overviews_adapter.js

@@ -0,0 +1,53 @@
+var queue = require('queue-async');
+var _ = require('underscore');
+
+function MapConfigOverviewsAdapter(overviewsMetadataApi) {
+    this.overviewsMetadataApi = overviewsMetadataApi;
+}
+
+module.exports = MapConfigOverviewsAdapter;
+
+MapConfigOverviewsAdapter.prototype.getLayers = function(username, layers, callback) {
+  var self = this;
+
+  if (!layers || layers.length === 0) {
+      return callback(null, layers);
+  }
+
+  var augmentLayersQueue = queue(layers.length);
+
+  function augmentLayer(layer, done) {
+      if ( layer.type !== 'mapnik' && layer.type !== 'cartodb' ) {
+          return done(null, layer);
+      }
+      self.overviewsMetadataApi.getOverviewsMetadata(username, layer.options.sql, function(err, metadata){
+           if (err) {
+               done(err, layer);
+           } else {
+               if ( !_.isEmpty(metadata) ) {
+                   layer = _.extend({}, layer);
+                   layer.options = _.extend({}, layer.options, { query_rewrite_data: { overviews: metadata } });
+               }
+               done(null, layer);
+           }
+      });
+  }
+
+  function layersAugmentQueueFinish(err, layers) {
+    if (err) {
+        return callback(err);
+    }
+
+    if (!layers || layers.length === 0) {
+        return callback(new Error('Missing layers array from layergroup config'));
+    }
+
+    return callback(null, layers);
+  }
+
+  layers.forEach(function(layer) {
+      augmentLayersQueue.defer(augmentLayer, layer);
+  });
+  augmentLayersQueue.awaitAll(layersAugmentQueueFinish);
+
+};

lib/cartodb/monitoring/health_check.js

@@ -0,0 +1,19 @@
+var fs = require('fs');
+
+function HealthCheck(disableFile) {
+    this.disableFile = disableFile;
+}
+
+module.exports = HealthCheck;
+
+
+HealthCheck.prototype.check = function(callback) {
+    fs.readFile(this.disableFile, function handleDisabledFile(err, data) {
+        var disabledError = null;
+        if (!err) {
+            disabledError = new Error(data || 'Unknown error');
+            disabledError.http_status = 503;
+        }
+        return callback(disabledError);
+    });
+};

lib/cartodb/server.js

@@ -0,0 +1,315 @@
+var express = require('express');
+var bodyParser = require('body-parser');
+var RedisPool = require('redis-mpool');
+var cartodbRedis = require('cartodb-redis');
+var _ = require('underscore');
+
+var controller = require('./controllers');
+
+var SurrogateKeysCache = require('./cache/surrogate_keys_cache');
+var NamedMapsCacheEntry = require('./cache/model/named_maps_entry');
+var VarnishHttpCacheBackend = require('./cache/backend/varnish_http');
+var FastlyCacheBackend = require('./cache/backend/fastly');
+
+var StatsClient = require('./stats/client');
+var Profiler = require('./stats/profiler_proxy');
+var RendererStatsReporter = require('./stats/reporter/renderer');
+
+var windshaft = require('windshaft');
+var mapnik = windshaft.mapnik;
+
+var TemplateMaps = require('./backends/template_maps.js');
+var QueryTablesApi = require('./api/query_tables_api');
+var OverviewsMetadataApi = require('./api/overviews_metadata_api');
+var UserLimitsApi = require('./api/user_limits_api');
+var AuthApi = require('./api/auth_api');
+var LayergroupAffectedTablesCache = require('./cache/layergroup_affected_tables');
+var NamedMapProviderCache = require('./cache/named_map_provider_cache');
+var PgQueryRunner = require('./backends/pg_query_runner');
+var PgConnection = require('./backends/pg_connection');
+
+var timeoutErrorTilePath = __dirname + '/../../assets/render-timeout-fallback.png';
+var timeoutErrorTile = require('fs').readFileSync(timeoutErrorTilePath, {encoding: null});
+
+
+module.exports = function(serverOptions) {
+    // Make stats client globally accessible
+    global.statsClient = StatsClient.getInstance(serverOptions.statsd);
+
+    var redisPool = new RedisPool(_.defaults(global.environment.redis, {
+        name: 'windshaft-server',
+        unwatchOnRelease: false,
+        noReadyCheck: true
+    }));
+
+    redisPool.on('status', function(status) {
+        var keyPrefix = 'windshaft.redis-pool.' + status.name + '.db' + status.db + '.';
+        global.statsClient.gauge(keyPrefix + 'count', status.count);
+        global.statsClient.gauge(keyPrefix + 'unused', status.unused);
+        global.statsClient.gauge(keyPrefix + 'waiting', status.waiting);
+    });
+
+    var metadataBackend = cartodbRedis({pool: redisPool});
+    var pgConnection = new PgConnection(metadataBackend);
+    var pgQueryRunner = new PgQueryRunner(pgConnection);
+    var queryTablesApi = new QueryTablesApi(pgQueryRunner);
+    var overviewsMetadataApi = new OverviewsMetadataApi(pgQueryRunner);
+    var userLimitsApi = new UserLimitsApi(metadataBackend, {
+        limits: {
+            cacheOnTimeout: serverOptions.renderer.mapnik.limits.cacheOnTimeout || false,
+            render: serverOptions.renderer.mapnik.limits.render || 0
+        }
+    });
+
+    var templateMaps = new TemplateMaps(redisPool, {
+        max_user_templates: global.environment.maxUserTemplates
+    });
+
+    var surrogateKeysCache = new SurrogateKeysCache(surrogateKeysCacheBackends(serverOptions));
+
+    function invalidateNamedMap (owner, templateName) {
+        var startTime = Date.now();
+        surrogateKeysCache.invalidate(new NamedMapsCacheEntry(owner, templateName), function(err) {
+            var logMessage = JSON.stringify({
+                username: owner,
+                type: 'named_map_invalidation',
+                elapsed: Date.now() - startTime,
+                error: !!err ? JSON.stringify(err.message) : undefined
+            });
+            if (err) {
+                global.logger.warn(logMessage);
+            } else {
+                global.logger.info(logMessage);
+            }
+        });
+    }
+    ['update', 'delete'].forEach(function(eventType) {
+        templateMaps.on(eventType, invalidateNamedMap);
+    });
+
+    serverOptions.grainstore.mapnik_version = mapnikVersion(serverOptions);
+
+    validateOptions(serverOptions);
+
+    bootstrapFonts(serverOptions);
+
+    // initialize express server
+    var app = bootstrap(serverOptions);
+    // Extend windshaft with all the elements of the options object
+    _.extend(app, serverOptions);
+
+    var mapStore  = new windshaft.storage.MapStore({
+        pool: redisPool,
+        expire_time: serverOptions.grainstore.default_layergroup_ttl
+    });
+
+    var onTileErrorStrategy;
+    if (global.environment.enabledFeatures.onTileErrorStrategy !== false) {
+        onTileErrorStrategy = function onTileErrorStrategy$TimeoutTile(err, tile, headers, stats, format, callback) {
+            if (err && err.message === 'Render timed out' && format === 'png') {
+                return callback(null, timeoutErrorTile, { 'Content-Type': 'image/png' }, {});
+            } else {
+                return callback(err, tile, headers, stats);
+            }
+        };
+    }
+
+    var rendererFactory = new windshaft.renderer.Factory({
+        onTileErrorStrategy: onTileErrorStrategy,
+        mapnik: {
+            redisPool: redisPool,
+            grainstore: serverOptions.grainstore,
+            mapnik: serverOptions.renderer.mapnik
+        },
+        http: serverOptions.renderer.http
+    });
+
+    // initialize render cache
+    var rendererCacheOpts = _.defaults(serverOptions.renderCache || {}, {
+        ttl: 60000, // 60 seconds TTL by default
+        statsInterval: 60000 // reports stats every milliseconds defined here
+    });
+    var rendererCache = new windshaft.cache.RendererCache(rendererFactory, rendererCacheOpts);
+    var rendererStatsReporter = new RendererStatsReporter(rendererCache, rendererCacheOpts.statsInterval);
+    rendererStatsReporter.start();
+
+    var attributesBackend = new windshaft.backend.Attributes();
+    var previewBackend = new windshaft.backend.Preview(rendererCache);
+    var tileBackend = new windshaft.backend.Tile(rendererCache);
+    var mapValidatorBackend = new windshaft.backend.MapValidator(tileBackend, attributesBackend);
+    var mapBackend = new windshaft.backend.Map(rendererCache, mapStore, mapValidatorBackend);
+
+    var layergroupAffectedTablesCache = new LayergroupAffectedTablesCache();
+    app.layergroupAffectedTablesCache = layergroupAffectedTablesCache;
+
+    var namedMapProviderCache = new NamedMapProviderCache(templateMaps, pgConnection, userLimitsApi, queryTablesApi);
+    ['update', 'delete'].forEach(function(eventType) {
+        templateMaps.on(eventType, namedMapProviderCache.invalidate.bind(namedMapProviderCache));
+    });
+
+    var authApi = new AuthApi(pgConnection, metadataBackend, mapStore, templateMaps);
+
+    var TablesExtentApi = require('./api/tables_extent_api');
+    var tablesExtentApi = new TablesExtentApi(pgQueryRunner);
+
+    /*******************************************************************************************************************
+     * Routing
+     ******************************************************************************************************************/
+
+    new controller.Layergroup(
+        authApi,
+        pgConnection,
+        mapStore,
+        tileBackend,
+        previewBackend,
+        attributesBackend,
+        new windshaft.backend.Widget(),
+        surrogateKeysCache,
+        userLimitsApi,
+        queryTablesApi,
+        layergroupAffectedTablesCache
+    ).register(app);
+
+    new controller.Map(
+        authApi,
+        pgConnection,
+        templateMaps,
+        mapBackend,
+        metadataBackend,
+        queryTablesApi,
+        overviewsMetadataApi,
+        surrogateKeysCache,
+        userLimitsApi,
+        layergroupAffectedTablesCache
+    ).register(app);
+
+    new controller.NamedMaps(
+        authApi,
+        pgConnection,
+        namedMapProviderCache,
+        tileBackend,
+        previewBackend,
+        surrogateKeysCache,
+        tablesExtentApi,
+        metadataBackend
+    ).register(app);
+
+    new controller.NamedMapsAdmin(authApi, pgConnection, templateMaps).register(app);
+
+    new controller.ServerInfo().register(app);
+
+    /*******************************************************************************************************************
+     * END Routing
+     ******************************************************************************************************************/
+
+    return app;
+};
+
+function validateOptions(opts) {
+    if (!_.isString(opts.base_url) || !_.isString(opts.base_url_mapconfig) || !_.isString(opts.base_url_templated)) {
+        throw new Error("Must initialise server with: 'base_url'/'base_url_mapconfig'/'base_url_templated' URLs");
+    }
+
+    // Be nice and warn if configured mapnik version is != instaled mapnik version
+    if (mapnik.versions.mapnik !== opts.grainstore.mapnik_version) {
+        console.warn('WARNING: detected mapnik version (' + mapnik.versions.mapnik + ')' +
+            ' != configured mapnik version (' + opts.grainstore.mapnik_version + ')');
+    }
+}
+
+function bootstrapFonts(opts) {
+    // Set carto renderer configuration for MMLStore
+    opts.grainstore.carto_env = opts.grainstore.carto_env || {};
+    var cenv = opts.grainstore.carto_env;
+    cenv.validation_data = cenv.validation_data || {};
+    if ( ! cenv.validation_data.fonts ) {
+        mapnik.register_system_fonts();
+        mapnik.register_default_fonts();
+        cenv.validation_data.fonts = _.keys(mapnik.fontFiles());
+    }
+}
+
+function bootstrap(opts) {
+    var app;
+    if (_.isObject(opts.https)) {
+        // use https if possible
+        app = express.createServer(opts.https);
+    } else {
+        // fall back to http by default
+        app = express();
+    }
+    app.enable('jsonp callback');
+    app.disable('x-powered-by');
+    app.disable('etag');
+    app.use(bodyParser.json());
+
+    app.use(function bootstrap$prepareRequestResponse(req, res, next) {
+        req.context = req.context || {};
+        req.profiler = new Profiler({
+            statsd_client: global.statsClient,
+            profile: opts.useProfiler
+        });
+
+        if (global.environment && global.environment.api_hostname) {
+            res.set('X-Served-By-Host', global.environment.api_hostname);
+        }
+
+        next();
+    });
+
+    // temporary measure until we upgrade to newer version expressjs so we can check err.status
+    app.use(function(err, req, res, next) {
+        if (err) {
+            if (err.name === 'SyntaxError') {
+                res.status(400).json({ errors: [err.name + ': ' + err.message] });
+            } else {
+                next(err);
+            }
+        } else {
+            next();
+        }
+    });
+
+    setupLogger(app, opts);
+
+    return app;
+}
+
+function setupLogger(app, opts) {
+    if (global.log4js && opts.log_format) {
+        var loggerOpts = {
+            // Allowing for unbuffered logging is mainly
+            // used to avoid hanging during unit testing.
+            // TODO: provide an explicit teardown function instead,
+            //       releasing any event handler or timer set by
+            //       this component.
+            buffer: !opts.unbuffered_logging,
+            // optional log format
+            format: opts.log_format
+        };
+        app.use(global.log4js.connectLogger(global.log4js.getLogger(), _.defaults(loggerOpts, {level: 'info'})));
+    }
+}
+
+function surrogateKeysCacheBackends(serverOptions) {
+    var cacheBackends = [];
+
+    if (serverOptions.varnish_purge_enabled) {
+        cacheBackends.push(
+            new VarnishHttpCacheBackend(serverOptions.varnish_host, serverOptions.varnish_http_port)
+        );
+    }
+
+    if (serverOptions.fastly &&
+        !!serverOptions.fastly.enabled && !!serverOptions.fastly.apiKey && !!serverOptions.fastly.serviceId) {
+        cacheBackends.push(
+            new FastlyCacheBackend(serverOptions.fastly.apiKey, serverOptions.fastly.serviceId)
+        );
+    }
+
+    return cacheBackends;
+}
+
+function mapnikVersion(opts) {
+    return opts.grainstore.mapnik_version || mapnik.versions.mapnik;
+}

lib/cartodb/server_options.js

@@ -1,726 +1,96 @@
-var   _          = require('underscore')
-    , Step       = require('step')
-    , cartoData  = require('cartodb-redis')(global.environment.redis)
-    , Cache = require('./cache_validator')
-    , mapnik     = require('mapnik')
-    , crypto     = require('crypto')
-    , request    = require('request')
-    , LZMA       = require('lzma/lzma_worker.js').LZMA
-  ;
+var os = require('os');
+var _ = require('underscore');
+var OverviewsQueryRewriter = require('./utils/overviews_query_rewriter');
 
-// This is for backward compatibility with 1.3.3
-if ( _.isUndefined(global.environment.sqlapi.domain) ) {
-  global.environment.sqlapi.domain = global.environment.sqlapi.host;
+var overviewsQueryRewriter = new OverviewsQueryRewriter({
+  zoom_level: 'CDB_ZoomFromScale(!scale_denominator!)'
+});
+
+var rendererConfig = _.defaults(global.environment.renderer || {}, {
+    cache_ttl: 60000, // milliseconds
+    statsInterval: 60000,
+    mapnik: {
+        poolSize: 8,
+        metatile: 2,
+        bufferSize: 64,
+        snapToGrid: false,
+        clipByBox2d: false,
+        limits: {}
+    },
+    http: {}
+});
+
+rendererConfig.mapnik.queryRewriter = overviewsQueryRewriter;
+
+// Perform keyword substitution in statsd
+// See https://github.com/CartoDB/Windshaft-cartodb/issues/153
+if ( global.environment.statsd ) {
+    if ( global.environment.statsd.prefix ) {
+        var host_token = os.hostname().split('.').reverse().join('.');
+        global.environment.statsd.prefix = global.environment.statsd.prefix.replace(/:host/, host_token);
+    }
 }
 
-module.exports = function(){
+module.exports = {
+    bind: {
+        port: global.environment.port,
+        host: global.environment.host
+    },
+        // This is for inline maps and table maps
+        base_url: global.environment.base_url_legacy || '/tiles/:table',
 
-    var rendererConfig = _.defaults(global.environment.renderer || {}, {
-      cache_ttl: 60000, // milliseconds
-      metatile: 4,
-      bufferSize: 64
-    });
+        /// @deprecated with Windshaft-0.17.0
+        ///base_url_notable: '/tiles',
+
+        // This is for Detached maps
+        //
+        // "maps" is the official, while
+        // "tiles/layergroup" is for backward compatibility up to 1.6.x
+        //
+        base_url_mapconfig: global.environment.base_url_detached || '(?:/maps|/tiles/layergroup)',
+
+        base_url_templated: global.environment.base_url_templated || '(?:/maps/named|/tiles/template)',
 
-    var me = {
-        base_url: '/tiles/:table',
-        base_url_notable: '/tiles',
         grainstore: {
+          map: {
+            // TODO: allow to specify in configuration
+            srid: 3857
+          },
           datasource: global.environment.postgres,
           cachedir: global.environment.millstone.cache_basedir,
-          mapnik_version: global.environment.mapnik_version || mapnik.versions.mapnik,
-          default_layergroup_ttl: 7200, // seconds (default is 300)
-          gc_prob: 0.01 // default is 0.01 TODO: make configurable via env config
-        },
-        mapnik: {
-          metatile: rendererConfig.metatile,
-          bufferSize: rendererConfig.bufferSize
+          mapnik_version: global.environment.mapnik_version,
+          mapnik_tile_format: global.environment.mapnik_tile_format || 'png',
+          default_layergroup_ttl: global.environment.mapConfigTTL || 7200
         },
+        statsd: global.environment.statsd,
         renderCache: {
-          ttl: rendererConfig.cache_ttl
+            ttl: rendererConfig.cache_ttl,
+            statsInterval: rendererConfig.statsInterval
         },
-        redis: global.environment.redis,
+        renderer: {
+            mapnik: _.defaults(rendererConfig.mapnik, {
+                geojson: {
+                    dbPoolParams: {
+                          size: 16,
+                          idleTimeout: 3000,
+                          reapInterval: 1000
+                    },
+                    clipByBox2d: false,
+                }
+            }),
+            torque: rendererConfig.torque,
+            http: rendererConfig.http
+        },
+        // Do not send unwatch on release. See http://github.com/CartoDB/Windshaft-cartodb/issues/161
+        redis: _.extend(global.environment.redis, {unwatchOnRelease: false}),
         enable_cors: global.environment.enable_cors,
         varnish_host: global.environment.varnish.host,
         varnish_port: global.environment.varnish.port,
+        varnish_http_port: global.environment.varnish.http_port,
+        varnish_secret: global.environment.varnish.secret,
+        varnish_purge_enabled: global.environment.varnish.purge_enabled,
+        fastly: global.environment.fastly || {},
         cache_enabled: global.environment.cache_enabled,
         log_format: global.environment.log_format,
         useProfiler: global.environment.useProfiler
-    };
-
-    // Be nice and warn if configured mapnik version
-    // is != instaled mapnik version
-    if ( mapnik.versions.mapnik != me.grainstore.mapnik_version ) {
-      console.warn("WARNING: detected mapnik version ("
-        + mapnik.versions.mapnik + ") != configured mapnik version ("
-        + me.grainstore.mapnik_version + ")");
-    }
-
-/* This whole block is about generating X-Cache-Channel { */
-
-    // TODO: review lifetime of elements of this cache
-    // NOTE: by-token indices should only be dropped when
-    //       the corresponding layegroup is dropped, because
-    //       we have no SQL after layer creation.
-    me.channelCache = {};
-
-    // Run a query through the SQL api
-    me.sqlQuery = function (username, api_key, sql, callback) {
-      var api = global.environment.sqlapi;
-
-      // build up api string
-      var sqlapi = api.protocol + '://' + username;
-      if ( api.domain ) sqlapi += '.' + api.domain;
-      sqlapi += ':' + api.port + '/api/' + api.version + '/sql'
-
-      var qs  = { q: sql }
-
-      // add api_key if given
-      if (_.isString(api_key) && api_key != '') { qs.api_key = api_key; }
-
-      // call sql api
-      //
-      // NOTE: using POST to avoid size limits:
-      // Seehttp://github.com/CartoDB/Windshaft-cartodb/issues/111
-      //
-      // TODO: use "host" header to allow IP based specification
-      //       of sqlapi address (and avoid a DNS lookup)
-      //
-      request.post({url:sqlapi, body:qs, json:true},
-        function(err, res, body){
-          if (err){
-            console.log('ERROR connecting to SQL API on ' + sqlapi + ': ' + err);
-            callback(err);
-            return;
-          }
-          if (res.statusCode != 200) {
-              var msg = res.body.error ? res.body.error : res.body;
-              callback(new Error(msg));
-              console.log('unexpected response status (' + res.statusCode + ') for sql query: ' + sql + ': ' + msg);
-              return;
-          }
-          callback(null, body.rows);
-      });
-    };
-
-    //
-    // Invoke callback with number of milliseconds since
-    // last update in any of the given tables
-    //
-    me.findLastUpdated = function (username, api_key, tableNames, callback) {
-      var sql = 'SELECT EXTRACT(EPOCH FROM max(updated_at)) as max FROM CDB_TableMetadata m WHERE m.tabname::name = any (\'{'
-        + tableNames.join(',') + '}\')';
-
-      // call sql api
-      me.sqlQuery(username, api_key, sql, function(err, rows){
-          if (err){
-            var msg = err.message ? err.message : err;
-            callback(new Error('could not find last updated timestamp: ' + msg));
-            return;
-          }
-          // when the table has not updated_at means it hasn't been changed so a default last_updated is set
-          var last_updated = 0;
-          if(rows.length !== 0) {
-            last_updated = rows[0].max || 0;
-          }
-          callback(null, last_updated*1000);
-      });
-    };
-
-    me.affectedTables = function (username, api_key, sql, callback) {
-
-      // Replace mapnik tokens
-      sql = sql.replace(RegExp('!bbox!', 'g'), 'ST_MakeEnvelope(0,0,0,0)')
-               .replace(RegExp('!pixel_width!', 'g'), '1')
-               .replace(RegExp('!pixel_height!', 'g'), '1')
-            ;
-
-      // Pass to CDB_QueryTables
-      sql = 'SELECT CDB_QueryTables($windshaft$' + sql + '$windshaft$)';
-
-      // call sql api
-      me.sqlQuery(username, api_key, sql, function(err, rows){
-          if (err){
-            var msg = err.message ? err.message : err;
-            callback(new Error('could not fetch source tables: ' + msg));
-            return;
-          }
-          var qtables = rows[0].cdb_querytables;
-          var tableNames = qtables.split(/^\{(.*)\}$/)[1];
-          tableNames = tableNames.split(',');
-          callback(null, tableNames);
-      });
-    };
-
-    me.buildCacheChannel = function (dbName, tableNames){
-      return dbName + ':' + tableNames.join(',');
-    };
-
-    me.generateMD5 = function(data){
-        var hash = crypto.createHash('md5');
-        hash.update(data);
-        return hash.digest('hex');
-    }
-
-    me.generateCacheChannel = function(req, callback){
-
-      // use key to call sql api with sql request if present, else
-      // just return dbname and table name base key
-      var dbName     = req.params.dbname;
-
-      var cacheKey = [ dbName ];
-      if ( req.params.token ) cacheKey.push(req.params.token);
-      else if ( req.params.sql ) cacheKey.push( me.generateMD5(req.params.sql) );
-      cacheKey = cacheKey.join(':');
-
-      if ( me.channelCache.hasOwnProperty(cacheKey) ) {
-        callback(null, me.channelCache[cacheKey]);
-        return;
-      }
-      else if ( req.params.token ) {
-        // cached cache channel for token-based access should be constructed
-        // at cache creation time
-        callback(new Error('missing channel cache for token ' + req.params.token));
-        return;
-      }
-
-      if ( ! req.params.sql && ! req.params.token ) {
-        var cacheChannel = me.buildCacheChannel(dbName, [req.params.table]);
-        // not worth caching this
-        callback(null, cacheChannel);
-        return;
-      }
-
-      if ( ! req.params.sql ) {
-        callback(new Error("this request doesn't need an X-Cache-Channel generated"));
-        return;
-      }
-
-      var dbName     = req.params.dbname;
-      var username   = this.userByReq(req);
-
-      // strip out windshaft/mapnik inserted sql if present
-      var sql = req.params.sql.match(/^\((.*)\)\sas\scdbq$/);
-      sql = (sql != null) ? sql[1] : req.params.sql;
-
-      me.affectedTables(username, req.params.map_key, sql, function(err, tableNames) {
-          if ( err ) { callback(err); return; }
-          var cacheChannel = me.buildCacheChannel(dbName,tableNames);
-          me.channelCache[cacheKey] = cacheChannel; // store for caching
-          callback(null, cacheChannel);
-      });
-    };
-
-    // Set the cache chanel info to invalidate the cache on the frontend server
-    //
-    // @param req The request object.
-    //            The function will have no effect unless req.res exists.
-    //            It is expected that req.params contains 'table' and 'dbname'
-    //
-    // @param cb function(err, channel) will be called when ready.
-    //           the channel parameter will be null if nothing was added
-    //
-    me.addCacheChannel = function(req, cb) {
-        // skip non-GET requests, or requests for which there's no response
-        if ( req.method != 'GET' || ! req.res ) { cb(null, null); return; }
-        var res = req.res;
-        var cache_policy = req.query.cache_policy;
-        if ( req.params.token ) cache_policy = 'persist';
-        if ( cache_policy == 'persist' ) {
-          res.header('Cache-Control', 'public,max-age=31536000'); // 1 year
-        } else {
-          var ttl = global.environment.varnish.ttl || 86400;
-          res.header('Cache-Control', 'no-cache,max-age='+ttl+',must-revalidate, public');
-        }
-
-        // Set Last-Modified header
-        var lastUpdated;
-        if ( req.params.cache_buster ) {
-          // Assuming cache_buster is a timestamp
-          // FIXME: store lastModified in the cache channel instead
-          lastUpdated = new Date(parseInt(req.params.cache_buster));
-        } else {
-          lastUpdated = new Date();
-        }
-        res.header('Last-Modified', lastUpdated.toUTCString());
-
-        me.generateCacheChannel(req, function(err, channel){
-            if ( ! err ) {
-              res.header('X-Cache-Channel', channel);
-              cb(null, channel);
-            } else {
-              console.log('ERROR generating cache channel: ' + ( err.message ? err.message : err ));
-              // TODO: evaluate if we should bubble up the error instead
-              cb(null, 'ERROR');
-            }
-        });
-    };
-
-    me.afterLayergroupCreate = function(req, mapconfig, response, callback) {
-        var token = response.layergroupid;
-
-        var username = this.userByReq(req);
-
-        var tasksleft = 2; // redis key and affectedTables
-        var errors = [];
-
-        var done = function(err) {
-          if ( err ) {
-            errors.push('' + err);
-          }
-          if ( ! --tasksleft ) {
-            err = errors.length ? new Error(errors.join('\n')) : null;
-            callback(err);
-          }
-        }
-
-        // Don't wait for the mapview count increment to
-        // take place before proceeding. Error will be logged
-        // asyncronously
-        cartoData.incMapviewCount(username, mapconfig.stat_tag, function(err) {
-          if (req.profiler) req.profiler.done('incMapviewCount');
-          if ( err ) console.log("ERROR: failed to increment mapview count for user '" + username + "': " + err);
-          done();
-        });
-
-        var sql = [];
-        _.each(mapconfig.layers, function(lyr) {
-          sql.push(lyr.options.sql);
-        });
-        sql = sql.join(';');
-
-        var dbName = req.params.dbname;
-        var usr    = this.userByReq(req);
-        var key    = req.params.map_key || req.params.api_key;
-
-        var cacheKey = dbName + ':' + token;
-
-        me.affectedTables(usr, key, sql, function(err, tableNames) {
-            if (req.profiler) req.profiler.done('affectedTables');
-
-            if ( err ) { done(err); return; }
-            var cacheChannel = me.buildCacheChannel(dbName,tableNames);
-            me.channelCache[cacheKey] = cacheChannel; // store for caching
-            // find last updated
-            me.findLastUpdated(usr, key, tableNames, function(err, lastUpdated) {
-              if (req.profiler) req.profiler.done('findLastUpdated');
-              if ( err ) { done(err); return; }
-              response.layergroupid = response.layergroupid + ':' + lastUpdated; // use epoch
-              response.last_updated = new Date(lastUpdated).toISOString(); // TODO: use ISO format
-              done(null);
-            });
-        });
-    };
-
-/* X-Cache-Channel generation } */
-
-    me.re_userFromHost = new RegExp(
-      global.environment.user_from_host ||
-      '^([^\\.]+)\\.' // would extract "strk" from "strk.cartodb.com"
-    );
-
-    me.userByReq = function(req) {
-      var host = req.headers.host;
-      var mat = host.match(this.re_userFromHost);
-      if ( ! mat ) {
-        console.error("ERROR: user pattern '" + this.re_userFromHost
-          + "' does not match hostname '" + host + "'");
-        return;
-      }
-      // console.log("Matches: "); console.dir(mat);
-      if ( ! mat.length === 2 ) {
-        console.error("ERROR: pattern '" + this.re_userFromHost
-          + "' gave unexpected matches against '" + host + "': " + mat);
-        return;
-      }
-      return mat[1];
-    }
-
-    // Set db authentication parameters to those of the given username
-    //
-    // @param username the cartodb username, mapped to a database username
-    //                 via CartodbRedis metadata records
-    //
-    // @param params the parameters to set auth options into
-    //               added params are: "dbuser" and "dbpassword"
-    //
-    // @param callback function(err) 
-    //
-    me.setDBAuth = function(username, params, callback) {
-
-      var user_params = {};
-      var auth_user = global.environment.postgres_auth_user;
-      var auth_pass = global.environment.postgres_auth_pass;
-      Step(
-        function getId() {
-          cartoData.getUserId(username, this);
-        },
-        function(err, user_id) {
-          if (err) throw err;
-          user_params['user_id'] = user_id;
-          var dbuser = _.template(auth_user, user_params);
-          _.extend(params, {dbuser:dbuser});
-
-          // skip looking up user_password if postgres_auth_pass
-          // doesn't contain the "user_password" label 
-          if (!auth_pass || ! auth_pass.match(/\buser_password\b/) ) return null;
-
-          cartoData.getUserDBPass(username, this);
-        },
-        function(err, user_password) {
-          if (err) throw err;
-          user_params['user_password'] = user_password;
-          if ( auth_pass ) {
-            var dbpass = _.template(auth_pass, user_params);
-            _.extend(params, {dbpassword:dbpass});
-          }
-          return true;
-        },
-        function finish(err) {
-          callback(err); 
-        }
-      );
-    };
-
-    // Set db connection parameters to those for the given username
-    //
-    // @param dbowner cartodb username of database owner,
-    //                mapped to a database username
-    //                via CartodbRedis metadata records
-    //
-    // @param params the parameters to set connection options into
-    //               added params are: "dbname", "dbhost"
-    //
-    // @param callback function(err) 
-    //
-    me.setDBConn = function(dbowner, params, callback) {
-      Step(
-        function getDatabaseHost(){
-            cartoData.getUserDBHost(dbowner, this);
-        },
-        function getDatabase(err, data){
-            if(err) throw err;
-            if ( data ) _.extend(params, {dbhost:data});
-            cartoData.getUserDBName(dbowner, this);
-        },
-        function getGeometryType(err, data){
-            if (err) throw err;
-            if ( data ) _.extend(params, {dbname:data});
-            return null;
-        },
-        function finish(err) {
-          callback(err); 
-        }
-      );
-    };
-
-
-    // Check if a request is authorized by a signer
-    //
-    // Any existing signature for the given request will verified
-    // for authorization to this specific request (may require auth_token)
-    // See https://github.com/CartoDB/Windshaft-cartodb/wiki/Signed-maps
-    //
-    // @param req express request object
-    // @param callback function(err, signed_by) signed_by will be
-    //                 null if the request is not signed by anyone
-    //                 or will be a string cartodb username otherwise.
-    //                 
-    me.authorizedBySigner = function(req, callback)
-    {
-      if ( ! req.params.token || ! req.params.signer ) {
-        //console.log("No signature provided"); // debugging
-        callback(null, null); // no signer requested
-        return;
-      }
-
-      var signer = req.params.signer;
-      var layergroup_id = req.params.token;
-      var auth_token = req.params.auth_token;
-
-console.log("Checking authorization from signer " + signer + " for resource " + layergroup_id + " with auth_token " + auth_token);
-
-      me.signedMaps.isAuthorized(signer, layergroup_id, auth_token,
-        function(err, authorized) {
-          callback(err, authorized ? signer : null);
-        });
-    };
-
-    // Check if a request is authorized by api_key
-    //
-    // @param req express request object
-    // @param callback function(err, authorized) 
-    //                 
-    me.authorizedByAPIKey = function(req, callback)
-    {
-        var user = me.userByReq(req);
-        Step(
-          function (){
-              cartoData.getUserMapKey(user, this);
-          },
-          function checkApiKey(err, val){
-              if (err) throw err;
-
-              var valid = 0;
-              if ( val ) {
-                if ( val == req.query.map_key ) valid = 1;
-                else if ( val == req.query.api_key ) valid = 1;
-                // check also in request body
-                else if ( req.body && req.body.map_key && val == req.body.map_key ) valid = 1;
-                else if ( req.body && req.body.api_key && val == req.body.api_key ) valid = 1;
-              }
-              return valid;
-          },
-          function finish(err, authorized) {
-              callback(err, authorized);
-          }
-        );
-    };
-
-    /**
-     * Check access authorization
-     *
-     * @param req - standard req object. Importantly contains table and host information
-     * @param callback function(err, allowed) is access allowed not?
-     */
-    me.authorize = function(req, callback) {
-        var that = this;
-        var user = me.userByReq(req);
-
-        Step(
-            function (){
-                that.authorizedByAPIKey(req, this);
-            },
-            function checkApiKey(err, authorized){
-                if (err) throw err;
-
-                // if not authorized by api_key, continue 
-                if (authorized !== 1)  {
-                  // not authorized by api_key, 
-                  // check if authorized by signer
-                  that.authorizedBySigner(req, this);
-                  return;
-                }
-
-                // authorized by api key, login as the given username and stop
-                that.setDBAuth(user, req.params, function(err) {
-                  callback(err, true); // authorized (or error)
-                });
-            },
-            function checkSignAuthorized(err, signed_by){
-                if (err) throw err;
-
-                if ( ! signed_by ) {
-                  // request not authorized by signer, continue
-                  // to check map privacy
-                  return null;
-                }
-
-                // Authorized by "signed_by" !
-                that.setDBAuth(signed_by, req.params, function(err) {
-                  callback(err, true); // authorized (or error)
-                });
-            },
-            function getDatabase(err){
-                if (err) throw err;
-                // NOTE: only used to get to table privacy
-                cartoData.getUserDBName(user, this);
-            },
-            function getPrivacy(err, dbname){
-                if (err) throw err;
-                cartoData.getTablePrivacy(dbname, req.params.table, this);
-            },
-            function(err, privacy){
-                callback(err, privacy);
-            }
-        );
-    };
-
-    /**
-     * Whitelist input and get database name & default geometry type from
-     * subdomain/user metadata held in CartoDB Redis
-     * @param req - standard express request obj. Should have host & table
-     * @param callback
-     */
-    me.req2params = function(req, callback){
-
-        if ( req.query.lzma ) {
-
-          // TODO: check ?
-          //console.log("type of req.query.lzma is " + typeof(req.query.lzma));
-
-          // Decode (from base64)
-          var lzma = (new Buffer(req.query.lzma, 'base64').toString('binary')).split('').map(function(c) { return c.charCodeAt(0) - 128 })
-
-          // Decompress
-          LZMA.decompress(
-            lzma,
-            function(result) {
-              if (req.profiler) req.profiler.done('LZMA decompress');
-              try {
-                delete req.query.lzma
-                _.extend(req.query, JSON.parse(result))
-                me.req2params(req, callback);
-              } catch (err) {
-                callback(new Error('Error parsing lzma as JSON: ' + err));
-              }
-            },
-            function(percent) { // progress
-              //console.log("LZMA decompression " + percent + "%");
-            }
-          );
-          return;
-        }
-
-        // Whitelist query parameters and attach format
-        var good_query = ['sql', 'geom_type', 'cache_buster', 'cache_policy', 'callback', 'interactivity', 'map_key', 'api_key', 'auth_token', 'style', 'style_version', 'style_convert', 'config' ];
-        var bad_query  = _.difference(_.keys(req.query), good_query);
-
-        _.each(bad_query, function(key){ delete req.query[key]; });
-        req.params =  _.extend({}, req.params); // shuffle things as request is a strange array/object
-
-        if ( req.params.token ) {
-          //console.log("Request parameters include token " + req.params.token);
-          var tksplit = req.params.token.split(':');
-          req.params.token = tksplit[0];
-          if ( tksplit.length > 1 ) req.params.cache_buster= tksplit[1];
-          tksplit = req.params.token.split('@');
-          if ( tksplit.length > 1 ) {
-            req.params.signer = this.userByReq(req);
-            if ( tksplit[0] ) req.params.signer = tksplit[0];
-            req.params.token = tksplit[1];
-            //console.log("Request for token " + req.params.token + " with signature from " + req.params.signer);
-          }
-        }
-
-        // bring all query values onto req.params object
-        _.extend(req.params, req.query);
-
-        // for cartodb, ensure interactivity is cartodb_id or user specified
-        req.params.interactivity = req.params.interactivity || 'cartodb_id';
-
-        var that = this;
-
-        if (req.profiler) req.profiler.done('req2params.setup');
-
-        var user = me.userByReq(req);
-
-        Step(
-            function getPrivacy(){
-                me.authorize(req, this);
-            },
-            function gatekeep(err, data){
-                if (req.profiler) req.profiler.done('authorize');
-                if(err) throw err;
-                if(data === "0") throw new Error("Sorry, you are unauthorized (permission denied)");
-                return data;
-            },
-            function getDatabase(err, data){
-                if(err) throw err;
-                that.setDBConn(user, req.params, this);
-            },
-            function getGeometryType(err){
-                if (req.profiler) req.profiler.done('cartoData.getDatabase');
-                if (err) throw err;
-                cartoData.getTableGeometryType(req.params.dbname, req.params.table, this);
-            },
-            function finishSetup(err, data){
-                if (req.profiler) req.profiler.done('cartoData.getGeometryType');
-                if ( err ) { callback(err, req); return; }
-
-                if (!_.isNull(data))
-                    _.extend(req.params, {geom_type: data});
-
-                that.addCacheChannel(req, function(err) {
-                  if (req.profiler) req.profiler.done('addCacheChannel');
-                  callback(err, req);
-                });
-            }
-        );
-    };
-
-    /**
-     * Little helper method to get the current list of infowindow variables and return to client
-     * @param req
-     * @param callback
-     */
-    me.getInfowindow = function(req, callback){
-        var that = this;
-        var user = me.userByReq(req);
-
-        Step(
-            function(){
-                // TODO: if this step really needed ?
-                that.req2params(req, this);
-            },
-            function getDatabase(err){
-                if (err) throw err;
-                cartoData.getUserDBName(user, this);
-            },
-            function getInfowindow(err, dbname){
-                if (err) throw err;
-                cartoData.getTableInfowindow(dbname, req.params.table, this);
-            },
-            function(err, data){
-                callback(err, data);
-            }
-        );
-    };
-
-    /**
-     * Little helper method to get map metadata and return to client
-     * @param req
-     * @param callback
-     */
-    me.getMapMetadata = function(req, callback){
-        var that = this;
-        var user = me.userByReq(req);
-
-        Step(
-            function(){
-                // TODO: if this step really needed ?
-                that.req2params(req, this);
-            },
-            function getDatabase(err){
-                if (err) throw err;
-                cartoData.getUserDBName(user, this);
-            },
-            function getMapMetadata(err, dbname){
-                if (err) throw err;
-                cartoData.getTableMapMetadata(dbname, req.params.table, this);
-            },
-            function(err, data){
-                callback(err, data);
-            }
-        );
-    };
-
-    /**
-     * Helper to clear out tile cache on request
-     * @param req
-     * @param callback
-     */
-    me.flushCache = function(req, Cache, callback){
-        var that = this;
-
-        Step(
-            function getParams(){
-                // this is mostly to compute req.params.dbname
-                that.req2params(req, this);
-            },
-            function flushInternalCache(err){
-                // TODO: implement this, see
-                // http://github.com/Vizzuality/Windshaft-cartodb/issues/73
-                return true;
-            },
-            function flushVarnishCache(err){
-                if (err) { callback(err); return; }
-                if(Cache) {
-                  Cache.invalidate_db(req.params.dbname, req.params.table);
-                }
-                callback(null, true);
-            }
-        );
-    };
-
-    return me;
-}();
+};

lib/cartodb/signed_maps.js

@@ -1,347 +0,0 @@
-var crypto    = require('crypto');
-var Step      = require('step');
-var _         = require('underscore');
-
-
-// Class handling map signatures and user certificates
-//
-// See https://github.com/CartoDB/Windshaft-cartodb/wiki/Signed-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.
-//
-function SignedMaps(redis_pool) {
-  this.redis_pool = redis_pool;
-
-  // Database containing signatures
-  // TODO: allow configuring ?
-  // NOTE: currently it is the same as
-  //       the one containing layergroups
-  this.db_signatures = 0;
-
-  //
-  // Map signatures in redis are reference to signature certificates
-  // We have the following datastores:
-  //
-  //  1. User certificates: set of per-user authorization certificates
-  //  2. Map signatures: set of per-map certificate references 
-  //  3. Certificate applications: set of per-certificate signed maps
-
-  // User certificates (HASH:crt_id->crt_val)
-  this.key_map_crt = "map_crt|<%= signer %>";
-
-  // Map signatures (SET:crt_id)
-  this.key_map_sig = "map_sig|<%= signer %>|<%= map_id %>";
-  
-  // Certificates applications (SET:map_id)
-  //
-  // Everytime a map is signed, the map identifier (layergroup_id)
-  // is added to this set. The purpose of this set is to drop
-  // all map signatures when a certificate is removed
-  //
-  this.key_crt_sig = "crt_sig|<%= signer %>|<%= crt_id %>";
-
-};
-
-var o = SignedMaps.prototype;
-
-//--------------- PRIVATE METHODS --------------------------------
-
-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);
-    }
-  );
-};
-
-//--------------- PUBLIC API -------------------------------------
-
-// Check if the given certificate authorizes waiver of "auth"
-o.authorizedByCert = function(cert, auth) {
-  //console.log("Checking cert: "); console.dir(cert);
-  if ( cert.version !== "0.0.1" ) {
-    throw new Error("Unsupported certificate version " + cert.version);
-  }
-
-  if ( ! cert.auth ) {
-    throw new Error("No certificate authorization");
-  }
-
-  if ( ! cert.auth.method ) {
-    throw new Error("No certificate authorization method");
-  }
-
-  // Open authentication certificates are always authorized
-  if ( cert.auth.method === 'open' ) return true;
-
-  // Token based authentication requires valid token
-  if ( cert.auth.method === 'token' ) {
-    var found = cert.auth.valid_tokens.indexOf(auth);
-    //if ( found !== -1 ) {
-      //console.log("Token " + auth + " is found at position " + found + " in valid tokens " + cert.auth.valid_tokens);
-    //  return true;
-    //} else return false;
-    return cert.auth.valid_tokens.indexOf(auth) !== -1;
-  }
-
-  throw new Error("Unsupported authentication method: " + cert.auth.method);
-};
-
-// Check if shown credential are authorized to access a map
-// by the given signer.
-//
-// @param signer a signer name (cartodb username)
-// @param map_id a layergroup_id
-// @param auth an authentication token, or undefined if none
-//                    (can still be authorized by signature)
-//
-// @param callback function(Error, Boolean)
-//
-o.isAuthorized = function(signer, map_id, auth, callback) {
-  var that = this;
-  var authorized = false;
-  var certificate_id_list;
-  var missing_certificates = [];
-console.log("Check auth from signer '" + signer + "' on map '" + map_id + "' with auth '" + auth + "'");
-  Step(
-    function getMapSignatures() {
-      var map_sig_key = _.template(that.key_map_sig, {signer:signer, map_id:map_id});
-      that._redisCmd('SMEMBERS', [ map_sig_key ], this);
-    },
-    function getCertificates(err, crt_lst) {
-      if ( err ) throw err;
-      console.log("Map '" + map_id + "' is signed by " + crt_lst.length + " certificates of user '" + signer + "': " + crt_lst);
-      certificate_id_list = crt_lst;
-      if ( ! crt_lst.length ) {
-        // No certs, avoid calling redis with short args list.
-        // Next step expects a list of certificate values so
-        // we directly send the empty list.
-        return crt_lst;
-      }
-      var map_crt_key = _.template(that.key_map_crt, {signer:signer});
-      that._redisCmd('HMGET', [ map_crt_key ].concat(crt_lst), this);
-    },
-    function checkCertificates(err, certs) {
-      if ( err ) throw err;
-      for (var i=0; i<certs.length; ++i) {
-        var crt_id = certificate_id_list[i];
-        if ( _.isNull(certs[i]) ) {
-          missing_certificates.push(crt_id);
-          continue;
-        }
-        var cert;
-        try {
-          //console.log("cert " + crt_id + ": " + certs[i]);
-          cert = JSON.parse(certs[i]);
-          authorized = that.authorizedByCert(cert, auth);
-        } catch (err) {
-          console.log("Certificate " + certificate_id_list[i] + " by user '" + signer + "' is malformed: " + err);
-          continue;
-        }
-        if ( authorized ) {
-          console.log("Access to map '" + map_id + "' authorized by cert '"
-            + certificate_id_list[i] + "' of user '" + signer + "'");
-          //console.dir(cert);
-          break; // no need to further check certs
-        }
-      }
-      return null;
-    },
-    function finish(err) {
-      if ( missing_certificates.length ) {
-        console.log("WARNING: map '" + map_id + "' is signed by '" + signer
-          + "' with " + missing_certificates.length
-          + " missing certificates: "
-          + missing_certificates + " (TODO: give cleanup instructions)");
-      }
-      callback(err, authorized);
-    }
-  );
-};
-
-// Add an authorization certificate from a user.
-//
-// @param signer a signer name (cartodb username)
-// @param cert certificate object, see
-//             http://github.com/CartoDB/Windshaft-cartodb/wiki/Signed-maps
-//
-// @param callback function(err, crt_id) return certificate id
-//
-// TODO: allow for requesting error when certificate already exists ?
-//
-o.addCertificate = function(signer, cert, callback) {
-  var crt_val = JSON.stringify(cert);
-  var crt_id = crypto.createHash('md5').update(crt_val).digest('hex');
-
-  var usr_crt_key = _.template(this.key_map_crt, {signer:signer});
-  this._redisCmd('HSET', [ usr_crt_key, crt_id, crt_val ], function(err, created) {
-    // NOTE: created would be 0 if the field already existed, 1 otherwise
-    callback(err, crt_id);
-  });
-};
-
-// Remove an authorization certificate of a user, also removing
-// any signature made with the certificate.
-//
-// @param signer a signer name (cartodb username)
-// @param crt_id certificate identifier, as returned by addCertificate
-// @param callback function(err)
-//
-o.delCertificate = function(signer, crt_id, callback) {
-  var db = this.db_signatures;
-  var crt_sig_key = _.template(this.key_crt_sig, {signer:signer, crt_id:crt_id});
-  var signed_map_list;
-  var redis_client;
-  var that = this;
-  Step (
-    function getRedisClient() {
-      that._acquireRedis(this);
-    },
-    function removeCertificate(err, data) {
-      if ( err ) throw err;
-      redis_client = data;
-      // Remove the certificate (would be enough to stop authorizing uses)
-      var usr_crt_key = _.template(that.key_map_crt, {signer:signer});
-      redis_client.HDEL(usr_crt_key, crt_id, this);
-    },
-    function getMapSignatures(err, deleted) {
-      if ( err ) throw err;
-      if ( ! deleted ) {
-        // debugging (how can this be possible?)
-        console.log("WARNING: authorization certificate '" + crt_id
-          + "' by user '" + signer + "' did not exist on delete request");
-      }
-      // Get all signatures by this certificate
-      redis_client.SMEMBERS(crt_sig_key, this);
-    },
-    function delMapSignaturesReference(err, map_id_list) {
-      if ( err ) throw err;
-      signed_map_list = map_id_list;
-      console.log("Certificate '" + crt_id + "' from user '" + signer
-        + "' was used to sign " + signed_map_list.length + " maps");
-      redis_client.DEL(crt_sig_key, this);
-    },
-    function delMapSignatures(err) {
-      if ( err ) throw err;
-      var crt_sig_key = _.template(that.key_crt_sig, {signer:signer, crt_id:crt_id});
-      var tx = redis_client.MULTI();
-      for (var i=0; i<signed_map_list.length; ++i) {
-        var map_id = signed_map_list[i];
-        var map_sig_key = _.template(that.key_map_sig, {signer:signer, map_id:map_id});
-        //console.log("Queuing removal of '" + crt_id + "' from '" + map_sig_key + "'");
-        tx.SREM( map_sig_key, crt_id )
-      }
-      tx.EXEC(this);
-    },
-    function reportTransaction(err, rets) {
-      if ( err ) throw err;
-      for (var i=0; i<signed_map_list.length; ++i) {
-        var ret = rets[i];
-        if ( ! ret ) {
-          console.log("No signature with certificate '" + crt_id
-            + "' of user '" + signer + "' found in map '"
-            + signed_map_list[i] + "'");
-        } else {
-          console.log("Signature with certificate '" + crt_id
-            + "' of user '" + signer + "' removed from map '"
-            + signed_map_list[i] + "'");
-        }
-      }
-      return null;
-    },
-    function finish(err) {
-      if ( ! _.isUndefined(redis_client) ) {
-        that._releaseRedis(redis_client);
-      }
-      callback(err);
-    }
-  );
-};
-
-// Sign a map with a certificate reference
-//
-// @param signer a signer name (cartodb username)
-// @param map_id a layergroup_id
-// @param crt_id signature certificate identifier
-//
-// @param callback function(Error) 
-//
-o.signMap = function(signer, map_id, crt_id, callback) {
-  var that = this;
-  Step(
-    function addMapSignature() {
-      var map_sig_key = _.template(that.key_map_sig, {signer:signer, map_id:map_id});
-console.log("Adding " + crt_id + " to " + map_sig_key);
-      that._redisCmd('SADD', [ map_sig_key, crt_id ], this);
-    },
-    function addCertificateUsage(err) {
-      // Add the map to the set of maps signed by the given cert
-      if ( err ) throw err;
-      var crt_sig_key = _.template(that.key_crt_sig, {signer:signer, crt_id:crt_id});
-      that._redisCmd('SADD', [ crt_sig_key, map_id ], this);
-    },
-    function finish(err) {
-      callback(err);
-    }
-  );
-};
-
-// Sign a map with a full certificate
-//
-// @param signer a signer name (cartodb username)
-// @param map_id a layergroup_id
-// @param cert_id signature certificate identifier
-//
-// @param callback function(Error, String) return certificate id
-//
-o.addSignature = function(signer, map_id, cert, callback) {
-  var that = this;
-  var certificate_id;
-  Step(
-    function addCertificate() {
-      that.addCertificate(signer, cert, this);
-    },
-    function signMap(err, cert_id) {
-      if ( err ) throw err;
-      if ( ! cert_id ) throw new Error("addCertificate returned no certificate id");
-      certificate_id = cert_id;
-      that.signMap(signer, map_id, cert_id, this);
-    },
-    function finish(err) {
-      callback(err, certificate_id);
-    }
-  );
-};
-
-module.exports = SignedMaps;

lib/cartodb/stats/client.js

@@ -0,0 +1,73 @@
+var _ = require('underscore');
+var debug = require('debug')('windshaft:stats_client');
+var StatsD = require('node-statsd').StatsD;
+
+module.exports = {
+    /**
+     * Returns an StatsD instance or an stub object that replicates the StatsD public interface so there is no need to
+     * keep checking if the stats_client is instantiated or not.
+     *
+     * The first call to this method implies all future calls will use the config specified in the very first call.
+     *
+     * TODO: It's far from ideal to use make this a singleton, improvement desired.
+     * We proceed this way to be able to use StatsD from several places sharing one single StatsD instance.
+     *
+     * @param config Configuration for StatsD, if undefined it will return an stub
+     * @returns {StatsD|Object}
+     */
+    getInstance: function(config) {
+
+        if (!this.instance) {
+
+            var instance;
+
+            if (config) {
+                instance = new StatsD(config);
+                instance.last_error = { msg: '', count: 0 };
+                instance.socket.on('error', function (err) {
+                    var last_err = instance.last_error;
+                    var last_msg = last_err.msg;
+                    var this_msg = '' + err;
+                    if (this_msg !== last_msg) {
+                        debug("statsd client socket error: " + err);
+                        instance.last_error.count = 1;
+                        instance.last_error.msg = this_msg;
+                    } else {
+                        ++last_err.count;
+                        if (!last_err.interval) {
+                            instance.last_error.interval = setInterval(function () {
+                                var count = instance.last_error.count;
+                                if (count > 1) {
+                                    debug("last statsd client socket error repeated " + count + " times");
+                                    instance.last_error.count = 1;
+                                    clearInterval(instance.last_error.interval);
+                                    instance.last_error.interval = null;
+                                }
+                            }, 1000);
+                        }
+                    }
+                });
+            } else {
+                var stubFunc = function (stat, value, sampleRate, callback) {
+                    if (_.isFunction(callback)) {
+                        callback(null, 0);
+                    }
+                };
+                instance = {
+                    timing: stubFunc,
+                    increment: stubFunc,
+                    decrement: stubFunc,
+                    gauge: stubFunc,
+                    unique: stubFunc,
+                    set: stubFunc,
+                    sendAll: stubFunc,
+                    send: stubFunc
+                };
+            }
+
+            this.instance = instance;
+        }
+
+        return this.instance;
+    }
+};

lib/cartodb/stats/profiler_proxy.js

@@ -0,0 +1,53 @@
+var Profiler = require('step-profiler');
+
+/**
+ * Proxy to encapsulate node-step-profiler module so there is no need to check if there is an instance
+ */
+function ProfilerProxy(opts) {
+    this.profile = !!opts.profile;
+
+    this.profiler = null;
+    if (!!opts.profile) {
+        this.profiler = new Profiler({statsd_client: opts.statsd_client});
+    }
+}
+
+ProfilerProxy.prototype.done = function(what) {
+    if (this.profile) {
+        this.profiler.done(what);
+    }
+};
+
+ProfilerProxy.prototype.end = function() {
+    if (this.profile) {
+        this.profiler.end();
+    }
+};
+
+ProfilerProxy.prototype.start = function(what) {
+    if (this.profile) {
+        this.profiler.start(what);
+    }
+};
+
+ProfilerProxy.prototype.add = function(what) {
+    if (this.profile) {
+        this.profiler.add(what || {});
+    }
+};
+
+ProfilerProxy.prototype.sendStats = function() {
+    if (this.profile) {
+        this.profiler.sendStats();
+    }
+};
+
+ProfilerProxy.prototype.toString = function() {
+    return this.profile ? this.profiler.toString() : "";
+};
+
+ProfilerProxy.prototype.toJSONString = function() {
+    return this.profile ? this.profiler.toJSONString() : "{}";
+};
+
+module.exports = ProfilerProxy;

lib/cartodb/stats/reporter/renderer.js

@@ -0,0 +1,82 @@
+//  - Reports stats about:
+//    * Total number of renderers
+//    * For mapnik renderers:
+//      - the mapnik-pool status: count, unused and waiting
+//      - the internally cached objects: png and grid
+
+var _ = require('underscore');
+
+function RendererStatsReporter(rendererCache, statsInterval) {
+    this.rendererCache = rendererCache;
+    this.statsInterval = statsInterval || 6e4;
+    this.renderersStatsIntervalId = null;
+}
+
+module.exports = RendererStatsReporter;
+
+RendererStatsReporter.prototype.start = function() {
+    var self = this;
+    this.renderersStatsIntervalId = setInterval(function() {
+        var rendererCacheEntries = self.rendererCache.renderers;
+
+        if (!rendererCacheEntries) {
+            return null;
+        }
+
+        global.statsClient.gauge('windshaft.rendercache.count', _.keys(rendererCacheEntries).length);
+
+        var renderersStats = _.reduce(rendererCacheEntries, function(_rendererStats, cacheEntry) {
+                var stats = cacheEntry.renderer && cacheEntry.renderer.getStats && cacheEntry.renderer.getStats();
+                if (!stats) {
+                    return _rendererStats;
+                }
+
+                _rendererStats.pool.count += stats.pool.count;
+                _rendererStats.pool.unused += stats.pool.unused;
+                _rendererStats.pool.waiting += stats.pool.waiting;
+
+                _rendererStats.cache.grid += stats.cache.grid;
+                _rendererStats.cache.png += stats.cache.png;
+
+                return _rendererStats;
+            },
+            {
+                pool: {
+                    count: 0,
+                    unused: 0,
+                    waiting: 0
+                },
+                cache: {
+                    png: 0,
+                    grid: 0
+                }
+            }
+        );
+
+        global.statsClient.gauge('windshaft.mapnik-cache.png', renderersStats.cache.png);
+        global.statsClient.gauge('windshaft.mapnik-cache.grid', renderersStats.cache.grid);
+
+        global.statsClient.gauge('windshaft.mapnik-pool.count', renderersStats.pool.count);
+        global.statsClient.gauge('windshaft.mapnik-pool.unused', renderersStats.pool.unused);
+        global.statsClient.gauge('windshaft.mapnik-pool.waiting', renderersStats.pool.waiting);
+    }, this.statsInterval);
+
+    this.rendererCache.on('err', rendererCacheErrorListener);
+    this.rendererCache.on('gc', gcTimingListener);
+};
+
+function rendererCacheErrorListener() {
+    global.statsClient.increment('windshaft.rendercache.error');
+}
+
+function gcTimingListener(gcTime) {
+    global.statsClient.timing('windshaft.rendercache.gc', gcTime);
+}
+
+RendererStatsReporter.prototype.stop = function() {
+    this.rendererCache.removeListener('err', rendererCacheErrorListener);
+    this.rendererCache.removeListener('gc', gcTimingListener);
+
+    clearInterval(this.renderersStatsIntervalId);
+    this.renderersStatsIntervalId = null;
+};

lib/cartodb/template_maps.js

@@ -1,586 +0,0 @@
-var crypto    = require('crypto');
-var Step      = require('step');
-var _         = require('underscore');
-
-// Templates in this hash (keyed as <username>@<template_name>)
-// are being worked on.
-var user_template_locks = {};
-
-// 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
-// 
-function TemplateMaps(redis_pool, signed_maps) {
-  this.redis_pool = redis_pool;
-  this.signed_maps = signed_maps;
-
-  // 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 teplates: 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 = "map_tpl|<%= owner %>";
-
-  // User template locks (HASH:tpl_id->ctime)
-  this.key_usr_tpl_lck = "map_tpl|<%= owner %>|locks";
-
-};
-
-var o = TemplateMaps.prototype;
-
-//--------------- PRIVATE METHODS --------------------------------
-
-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 usr_tpl_lck_key = _.template(this.key_usr_tpl_lck, {owner:owner});
-  var that = this;
-  var gotLock = false;
-  Step (
-    function obtainLock() {
-      var ctime = Date.now();
-      that._redisCmd('HSETNX', [usr_tpl_lck_key, tpl_id, ctime], this);
-    },
-    function checkLock(err, locked) {
-      if ( err ) throw err;
-      if ( ! locked ) {
-        // Already locked
-        // TODO: unlock if expired ?
-        throw new Error("Template '" + tpl_id + "' of user '" + owner + "' is locked");
-      }
-      return gotLock = true;
-    },
-    function finish(err) {
-      callback(err, gotLock);
-    }
-  );
-};
-
-// @param callback function(err, deleted)
-o._releaseTemplateLock = function(owner, tpl_id, callback) {
-  var usr_tpl_lck_key = _.template(this.key_usr_tpl_lck, {owner:owner});
-  this._redisCmd('HDEL', [usr_tpl_lck_key, tpl_id], callback);
-};
-
-o._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(this._reValidIdentifier) ) {
-    return new Error("Invalid characters in template name '" + tplname + "'");
-  }
-
-  var phold = template.placeholders;
-  for (var k in phold) {
-    if ( ! k.match(this._reValidIdentifier) ) {
-      return new Error("Invalid characters in placeholder name '" + k + "'");
-    }
-    if ( ! phold[k].hasOwnProperty('default') ) {
-      return new Error("Missing default for placeholder '" + k + "'");
-    }
-    if ( ! phold[k].hasOwnProperty('type') ) {
-      return new Error("Missing type for placeholder '" + k + "'");
-    }
-  };
-
-  // 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) {
-  var cert = {
-    version: '0.0.1',
-    template_id: template.name,
-    auth: template.auth
-  };
-  return cert;
-};
-
-// 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:
-  //
-  // 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 = _.template(this.key_usr_tpl, {owner:owner});
-  var gotLock = false;
-  var that = this;
-  Step(
-    // try to obtain a lock
-    function obtainLock() {
-      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 ( ! gotLock ) {
-        if ( err ) throw err;
-        return null;
-      }
-
-      // 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 = _.template(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 = _.template(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) {
-  var usr_tpl_key = _.template(this.key_usr_tpl, {owner:owner});
-  this._redisCmd('HKEYS', [ usr_tpl_key ], 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 usr_tpl_key = _.template(this.key_usr_tpl, {owner:owner});
-  var that = this;
-  Step(
-    function getTemplate() {
-      that._redisCmd('HGET', [ usr_tpl_key, tpl_id ], this);
-    },
-    function parseTemplate(err, tpl_val) {
-      if ( err ) throw err;
-      var tpl = JSON.parse(tpl_val);
-      // Should we strip auth_id ?
-      return tpl;
-    },
-    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
-//
-o._reNumber = /^([-+]?[\d\.]?\d+([eE][+-]?\d+)?)$/;
-o._reCSSColorName = /^[a-zA-Z]+$/;
-o._reCSSColorVal = /^#[0-9a-fA-F]{3,6}$/;
-o._replaceVars = function(str, params) {
-  //return _.template(str, params); // lazy way, possibly dangerous 
-  // Construct regular expressions for each param
-  if ( ! params._re ) {
-    params._re = {};
-    for (var k in params) {
-      params._re[k] = RegExp("<%= " + k + " %>", "g");
-    }
-  }
-  for (var k in params) str = str.replace(params._re[k], params[k]);
-  return str;
-};
-o.instance = function(template, params) {
-  var all_params = {};
-  var phold = template.placeholders;
-  for (var k in phold) {
-    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 ( ! val.match(this._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(this._reCSSColorName) && ! val.match(this._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;
-    lyropt.cartocss = this._replaceVars(lyropt.cartocss, all_params);
-    lyropt.sql = this._replaceVars(lyropt.sql, all_params);
-    // Anything else ?
-  }
-  return layergroup;
-};
-
-module.exports = TemplateMaps;

lib/cartodb/utils/overviews_query_rewriter.js

@@ -0,0 +1,182 @@
+var TableNameParser = require('./table_name_parser');
+
+function OverviewsQueryRewriter(options) {
+
+    this.options = options;
+}
+
+module.exports = OverviewsQueryRewriter;
+
+// TODO: some names are introudced in the queries, and the
+// '_vovw_' (for vector overviews) is used in them, but no check
+// is performed for conflicts with existing identifiers in the query.
+
+// Build UNION expression to replace table, using overviews metadata
+// overviews metadata: { 1: 'table_ov1', ... }
+// assume table and overview names include schema if necessary and are quoted as needed
+function overviews_view_for_table(table, overviews_metadata, indent) {
+    var condition, i, len, ov_table, overview_layers, selects, z_hi, z_lo;
+    var parsed_table = TableNameParser.parse(table);
+
+    var sorted_overviews = []; // [[1, 'table_ov1'], ...]
+
+    indent = indent || '    ';
+    for (var z in overviews_metadata) {
+        if (overviews_metadata.hasOwnProperty(z)) {
+            sorted_overviews.push([z, overviews_metadata[z].table]);
+        }
+    }
+    sorted_overviews.sort(function(a, b){ return a[0]-b[0]; });
+
+    overview_layers = [];
+    z_lo = null;
+    for (i = 0, len = sorted_overviews.length; i < len; i++) {
+        z_hi = parseInt(sorted_overviews[i][0]);
+        ov_table = sorted_overviews[i][1];
+        overview_layers.push([overview_z_condition(z_lo, z_hi), ov_table]);
+        z_lo = z_hi;
+    }
+    overview_layers.push(["_vovw_z > " + z_lo, table]);
+
+    selects = overview_layers.map(function(condition_table) {
+      condition = condition_table[0];
+      ov_table = TableNameParser.parse(condition_table[1]);
+      ov_table.schema = ov_table.schema || parsed_table.schema;
+      var ov_identifier = TableNameParser.table_identifier(ov_table);
+      return indent + "SELECT * FROM " + ov_identifier + ", _vovw_scale WHERE " + condition;
+    });
+
+    return selects.join("\n"+indent+"UNION ALL\n");
+}
+
+function overview_z_condition(z_lo, z_hi) {
+    if (z_lo !== null) {
+        if (z_lo === z_hi - 1) {
+            return "_vovw_z = " + z_hi;
+        } else {
+            return "_vovw_z > " + z_lo + " AND _vovw_z <= " + z_hi;
+        }
+    } else {
+        if (z_hi === 0) {
+            return "_vovw_z = " + z_hi;
+        } else {
+            return "_vovw_z <= " + z_hi;
+        }
+    }
+}
+
+// name to be used for the view of the table using overviews
+function overviews_view_name(table) {
+    var parsed_table = TableNameParser.parse(table);
+    parsed_table.table = '_vovw_' + parsed_table.table;
+    parsed_table.schema = null;
+    return TableNameParser.table_identifier(parsed_table);
+}
+
+// replace a table name in a query by anoter name
+function replace_table_in_query(sql, old_table_name, new_table_name) {
+    var old_table = TableNameParser.parse(old_table_name);
+    var new_table = TableNameParser.parse(new_table_name);
+    var old_table_ident = TableNameParser.table_identifier(old_table);
+    var new_table_ident = TableNameParser.table_identifier(new_table);
+
+    // text that will be substituted by the table name pattern
+    var replacement = new_table_ident;
+
+    // regular expression prefix (beginning) to match a table name
+    function pattern_prefix(schema, identifier) {
+        if ( schema ) {
+            // to match a table name including schema prefix
+            // name should not be part of another name, so we require
+            // to start a at a word boundary
+            if ( identifier[0] !== '"' ) {
+                return '\\b';
+            } else {
+                return '';
+            }
+        } else {
+           // to match a table name without schema
+           // name should not begin right after a dot (i.e. have a explicit schema)
+           // nor be part of another name
+           // since the pattern matches the first character of the table
+           // it must be put back in the replacement text
+           replacement = '$01'+replacement;
+           return '([^\.a-z0-9_]|^)';
+        }
+    }
+
+    // regular expression suffix (ending) to match a table name
+    function pattern_suffix(identifier) {
+        // name shouldn't be the prefix of a longer name
+        if ( identifier[identifier.length-1] !== '"' ) {
+            return '\\b';
+        } else {
+            return '';
+        }
+    }
+
+    // regular expression to match a table name
+    var regexp = pattern_prefix(old_table.schema, old_table_ident) +
+                 old_table_ident +
+                 pattern_suffix(old_table_ident);
+
+    // replace all occurrences of the table pattern
+    return sql.replace(new RegExp(regexp, 'g'), replacement);
+}
+
+function overviews_query(query, overviews, zoom_level_expression) {
+    var replaced_query = query;
+    var sql = "WITH\n  _vovw_scale AS ( SELECT " + zoom_level_expression + " AS _vovw_z )";
+    for ( var table in overviews ) {
+        if (overviews.hasOwnProperty(table)) {
+            var table_overviews = overviews[table];
+            var table_view = overviews_view_name(table);
+            replaced_query = replace_table_in_query(replaced_query, table, table_view);
+            sql += ",\n  " + table_view + " AS (\n" + overviews_view_for_table(table, table_overviews) + "\n  )";
+        }
+    }
+    if ( replaced_query !== query ) {
+        sql += "\n";
+        sql += replaced_query;
+    } else {
+        sql = query;
+    }
+    return sql;
+}
+
+// Transform an SQL query so that it uses overviews.
+// overviews contains metadata about the overviews to be used:
+//     { 'table-name': {1: { table: 'overview-table-1' }, ... }, ... }
+//
+// For a given query `SELECT * FROM table`,  if any of tables in it
+// has overviews as defined by the provided metadat, the query will
+// be transform into something similar to this:
+//
+//     WITH _vovw_scale AS ( ... ), -- define scale level
+//     WITH _vovw_table AS ( ... ), -- define union of overviews and base table
+//     SELECT * FROM _vovw_table -- query with table replaced by _vovw_table
+//
+// This transformation can in principle be applied to arbitrary queries
+// (except for the case of queries that include the name of tables with
+// overviews inside text literals: at the current table name substitution
+// doesnn't prevent substitution inside literals).
+// But the transformation will currently only be applied to simple queries
+// of the form detected by the overviews_supported_query function.
+OverviewsQueryRewriter.prototype.query = function(query, data) {
+    var overviews = this.overviews_metadata(data);
+    if ( !overviews || !this.is_supported_query(query)) {
+        return query;
+    }
+    var zoom_level_expression = this.options.zoom_level || '0';
+    return overviews_query(query, overviews, zoom_level_expression);
+};
+
+OverviewsQueryRewriter.prototype.is_supported_query = function(sql) {
+  return !!sql.match(
+    /^\s*SELECT\s+[\*\.a-z0-9_,\s]+?\s+FROM\s+((\"[^"]+\"|[a-z0-9_]+)\.)?(\"[^"]+\"|[a-z0-9_]+)\s*;?\s*$/i
+  );
+};
+
+OverviewsQueryRewriter.prototype.overviews_metadata = function(data) {
+  return data && data.overviews;
+};

lib/cartodb/utils/table_name_parser.js

@@ -0,0 +1,106 @@
+// Quote an PostgreSQL identifier if ncecessary
+function quote_identifier_if_needed(txt) {
+    if ( txt && !txt.match(/^[a-z_][a-z_0-9]*$/)) {
+        return '"' + txt.replace(/\"/g, '""') + '"';
+    } else {
+        return txt;
+    }
+}
+
+// Parse PostgreSQL table name (possibly quoted and with optional schema).+
+// Returns { schema: 'schema_name', table: 'table_name' }
+function parse_table_name(table) {
+
+    function split_as_quoted_parts(table_name) {
+      // parse table into 'parts' that may be quoted, each part
+      // in the parts array being an object { part: 'text', quoted: false/true }
+     var parts = [];
+     var splitted = table_name.split(/\"/);
+     for (var i=0; i<splitted.length; i++ ) {
+       if ( splitted[i] === '' ) {
+         if ( parts.length > 0 && i < splitted.length-1 ) {
+             i++;
+             parts[parts.length - 1].part += '"' + splitted[i];
+         }
+       }
+       else {
+         var is_quoted = (i > 0 && splitted[i-1] === '') ||
+                         (i < splitted.length - 1 && splitted[i+1] === '');
+             parts.push({ part: splitted[i], quoted: is_quoted });
+       }
+     }
+     return parts;
+    }
+
+    var parts = split_as_quoted_parts(table);
+
+    function split_single_part(part) {
+        var schema_part = null;
+        var table_part = null;
+        if ( part.quoted ) {
+            table_part = part.part;
+        } else {
+            var parts = part.part.split('.');
+            if ( parts.length === 1 ) {
+                schema_part = null;
+                table_part = parts[0];
+            } else if ( parts.length === 2 ) {
+                schema_part = parts[0];
+                table_part = parts[1];
+            } // else invalid table name
+        }
+        return {
+            schema: schema_part,
+            table:  table_part
+        };
+    }
+
+    function split_two_parts(part1, part2) {
+        var schema_part = null;
+        var table_part = null;
+        if ( part1.quoted && !part2.quoted ) {
+            if ( part2.part[0] === '.' ) {
+                schema_part = part1.part;
+                table_part = part2.part.slice(1);
+            } // else invalid table name (missing dot)
+        } else if ( !part1.quoted && part2.quoted ) {
+            if ( part1.part[part1.part.length - 1] === '.' ) {
+                schema_part = part1.part.slice(0, -1);
+                table_part = part2.part;
+            } // else invalid table name (missing dot)
+        } // else invalid table name (missing dot)
+        return {
+            schema: schema_part,
+            table:  table_part
+        };
+    }
+
+    if ( parts.length === 1 ) {
+        return split_single_part(parts[0]);
+    } else if ( parts.length === 2 ) {
+        return split_two_parts(parts[0], parts[1]);
+    } else if ( parts.length === 3 && parts[1].part === '.' ) {
+        return {
+            schema: parts[0].part,
+            table:  parts[2].part
+        };
+    } // else invalid table name
+}
+
+function table_identifier(parsed_name) {
+    if ( parsed_name && parsed_name.table ) {
+        if ( parsed_name.schema ) {
+            return quote_identifier_if_needed(parsed_name.schema) + '.' + quote_identifier_if_needed(parsed_name.table);
+        } else {
+            return quote_identifier_if_needed(parsed_name.table);
+        }
+    } else {
+        return null;
+    }
+}
+
+module.exports = {
+  parse: parse_table_name,
+  quote: quote_identifier_if_needed,
+  table_identifier: table_identifier
+};

package.json

@@ -1,16 +1,13 @@
 {
     "private": true,
     "name": "windshaft-cartodb",
-    "version": "1.6.3",
+    "version": "2.26.2",
     "description": "A map tile server for CartoDB",
     "keywords": [
       "cartodb"
     ],
     "url": "https://github.com/CartoDB/Windshaft-cartodb",
-    "licenses": [{
-        "type": "BSD",
-        "url": "https://github.com/CartoDB/Windshaft-cartodb/blob/master/LICENCE"
-    }],
+    "license": "BSD-3-Clause",
     "repository": {
         "type": "git",
         "url": "git://github.com/CartoDB/Windshaft-cartodb.git"
@@ -22,23 +19,40 @@
       "Sandro Santilli <strk@vizzuality.com>"
     ],
     "dependencies": {
-        "node-varnish": "0.1.1",
-        "underscore"  : "~1.3.3",
-        "windshaft"  : "~0.15.1",
-        "step": "0.0.x",
-        "request": "2.9.202",
-        "cartodb-redis": "~0.3.0",
-        "redis-mpool": "~0.0.2",
-        "mapnik": "~0.7.22",
-        "lzma": "~1.2.3"
+        "express": "~4.13.3",
+        "body-parser": "~1.14.0",
+        "debug": "~2.2.0",
+        "step-profiler": "~0.2.1",
+        "node-statsd": "~0.0.7",
+        "underscore"  : "~1.6.0",
+        "dot": "~1.0.2",
+        "windshaft": "1.13.2",
+        "step": "~0.0.6",
+        "queue-async": "~1.0.7",
+        "request": "~2.62.0",
+        "cartodb-redis": "~0.13.0",
+        "cartodb-psql": "~0.4.0",
+        "fastly-purge": "~1.0.1",
+        "redis-mpool": "~0.4.0",
+        "lru-cache": "2.6.5",
+        "lzma": "~1.3.7",
+        "log4js": "https://github.com/CartoDB/log4js-node/tarball/cdb"
     },
     "devDependencies": {
-        "mocha": "1.14.0",
-        "redis": "~0.8.3",
-        "strftime": "~0.6.0",
-        "semver": "~1.1.0"
+        "istanbul": "~0.3.6",
+        "mocha": "~1.21.4",
+        "nock": "~2.11.0",
+        "jshint": "~2.6.0",
+        "redis": "~0.8.6",
+        "strftime": "~0.8.2",
+        "semver": "~1.1.4"
     },
     "scripts": {
-        "test": "make check"
+        "preinstall": "make pre-install",
+        "test": "make test-all"
+    },
+    "engines": {
+        "node": ">=0.8 <0.11",
+        "npm": ">=2.14.16"
     }
 }

run_tests.sh

@@ -4,6 +4,9 @@ OPT_CREATE_REDIS=yes # create the redis test environment
 OPT_CREATE_PGSQL=yes # create the PostgreSQL test environment
 OPT_DROP_REDIS=yes   # drop the redis test environment
 OPT_DROP_PGSQL=yes   # drop the PostgreSQL test environment
+OPT_COVERAGE=no      # run tests with coverage
+
+export PGAPPNAME=cartodb_tiler_tester
 
 cd $(dirname $0)
 BASEDIR=$(pwd)
@@ -21,7 +24,10 @@ cleanup() {
         return;
       fi
     fi
+    redis-cli -p ${REDIS_PORT} info stats
+    redis-cli -p ${REDIS_PORT} info keyspace
     echo "Killing test redis pid ${PID_REDIS}"
+    #kill ${PID_REDIS_MONITOR}
     kill ${PID_REDIS}
   fi
   if test x"$OPT_DROP_PGSQL" = xyes; then
@@ -67,6 +73,10 @@ while [ -n "$1" ]; do
                 OPT_CREATE_REDIS=no
                 shift
                 continue
+        elif test "$1" = "--with-coverage"; then
+                OPT_COVERAGE=yes
+                shift
+                continue
         # This is kept for backward compatibility
         elif test "$1" = "--nocreate"; then
                 OPT_CREATE_REDIS=no
@@ -83,6 +93,7 @@ if [ -z "$1" ]; then
         echo "Options:" >&2
         echo " --nocreate   do not create the test environment on start" >&2
         echo " --nodrop     do not drop the test environment on exit" >&2
+        echo " --with-coverage   use istanbul to determine code coverage" >&2
         exit 1
 fi
 
@@ -110,8 +121,16 @@ cd -
 
 PATH=node_modules/.bin/:$PATH
 
-echo "Running tests"
-mocha -t 10000 -u tdd ${MOCHA_OPTS} ${TESTS}
+#redis-cli -p ${REDIS_PORT} monitor > /tmp/windshaft-cartodb.redis.log &
+#PID_REDIS_MONITOR=$!
+
+if test x"$OPT_COVERAGE" = xyes; then
+  echo "Running tests with coverage"
+  ./node_modules/.bin/istanbul cover node_modules/.bin/_mocha -- -u tdd -t 5000 ${TESTS}
+else
+  echo "Running tests"
+  mocha -u tdd -t 5000 ${TESTS}
+fi
 ret=$?
 
 cleanup

scripts/check-node-canvas.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    CAIRO_PKG_CONFIG=`pkg-config cairo --cflags-only-I 2> /dev/null`
+    RESULT=$?
+
+    if [[ ${RESULT} -ne 0 ]]; then
+        echo "###################################################################################"
+        echo "#                            PREINSTALL HOOK ERROR                                #"
+        echo "#---------------------------------------------------------------------------------#"
+        echo "#                                                                                 #"
+        echo "# node-canvas install error: some packages required by 'cairo' are not found      #"
+        echo "#                                                                                 #"
+        echo -e "# Use '\033[1mmake all\033[0m', it will take care of common/known issues                        #"
+        echo "#                                                                                 #"
+        echo "# As an alternative try:                                                          #"
+        echo "# Try to 'export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:/opt/X11/lib/pkgconfig' #"
+        echo "#                                                                                 #"
+        echo "# If problems persist visit: https://github.com/Automattic/node-canvas/wiki       #"
+        echo "#                                                                                 #"
+        echo "###################################################################################"
+        exit 1
+    fi
+fi

scripts/install.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:/opt/X11/lib/pkgconfig
+fi
+
+npm install

scripts/lzma2config.js

@@ -0,0 +1,18 @@
+if (process.argv.length !== 3) {
+    console.error('Usage: node %s lzma_string', __filename);
+    process.exit(1);
+}
+
+var LZMA = require('lzma').LZMA;
+var lzmaWorker = new LZMA();
+var lzmaInput = decodeURIComponent(process.argv[2]);
+var lzmaBuffer = new Buffer(lzmaInput, 'base64')
+    .toString('binary')
+    .split('')
+    .map(function(c) {
+        return c.charCodeAt(0) - 128
+    });
+
+lzmaWorker.decompress(lzmaBuffer, function(result) {
+    console.log(JSON.stringify(JSON.parse(JSON.parse(result).config), null, 4));
+});

test/acceptance/cache/surrogate_keys_invalidation.js

@@ -0,0 +1,317 @@
+var testHelper = require('../../support/test_helper');
+
+var assert      = require('../../support/assert');
+var step        = require('step');
+var FastlyPurge = require('fastly-purge');
+var _ = require('underscore');
+
+var NamedMapsCacheEntry = require(__dirname + '/../../../lib/cartodb/cache/model/named_maps_entry');
+var CartodbWindshaft = require(__dirname + '/../../../lib/cartodb/server');
+
+
+describe('templates surrogate keys', function() {
+
+    var serverOptions = require('../../../lib/cartodb/server_options');
+
+    // Enable Varnish purge for tests
+    var varnishHost = serverOptions.varnish_host;
+    serverOptions.varnish_host = '127.0.0.1';
+    var varnishPurgeEnabled = serverOptions.varnish_purge_enabled;
+    serverOptions.varnish_purge_enabled = true;
+
+    var fastlyConfig = serverOptions.fastly;
+    var FAKE_FASTLY_API_KEY = 'fastly-api-key';
+    var FAKE_FASTLY_SERVICE_ID = 'fake-service-id';
+    serverOptions.fastly = {
+        enabled: true,
+        // the fastly api key
+        apiKey: FAKE_FASTLY_API_KEY,
+        // the service that will get surrogate key invalidation
+        serviceId: FAKE_FASTLY_SERVICE_ID
+    };
+
+    var server = new CartodbWindshaft(serverOptions);
+
+    var templateOwner = 'localhost';
+    var templateName = 'acceptance';
+    var expectedTemplateId = templateName;
+    var template = {
+        version: '0.0.1',
+        name: templateName,
+        auth: {
+            method: 'open'
+        },
+        layergroup:  {
+            version: '1.2.0',
+            layers: [
+                {
+                    options: {
+                        sql: 'select 1 cartodb_id, null::geometry as the_geom_webmercator',
+                        cartocss: '#layer { marker-fill:blue; }',
+                        cartocss_version: '2.3.0'
+                    }
+                }
+            ]
+        }
+    };
+    var templateUpdated = _.extend({}, template, {layergroup: {layers: [{
+        type: 'plain',
+        options: {
+            color: 'red'
+        }
+    }]} });
+    var expectedBody = { template_id: expectedTemplateId };
+
+    var varnishHttpUrl = [
+        'http://', serverOptions.varnish_host, ':', serverOptions.varnish_http_port
+    ].join('');
+
+    var cacheEntryKey = new NamedMapsCacheEntry(templateOwner, templateName).key();
+    var invalidationMatchHeader = '\\b' + cacheEntryKey + '\\b';
+    var fastlyPurgePath = '/service/' + FAKE_FASTLY_SERVICE_ID + '/purge/' + cacheEntryKey;
+
+    var nock = require('nock');
+    nock.enableNetConnect(/(127.0.0.1:5555|cartocdn.com)/);
+
+    after(function(done) {
+        serverOptions.varnish_purge_enabled = false;
+        serverOptions.varnish_host = varnishHost;
+        serverOptions.varnish_purge_enabled = varnishPurgeEnabled;
+
+        serverOptions.fastly = fastlyConfig;
+
+        nock.restore();
+        done();
+    });
+
+    function createTemplate(callback) {
+        var postTemplateRequest = {
+            url: '/api/v1/map/named?api_key=1234',
+            method: 'POST',
+            headers: {
+                host: templateOwner,
+                'Content-Type': 'application/json'
+            },
+            data: JSON.stringify(template)
+        };
+
+        step(
+            function postTemplate() {
+                var next = this;
+                assert.response(server,
+                    postTemplateRequest,
+                    {
+                        status: 200
+                    },
+                    function(res) {
+                        next(null, res);
+                    }
+                );
+            },
+            function rePostTemplate(err, res) {
+                if (err) {
+                    throw err;
+                }
+                var parsedBody = JSON.parse(res.body);
+                assert.deepEqual(parsedBody, expectedBody);
+                return true;
+            },
+            function finish(err) {
+                callback(err);
+            }
+        );
+    }
+
+    it("invalidates surrogate keys on template update", function(done) {
+
+        var scope = nock(varnishHttpUrl)
+            .intercept('/key', 'PURGE')
+            .matchHeader('Invalidation-Match', invalidationMatchHeader)
+            .reply(204, '');
+
+        var fastlyScope = nock(FastlyPurge.FASTLY_API_ENDPOINT)
+            .post(fastlyPurgePath)
+            .matchHeader('Fastly-Key', FAKE_FASTLY_API_KEY)
+            .matchHeader('Accept', 'application/json')
+            .reply(200, {
+                status:'ok'
+            });
+
+        step(
+            function createTemplateToUpdate() {
+                createTemplate(this);
+            },
+            function putValidTemplate(err) {
+                if (err) {
+                    throw err;
+                }
+                var updateTemplateRequest = {
+                    url: '/api/v1/map/named/' + expectedTemplateId + '/?api_key=1234',
+                    method: 'PUT',
+                    headers: {
+                        host: templateOwner,
+                        'Content-Type': 'application/json'
+                    },
+                    data: JSON.stringify(templateUpdated)
+                };
+                var next = this;
+                assert.response(server,
+                    updateTemplateRequest,
+                    {
+                        status: 200
+                    },
+                    function(res) {
+                        setTimeout(function() {
+                            next(null, res);
+                        }, 50);
+                    }
+                );
+            },
+            function checkValidUpdate(err, res) {
+                if (err) {
+                    throw err;
+                }
+                var parsedBody = JSON.parse(res.body);
+                assert.deepEqual(parsedBody, expectedBody);
+
+                assert.equal(scope.pendingMocks().length, 0);
+                assert.equal(fastlyScope.pendingMocks().length, 0);
+
+                return null;
+            },
+            function finish(err) {
+                if ( err ) {
+                    return done(err);
+                }
+                testHelper.deleteRedisKeys({'map_tpl|localhost': 0}, done);
+            }
+        );
+    });
+
+    it("invalidates surrogate on template deletion", function(done) {
+
+        var scope = nock(varnishHttpUrl)
+            .intercept('/key', 'PURGE')
+            .matchHeader('Invalidation-Match', invalidationMatchHeader)
+            .reply(204, '');
+
+        var fastlyScope = nock(FastlyPurge.FASTLY_API_ENDPOINT)
+            .post(fastlyPurgePath)
+            .matchHeader('Fastly-Key', FAKE_FASTLY_API_KEY)
+            .matchHeader('Accept', 'application/json')
+            .reply(200, {
+                status:'ok'
+            });
+
+        step(
+            function createTemplateToDelete() {
+                createTemplate(this);
+            },
+            function deleteValidTemplate(err) {
+                if (err) {
+                    throw err;
+                }
+                var deleteTemplateRequest = {
+                    url: '/api/v1/map/named/' + expectedTemplateId + '/?api_key=1234',
+                    method: 'DELETE',
+                    headers: {
+                        host: templateOwner,
+                        'Content-Type': 'application/json'
+                    }
+                };
+                var next = this;
+                assert.response(server,
+                    deleteTemplateRequest,
+                    {
+                        status: 204
+                    },
+                    function(res) {
+                        setTimeout(function() {
+                            next(null, res);
+                        }, 50);
+                    }
+                );
+            },
+            function checkValidUpdate(err) {
+                if (err) {
+                    throw err;
+                }
+
+                assert.equal(scope.pendingMocks().length, 0);
+                assert.equal(fastlyScope.pendingMocks().length, 0);
+
+                return null;
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+    });
+
+    it("should update template even if surrogate key invalidation fails", function(done) {
+
+        var scope = nock(varnishHttpUrl)
+            .intercept('/key', 'PURGE')
+            .matchHeader('Invalidation-Match', invalidationMatchHeader)
+            .reply(503, '');
+
+        var fastlyScope = nock(FastlyPurge.FASTLY_API_ENDPOINT)
+            .post(fastlyPurgePath)
+            .matchHeader('Fastly-Key', FAKE_FASTLY_API_KEY)
+            .matchHeader('Accept', 'application/json')
+            .reply(200, {
+                status:'ok'
+            });
+
+        step(
+            function createTemplateToUpdate() {
+                createTemplate(this);
+            },
+            function putValidTemplate(err) {
+                if (err) {
+                    throw err;
+                }
+                var updateTemplateRequest = {
+                    url: '/api/v1/map/named/' + expectedTemplateId + '/?api_key=1234',
+                    method: 'PUT',
+                    headers: {
+                        host: templateOwner,
+                        'Content-Type': 'application/json'
+                    },
+                    data: JSON.stringify(templateUpdated)
+                };
+                var next = this;
+                assert.response(server,
+                    updateTemplateRequest,
+                    {
+                        status: 200
+                    },
+                    function(res) {
+                        setTimeout(function() {
+                            next(null, res);
+                        }, 50);
+                    }
+                );
+            },
+            function checkValidUpdate(err, res) {
+                if (err) {
+                    throw err;
+                }
+                var parsedBody = JSON.parse(res.body);
+                assert.deepEqual(parsedBody, expectedBody);
+
+                assert.equal(scope.pendingMocks().length, 0);
+                assert.equal(fastlyScope.pendingMocks().length, 0);
+
+                return null;
+            },
+            function finish(err) {
+                if ( err ) {
+                    return done(err);
+                }
+                testHelper.deleteRedisKeys({'map_tpl|localhost': 0}, done);
+            }
+        );
+    });
+
+});

test/acceptance/cache_validator.js

@@ -1,21 +0,0 @@
-var assert      = require('../support/assert');
-require(__dirname + '/../support/test_helper');
-var CacheValidator = require(__dirname + '/../../lib/cartodb/cache_validator');
-
-var VarnishEmu = require('../support/VarnishEmu');
-
-suite('cache_validator', function() {
-
-    test('should call purge on varnish when invalidate database', function(done) {
-        var varnish = new VarnishEmu(function(cmds) {
-            assert.ok(cmds.length == 1);        
-            assert.equal('purge obj.http.X-Cache-Channel ~ \"^test_db:(.*test_cache.*)|(table)$\"\n', cmds[0].toString('utf8'));
-            done();
-        },
-        function() {
-            CacheValidator.init('localhost', 1337);
-            CacheValidator.invalidate_db('test_db', 'test_cache');
-        });
-    });
-
-});

test/acceptance/health_check.js

@@ -0,0 +1,116 @@
+require(__dirname + '/../support/test_helper');
+
+var fs = require('fs');
+
+var assert = require('../support/assert');
+var CartodbWindshaft = require('../../lib/cartodb/server');
+var serverOptions = require('../../lib/cartodb/server_options');
+
+describe('health checks', function () {
+
+    function enableHealthConfig() {
+        global.environment.health = {
+            enabled: true
+        };
+    }
+
+    function disableHealthConfig() {
+        global.environment.health = {
+            enabled: false
+        };
+    }
+
+    var healthCheckRequest = {
+        url: '/health',
+        method: 'GET',
+        headers: {
+            host: 'localhost'
+        }
+    };
+
+    beforeEach(enableHealthConfig);
+    afterEach(disableHealthConfig);
+
+    var RESPONSE_OK = {
+        status: 200
+    };
+
+    var RESPONSE_FAIL = {
+        status: 503
+    };
+
+    it('returns 200 and ok=true with enabled configuration', function (done) {
+        var server = new CartodbWindshaft(serverOptions);
+
+        assert.response(server, healthCheckRequest, RESPONSE_OK, function (res, err) {
+            assert.ok(!err);
+
+            var parsed = JSON.parse(res.body);
+
+            assert.ok(parsed.enabled);
+            assert.ok(parsed.ok);
+
+            done();
+        });
+    });
+
+    it('error if disabled file exists', function(done) {
+        var errorMessage = "Maintenance";
+
+        var readFileFn = fs.readFile;
+        fs.readFile = function(filename, callback) {
+            callback(null, errorMessage);
+        };
+        var server = new CartodbWindshaft(serverOptions);
+
+        assert.response(server, healthCheckRequest, RESPONSE_FAIL, function(res, err) {
+            fs.readFile = readFileFn;
+
+            assert.ok(!err);
+            var parsed = JSON.parse(res.body);
+            assert.ok(parsed.enabled);
+            assert.ok(!parsed.ok);
+            assert.equal(parsed.err, errorMessage);
+
+            done();
+        });
+    });
+
+    it('error if disabled file exists but has no content', function(done) {
+        var readFileFn = fs.readFile;
+        fs.readFile = function(filename, callback) {
+            callback(null, '');
+        };
+        var server = new CartodbWindshaft(serverOptions);
+
+        assert.response(server, healthCheckRequest, RESPONSE_FAIL, function(res, err) {
+            fs.readFile = readFileFn;
+
+            assert.ok(!err);
+            var parsed = JSON.parse(res.body);
+            assert.ok(parsed.enabled);
+            assert.ok(!parsed.ok);
+            assert.equal(parsed.err, 'Unknown error');
+
+            done();
+        });
+    });
+
+    it('not err if disabled file does not exists', function(done) {
+        global.environment.disabled_file = '/tmp/ftreftrgtrccre';
+
+        var server = new CartodbWindshaft(serverOptions);
+
+        assert.response(server, healthCheckRequest, RESPONSE_OK, function (res, err) {
+            assert.ok(!err);
+
+            var parsed = JSON.parse(res.body);
+
+            assert.equal(parsed.enabled, true);
+            assert.equal(parsed.ok, true);
+
+            done();
+        });
+    });
+
+});

test/acceptance/limits.js

@@ -0,0 +1,311 @@
+var testHelper = require('../support/test_helper');
+
+var assert = require('../support/assert');
+var _ = require('underscore');
+var redis = require('redis');
+
+var CartodbWindshaft = require('../../lib/cartodb/server');
+var serverOptions = require('../../lib/cartodb/server_options');
+
+var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+
+describe('render limits', function() {
+
+    var layergroupUrl = '/api/v1/map';
+
+    var redisClient = redis.createClient(global.environment.redis.port);
+
+    var server;
+    var keysToDelete;
+    beforeEach(function() {
+        keysToDelete = {};
+        server = new CartodbWindshaft(serverOptions);
+        server.setMaxListeners(0);
+    });
+
+    afterEach(function(done) {
+        testHelper.deleteRedisKeys(keysToDelete, done);
+    });
+
+    var user = 'localhost';
+
+    var pointSleepSql = "SELECT pg_sleep(0.5)," +
+        " 'SRID=3857;POINT(0 0)'::geometry the_geom_webmercator, 1 cartodb_id";
+    var pointCartoCss = '#layer { marker-fill:red; }';
+    var polygonSleepSql = "SELECT pg_sleep(0.5)," +
+        " ST_Buffer('SRID=3857;POINT(0 0)'::geometry, 100000000) the_geom_webmercator, 1 cartodb_id";
+    var polygonCartoCss = '#layer { polygon-fill:red; }';
+
+    function singleLayergroupConfig(sql, cartocss) {
+        return {
+            version: '1.0.0',
+            layers: [
+                {
+                    type: 'mapnik',
+                    options: {
+                        sql: sql,
+                        cartocss: cartocss,
+                        cartocss_version: '2.0.1'
+                    }
+                }
+            ]
+        };
+    }
+
+    function createRequest(layergroup, userHost) {
+        return {
+            url: layergroupUrl,
+            method: 'POST',
+            headers: {
+                host: userHost,
+                'Content-Type': 'application/json'
+            },
+            data: JSON.stringify(layergroup)
+        };
+    }
+
+    function withRenderLimit(user, renderLimit, callback) {
+        redisClient.SELECT(5, function(err) {
+            if (err) {
+                return callback(err);
+            }
+            var userLimitsKey = 'limits:tiler:' + user;
+            redisClient.HSET(userLimitsKey, 'render', renderLimit, function(err) {
+                if (err) {
+                    return callback(err);
+                }
+                keysToDelete[userLimitsKey] = 5;
+                return callback();
+            });
+        });
+
+    }
+
+    describe('with onTileErrorStrategy DISABLED', function() {
+        var onTileErrorStrategyEnabled;
+        before(function() {
+            onTileErrorStrategyEnabled = global.environment.enabledFeatures.onTileErrorStrategy;
+            global.environment.enabledFeatures.onTileErrorStrategy = false;
+        });
+
+        after(function() {
+            global.environment.enabledFeatures.onTileErrorStrategy = onTileErrorStrategyEnabled;
+        });
+
+        it("layergroup creation fails if test tile is slow", function(done) {
+            withRenderLimit(user, 50, function(err) {
+                if (err) {
+                    return done(err);
+                }
+
+                var layergroup = singleLayergroupConfig(polygonSleepSql, polygonCartoCss);
+                assert.response(server,
+                    createRequest(layergroup, user),
+                    {
+                        status: 400
+                    },
+                    function(res) {
+                        var parsed = JSON.parse(res.body);
+                        assert.deepEqual(parsed, { errors: [ 'Render timed out' ] });
+                        done();
+                    }
+                );
+            });
+        });
+
+        it("layergroup creation does not fail if user limit is high enough even if test tile is slow", function(done) {
+            withRenderLimit(user, 5000, function(err) {
+                if (err) {
+                    return done(err);
+                }
+
+                var layergroup = singleLayergroupConfig(polygonSleepSql, polygonCartoCss);
+                assert.response(server,
+                    createRequest(layergroup, user),
+                    {
+                        status: 200
+                    },
+                    function(res) {
+                        var parsed = JSON.parse(res.body);
+                        assert.ok(parsed.layergroupid);
+                        keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
+                        keysToDelete['user:localhost:mapviews:global'] = 5;
+                        done();
+                    }
+                );
+            });
+        });
+
+
+        it("layergroup creation works if test tile is fast but tile request fails if they are slow",  function(done) {
+            withRenderLimit(user, 50, function(err) {
+                if (err) {
+                    return done(err);
+                }
+
+                var layergroup = singleLayergroupConfig(pointSleepSql, pointCartoCss);
+                assert.response(server,
+                    createRequest(layergroup, user),
+                    {
+                        status: 200
+                    },
+                    function(res) {
+                        keysToDelete['map_cfg|' + LayergroupToken.parse(JSON.parse(res.body).layergroupid).token] = 0;
+                        keysToDelete['user:localhost:mapviews:global'] = 5;
+                        assert.response(server,
+                            {
+                                url: layergroupUrl + _.template('/<%= layergroupId %>/<%= z %>/<%= x %>/<%= y %>.png', {
+                                    layergroupId: JSON.parse(res.body).layergroupid,
+                                    z: 0,
+                                    x: 0,
+                                    y: 0
+                                }),
+                                method: 'GET',
+                                headers: {
+                                    host: 'localhost'
+                                },
+                                encoding: 'binary'
+                            },
+                            {
+                                status: 400
+                            },
+                            function(res) {
+                                var parsed = JSON.parse(res.body);
+                                assert.deepEqual(parsed, { errors: ['Render timed out'] });
+                                done();
+                            }
+                        );
+
+                    }
+                );
+            });
+        });
+
+        it("tile request does not fail if user limit is high enough",  function(done) {
+            withRenderLimit(user, 5000, function(err) {
+                if (err) {
+                    return done(err);
+                }
+
+                var layergroup = singleLayergroupConfig(pointSleepSql, pointCartoCss);
+                assert.response(server,
+                    createRequest(layergroup, user),
+                    {
+                        status: 200
+                    },
+                    function(res) {
+                        keysToDelete['map_cfg|' + LayergroupToken.parse(JSON.parse(res.body).layergroupid).token] = 0;
+                        keysToDelete['user:localhost:mapviews:global'] = 5;
+                        assert.response(server,
+                            {
+                                url: layergroupUrl + _.template('/<%= layergroupId %>/<%= z %>/<%= x %>/<%= y %>.png', {
+                                    layergroupId: JSON.parse(res.body).layergroupid,
+                                    z: 0,
+                                    x: 0,
+                                    y: 0
+                                }),
+                                method: 'GET',
+                                headers: {
+                                    host: 'localhost'
+                                },
+                                encoding: 'binary'
+                            },
+                            {
+                                status: 200,
+                                headers: {
+                                    'Content-Type': 'image/png'
+                                }
+                            },
+                            function(res, err) {
+                                done(err);
+                            }
+                        );
+
+                    }
+                );
+            });
+        });
+
+    });
+
+    describe('with onTileErrorStrategy', function() {
+
+        it("layergroup creation works even if test tile is slow", function(done) {
+            withRenderLimit(user, 50, function(err) {
+                if (err) {
+                    return done(err);
+                }
+
+                var layergroup = singleLayergroupConfig(polygonSleepSql, polygonCartoCss);
+                assert.response(server,
+                    createRequest(layergroup, user),
+                    {
+                        status: 200
+                    },
+                    function(res) {
+                        var parsed = JSON.parse(res.body);
+                        assert.ok(parsed.layergroupid);
+                        keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
+                        keysToDelete['user:localhost:mapviews:global'] = 5;
+                        done();
+                    }
+                );
+            });
+        });
+
+        it("layergroup creation and tile requests works even if they are slow but returns fallback",  function(done) {
+            withRenderLimit(user, 50, function(err) {
+                if (err) {
+                    return done(err);
+                }
+
+                var layergroup = singleLayergroupConfig(pointSleepSql, pointCartoCss);
+                assert.response(server,
+                    createRequest(layergroup, user),
+                    {
+                        status: 200
+                    },
+                    function(res) {
+                        keysToDelete['map_cfg|' + LayergroupToken.parse(JSON.parse(res.body).layergroupid).token] = 0;
+                        keysToDelete['user:localhost:mapviews:global'] = 5;
+                        assert.response(server,
+                            {
+                                url: layergroupUrl + _.template('/<%= layergroupId %>/<%= z %>/<%= x %>/<%= y %>.png', {
+                                    layergroupId: JSON.parse(res.body).layergroupid,
+                                    z: 0,
+                                    x: 0,
+                                    y: 0
+                                }),
+                                method: 'GET',
+                                headers: {
+                                    host: 'localhost'
+                                },
+                                encoding: 'binary'
+                            },
+                            {
+                                status: 200,
+                                headers: {
+                                    'Content-Type': 'image/png'
+                                }
+                            },
+                            function(res, err) {
+                                if (err) {
+                                    done(err);
+                                }
+                                var referenceImagePath = './test/fixtures/render-timeout-fallback.png';
+                                assert.imageBufferIsSimilarToFile(res.body, referenceImagePath, 25,
+                                    function(imgErr/*, similarity*/) {
+                                        done(imgErr);
+                                    }
+                                );
+                            }
+                        );
+
+                    }
+                );
+            });
+        });
+
+    });
+
+});

test/acceptance/multilayer_server.js

@@ -0,0 +1,398 @@
+var testHelper = require('../support/test_helper');
+
+var assert = require('../support/assert');
+
+var _ = require('underscore');
+
+var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+
+var PgQueryRunner = require('../../lib/cartodb/backends/pg_query_runner');
+var CartodbWindshaft = require('../../lib/cartodb/server');
+var serverOptions = require('../../lib/cartodb/server_options');
+var server = new CartodbWindshaft(serverOptions);
+server.setMaxListeners(0);
+
+describe('tests from old api translated to multilayer', function() {
+
+    var layergroupUrl = '/api/v1/map';
+
+    var keysToDelete;
+
+    beforeEach(function() {
+        keysToDelete = {};
+    });
+
+    afterEach(function(done) {
+        testHelper.deleteRedisKeys(keysToDelete, done);
+    });
+
+    var wadusSql = 'select 1 as cartodb_id, null::geometry as the_geom_webmercator';
+    var pointSql = "SELECT 'SRID=3857;POINT(0 0)'::geometry as the_geom_webmercator, 1::int as cartodb_id";
+
+    function singleLayergroupConfig(sql, cartocss) {
+        return {
+            version: '1.0.0',
+            layers: [
+                {
+                    type: 'mapnik',
+                    options: {
+                        sql: sql,
+                        cartocss: cartocss,
+                        cartocss_version: '2.0.1'
+                    }
+                }
+            ]
+        };
+    }
+
+    function createRequest(layergroup, userHost, apiKey) {
+        var url = layergroupUrl;
+        if (apiKey) {
+            url += '?api_key=' + apiKey;
+        }
+        return {
+            url: url,
+            method: 'POST',
+            headers: {
+                host: userHost || 'localhost',
+                'Content-Type': 'application/json'
+            },
+            data: JSON.stringify(layergroup)
+        };
+    }
+
+    it("layergroup creation fails if CartoCSS is bogus", function(done) {
+        var layergroup = singleLayergroupConfig(wadusSql, '#my_table3{');
+        assert.response(server,
+            createRequest(layergroup),
+            {
+                status: 400
+            },
+            function(res) {
+                var parsed = JSON.parse(res.body);
+                assert.ok(parsed.errors[0].match(/^style0/));
+                assert.ok(parsed.errors[0].match(/missing closing/));
+                done();
+            }
+        );
+    });
+
+    it("multiple bad styles returns 400 with all errors", function(done) {
+        var layergroup = singleLayergroupConfig(wadusSql, '#my_table4{backgxxxxxround-color:#fff;foo:bar}');
+        assert.response(server,
+            createRequest(layergroup),
+            {
+                status: 400
+            },
+            function(res) {
+                var parsed = JSON.parse(res.body);
+                assert.equal(parsed.errors.length, 1);
+                assert.ok(parsed.errors[0].match(/^style0/));
+                assert.ok(parsed.errors[0].match(/Unrecognized rule: backgxxxxxround-color/));
+                assert.ok(parsed.errors[0].match(/Unrecognized rule: foo/));
+                done();
+            }
+        );
+    });
+
+    // Zoom is a special variable
+    it("Specifying zoom level in CartoCSS does not need a 'zoom' variable in SQL output", function(done) {
+        var layergroup = singleLayergroupConfig(pointSql, '#gadm4 [ zoom>=3] { marker-fill:red; }');
+
+        assert.response(server,
+            createRequest(layergroup),
+            {
+                status: 200
+            },
+            function(res) {
+                var parsed = JSON.parse(res.body);
+                assert.ok(parsed.layergroupid);
+                assert.equal(res.headers['x-layergroup-id'], parsed.layergroupid);
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                done();
+            }
+        );
+    });
+
+    // See https://github.com/CartoDB/Windshaft-cartodb/issues/88
+    it("getting a tile from a user-specific database should return an expected tile", function(done) {
+        var layergroup = singleLayergroupConfig(pointSql, '#layer { marker-fill:red; }');
+
+        var backupDBHost = global.environment.postgres.host;
+        global.environment.postgres.host = '6.6.6.6';
+
+        assert.response(server,
+            createRequest(layergroup, 'cartodb250user'),
+            {
+                status: 200
+            },
+            function(res) {
+                var parsed = JSON.parse(res.body);
+                assert.ok(parsed.layergroupid);
+                assert.equal(res.headers['x-layergroup-id'], parsed.layergroupid);
+
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
+                keysToDelete['user:cartodb250user:mapviews:global'] = 5;
+
+                global.environment.postgres.host = backupDBHost;
+                done();
+            }
+        );
+    });
+
+    // See https://github.com/CartoDB/Windshaft-cartodb/issues/89
+    it("getting a tile with a user-specific database password", function(done) {
+        var layergroup = singleLayergroupConfig(pointSql, '#layer { marker-fill:red; }');
+
+        var backupDBPass = global.environment.postgres_auth_pass;
+        global.environment.postgres_auth_pass = '<%= user_password %>';
+
+        assert.response(server,
+            createRequest(layergroup, 'cartodb250user', '4321'),
+            {
+                status: 200
+            },
+            function(res) {
+                var parsed = JSON.parse(res.body);
+                assert.ok(parsed.layergroupid);
+                assert.equal(res.headers['x-layergroup-id'], parsed.layergroupid);
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
+                keysToDelete['user:cartodb250user:mapviews:global'] = 5;
+
+                global.environment.postgres_auth_pass = backupDBPass;
+                done();
+            }
+        );
+    });
+
+    it("creating a layergroup from lzma param",  function(done){
+        var params = {
+            config: JSON.stringify(singleLayergroupConfig(pointSql, '#layer { marker-fill:red; }'))
+        };
+
+        testHelper.lzma_compress_to_base64(JSON.stringify(params), 1, function(err, lzma) {
+            if (err) {
+                return done(err);
+            }
+            assert.response(server,
+                {
+                    url: layergroupUrl + '?lzma=' + encodeURIComponent(lzma),
+                    method: 'GET',
+                    headers: {
+                        host: 'localhost'
+                    },
+                    encoding: 'binary'
+                },
+                {
+                    status: 200
+                },
+                function(res) {
+                    var parsed = JSON.parse(res.body);
+                    assert.ok(parsed.layergroupid);
+
+                    keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
+                    keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                    done();
+                }
+            );
+        });
+    });
+
+    it("creating a layergroup from lzma param, invalid json input",  function(done) {
+        var params = {
+            config: 'WADUS'
+        };
+
+        testHelper.lzma_compress_to_base64(JSON.stringify(params), 1, function(err, lzma) {
+            if (err) {
+                return done(err);
+            }
+            assert.response(server,
+                {
+                    url: layergroupUrl + '?lzma=' + encodeURIComponent(lzma),
+                    method: 'GET',
+                    headers: {
+                        host: 'localhost'
+                    },
+                    encoding: 'binary'
+                },
+                {
+                    status: 400
+                },
+                function(res) {
+                    var parsed = JSON.parse(res.body);
+                    assert.deepEqual(parsed, { errors: [ 'Unexpected token W' ] });
+
+                    done();
+                }
+            );
+        });
+    });
+
+    it("uses queries postgresql to figure affected tables in query",  function(done) {
+        var tableName = 'gadm4';
+        var expectedCacheChannel = _.template('<%= databaseName %>:public.<%= tableName %>', {
+            databaseName: _.template(global.environment.postgres_auth_user, {user_id:1}) + '_db',
+            tableName: tableName
+        });
+
+        var layergroup =  singleLayergroupConfig('select * from ' + tableName, '#gadm4 { marker-fill: red; }');
+
+        assert.response(server,
+            {
+                url: layergroupUrl + '?config=' + encodeURIComponent(JSON.stringify(layergroup)),
+                method: 'GET',
+                headers: {
+                    host: 'localhost'
+                }
+            },
+            {
+                status: 200
+            },
+            function(res) {
+                var parsed = JSON.parse(res.body);
+                assert.ok(parsed.layergroupid);
+
+                assert.ok(res.headers.hasOwnProperty('x-cache-channel'));
+                assert.equal(res.headers['x-cache-channel'], expectedCacheChannel);
+
+                assert.equal(res.headers['x-layergroup-id'], parsed.layergroupid);
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                done();
+            }
+        );
+    });
+
+    // https://github.com/CartoDB/cartodb-postgresql/issues/86
+    it.skip("should not fail with long table names because table name length limit",  function(done) {
+        var tableName = 'long_table_name_with_enough_chars_to_break_querytables_function';
+        var expectedCacheChannel = _.template('<%= databaseName %>:public.<%= tableName %>', {
+            databaseName: _.template(global.environment.postgres_auth_user, {user_id:1}) + '_db',
+            tableName: tableName
+        });
+
+        var layergroup =  singleLayergroupConfig('select * from ' + tableName, '#layer { marker-fill: red; }');
+
+        assert.response(server,
+            {
+                url: layergroupUrl + '?config=' + encodeURIComponent(JSON.stringify(layergroup)),
+                method: 'GET',
+                headers: {
+                    host: 'localhost'
+                }
+            },
+            {
+                status: 200
+            },
+            function(res) {
+                var parsed = JSON.parse(res.body);
+                assert.ok(parsed.layergroupid);
+
+                assert.ok(res.headers.hasOwnProperty('x-cache-channel'));
+                assert.equal(res.headers['x-cache-channel'], expectedCacheChannel);
+
+                assert.equal(res.headers['x-layergroup-id'], parsed.layergroupid);
+
+                done();
+            }
+        );
+    });
+
+    it("creates layergroup fails when postgresql queries fail to figure affected tables in query",  function(done) {
+
+        var runQueryFn = PgQueryRunner.prototype.run;
+        PgQueryRunner.prototype.run = function(username, query, callback) {
+            return callback(new Error('fake error message'), []);
+        };
+
+        var layergroup =  singleLayergroupConfig('select * from gadm4', '#gadm4 { marker-fill: red; }');
+
+        assert.response(server,
+            {
+                url: layergroupUrl + '?config=' + encodeURIComponent(JSON.stringify(layergroup)),
+                method: 'GET',
+                headers: {
+                    host: 'localhost'
+                }
+            },
+            {
+                status: 400
+            },
+            function(res) {
+                PgQueryRunner.prototype.run = runQueryFn;
+
+                assert.ok(!res.headers.hasOwnProperty('x-cache-channel'));
+
+                var parsed = JSON.parse(res.body);
+                assert.deepEqual(parsed, {
+                    errors: ["could not get overviews metadata: fake error message"]
+                });
+
+                done();
+            }
+        );
+    });
+
+    it("tile requests works when postgresql queries fail to figure affected tables in query",  function(done) {
+        var layergroup =  singleLayergroupConfig('select * from gadm4', '#gadm4 { marker-fill: red; }');
+        assert.response(server,
+            {
+                url: layergroupUrl + '?config=' + encodeURIComponent(JSON.stringify(layergroup)),
+                method: 'GET',
+                headers: {
+                    host: 'localhost'
+                }
+            },
+            {
+                status: 200
+            },
+            function(res) {
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(JSON.parse(res.body).layergroupid).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                var runQueryFn = PgQueryRunner.prototype.run;
+                PgQueryRunner.prototype.run = function(username, query, callback) {
+                    return callback(new Error('failed to query database for affected tables'), []);
+                };
+
+                // reset internal cacheChannel cache
+                server.layergroupAffectedTablesCache.cache.reset();
+
+                assert.response(server,
+                    {
+                        url: layergroupUrl + _.template('/<%= layergroupId %>/<%= z %>/<%= x %>/<%= y %>.png', {
+                            layergroupId: JSON.parse(res.body).layergroupid,
+                            z: 0,
+                            x: 0,
+                            y: 0
+                        }),
+                        method: 'GET',
+                        headers: {
+                            host: 'localhost'
+                        },
+                        encoding: 'binary'
+                    },
+                    {
+                        status: 200
+                    },
+                    function(res) {
+                        assert.ok(!res.headers.hasOwnProperty('x-cache-channel'));
+                        PgQueryRunner.prototype.run = runQueryFn;
+                        done();
+                    }
+                );
+            }
+        );
+    });
+
+});

test/acceptance/named_layers.js

@@ -0,0 +1,874 @@
+var test_helper = require('../support/test_helper');
+
+var assert = require('../support/assert');
+var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
+var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
+var server = new CartodbWindshaft(serverOptions);
+
+var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+
+var RedisPool = require('redis-mpool');
+var TemplateMaps = require('../../lib/cartodb/backends/template_maps.js');
+
+var step = require('step');
+
+describe('named_layers', function() {
+    // configure redis pool instance to use in tests
+    var redisPool = new RedisPool(global.environment.redis);
+
+    var templateMaps = new TemplateMaps(redisPool, {
+        max_user_templates: global.environment.maxUserTemplates
+    });
+
+    var wadusLayer = {
+        type: 'cartodb',
+        options: {
+            sql: 'select 1 cartodb_id, null::geometry the_geom_webmercator',
+            cartocss: '#layer { marker-fill: <%= color %>; }',
+            cartocss_version: '2.3.0'
+        }
+    };
+
+    var username = 'localhost';
+
+    var templateName = 'valid_template';
+    var template = {
+        version: '0.0.1',
+        name: templateName,
+        auth: {
+            method: 'open'
+        },
+        "placeholders": {
+            "color": {
+                "type": "css_color",
+                "default": "#cc3300"
+            }
+        },
+        layergroup: {
+            layers: [
+                wadusLayer,
+                wadusLayer
+            ]
+        }
+    };
+
+    var tokenAuthTemplateName = 'auth_valid_template';
+    var tokenAuthTemplate = {
+        version: '0.0.1',
+        name: tokenAuthTemplateName,
+        auth: {
+            method: 'token',
+            valid_tokens: ['valid1', 'valid2']
+        },
+        placeholders: {
+            color: {
+                "type": "css_color",
+                "default": "#cc3300"
+            }
+        },
+        layergroup: {
+            layers: [
+                wadusLayer
+            ]
+        }
+    };
+
+
+    var namedMapLayer = {
+        type: 'named',
+        options: {
+            name: templateName,
+            config: {},
+            auth_tokens: []
+        }
+    };
+
+    var nestedNamedMapTemplateName = 'nested_template';
+    var nestedNamedMapTemplate = {
+        version: '0.0.1',
+        name: nestedNamedMapTemplateName,
+        auth: {
+            method: 'open'
+        },
+        layergroup: {
+            layers: [
+                namedMapLayer
+            ]
+        }
+    };
+
+    var keysToDelete;
+
+    beforeEach(function() {
+        keysToDelete = {};
+    });
+
+    afterEach(function(done) {
+        test_helper.deleteRedisKeys(keysToDelete, done);
+    });
+
+    beforeEach(function(done) {
+        global.environment.enabledFeatures = {cdbQueryTablesFromPostgres: true};
+        templateMaps.addTemplate(username, nestedNamedMapTemplate, function(err) {
+            if (err) {
+                return done(err);
+            }
+            templateMaps.addTemplate(username, tokenAuthTemplate, function(err) {
+                if (err) {
+                    return done(err);
+                }
+                templateMaps.addTemplate(username, template, function(err) {
+                    return done(err);
+                });
+            });
+        });
+    });
+
+    afterEach(function(done) {
+        global.environment.enabledFeatures = {cdbQueryTablesFromPostgres: false};
+        templateMaps.delTemplate(username, nestedNamedMapTemplateName, function(err) {
+            if (err) {
+                return done(err);
+            }
+            templateMaps.delTemplate(username, tokenAuthTemplateName, function(err) {
+                if (err) {
+                    return done(err);
+                }
+                templateMaps.delTemplate(username, templateName, function(err) {
+                    return done(err);
+                });
+            });
+        });
+    });
+
+    it('should fail for non-existing template name', function(done) {
+        var layergroup =  {
+            version: '1.3.0',
+            layers: [
+                {
+                    type: 'named',
+                    options: {
+                        name: 'nonexistent'
+                    }
+                }
+            ]
+        };
+
+        step(
+            function createLayergroup() {
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map',
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        },
+                        data: JSON.stringify(layergroup)
+                    },
+                    {
+                        status: 400
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function checkLayergroup(err, response) {
+                if (err) {
+                    throw err;
+                }
+
+                var parsedBody = JSON.parse(response.body);
+                assert.deepEqual(parsedBody, { errors: ["Template 'nonexistent' of user 'localhost' not found"] });
+
+                return null;
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+    });
+
+    it('should return 403 if not properly authorized', function(done) {
+
+        var layergroup =  {
+            version: '1.3.0',
+            layers: [
+                {
+                    type: 'named',
+                    options: {
+                        name: tokenAuthTemplateName,
+                        config: {},
+                        auth_tokens: ['token1']
+                    }
+                }
+            ]
+        };
+
+        step(
+            function createLayergroup() {
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map',
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        },
+                        data: JSON.stringify(layergroup)
+                    },
+                    {
+                        status: 403
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function checkLayergroup(err, response) {
+                if (err) {
+                    throw err;
+                }
+
+                var parsedBody = JSON.parse(response.body);
+                assert.deepEqual(
+                    parsedBody,
+                    { errors: [ "Unauthorized 'auth_valid_template' template instantiation" ] }
+                );
+
+                return null;
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+
+    });
+
+    it('should return 200 and layergroup if properly authorized', function(done) {
+
+        var layergroup =  {
+            version: '1.3.0',
+            layers: [
+                {
+                    type: 'named',
+                    options: {
+                        name: tokenAuthTemplateName,
+                        config: {},
+                        auth_tokens: ['valid1']
+                    }
+                }
+            ]
+        };
+
+        step(
+            function createLayergroup() {
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map',
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        },
+                        data: JSON.stringify(layergroup)
+                    },
+                    {
+                        status: 200
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function checkLayergroup(err, response) {
+                if (err) {
+                    throw err;
+                }
+
+                var parsedBody = JSON.parse(response.body);
+                assert.ok(parsedBody.layergroupid);
+                assert.ok(parsedBody.last_updated);
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                return null;
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+
+    });
+
+    it('should return 400 for nested named map layers', function(done) {
+
+        var layergroup =  {
+            version: '1.3.0',
+            layers: [
+                {
+                    type: 'named',
+                    options: {
+                        name: nestedNamedMapTemplateName
+                    }
+                }
+            ]
+        };
+
+        step(
+            function createLayergroup() {
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map',
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        },
+                        data: JSON.stringify(layergroup)
+                    },
+                    {
+                        status: 400
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function checkLayergroup(err, response) {
+                if (err) {
+                    throw err;
+                }
+
+                var parsedBody = JSON.parse(response.body);
+                assert.deepEqual(parsedBody, { errors: [ 'Nested named layers are not allowed' ] });
+
+                return null;
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+
+    });
+
+    it('should return 200 and layergroup with private tables', function(done) {
+
+        var privateTableTemplateName = 'private_table_template';
+        var privateTableTemplate = {
+            version: '0.0.1',
+            name: privateTableTemplateName,
+            auth: {
+                method: 'open'
+            },
+            layergroup: {
+                layers: [
+                    {
+                        type: 'cartodb',
+                        options: {
+                            sql: 'select * from test_table_private_1',
+                            cartocss: '#layer { marker-fill: #cc3300; }',
+                            cartocss_version: '2.3.0'
+                        }
+                    }
+                ]
+            }
+        };
+
+        var layergroup =  {
+            version: '1.3.0',
+            layers: [
+                {
+                    type: 'named',
+                    options: {
+                        name: privateTableTemplateName
+                    }
+                }
+            ]
+        };
+
+        step(
+            function createTemplate() {
+                templateMaps.addTemplate(username, privateTableTemplate, this);
+            },
+            function createLayergroup(err) {
+                if (err) {
+                    throw err;
+                }
+
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map',
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        },
+                        data: JSON.stringify(layergroup)
+                    },
+                    {
+                        status: 200
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function checkLayergroup(err, response) {
+                if (err) {
+                    throw err;
+                }
+
+                var parsedBody = JSON.parse(response.body);
+                assert.ok(parsedBody.layergroupid);
+                assert.ok(parsedBody.last_updated);
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                return parsedBody.layergroupid;
+            },
+            function requestTile(err, layergroupId) {
+                if (err) {
+                    throw err;
+                }
+
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map/' + layergroupId + '/0/0/0.png',
+                        method: 'GET',
+                        headers: {
+                            host: 'localhost'
+                        },
+                        encoding: 'binary'
+                    },
+                    {
+                        status: 200,
+                        headers: {
+                            'content-type': 'image/png'
+                        }
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function handleTileResponse(err, res) {
+                if (err) {
+                    throw err;
+                }
+                test_helper.checkCache(res);
+                return true;
+            },
+            function deleteTemplate(err) {
+                var next = this;
+                templateMaps.delTemplate(username, privateTableTemplateName, function(/*delErr*/) {
+                    // ignore deletion error
+                    next(err);
+                });
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+
+    });
+
+    it('should return 200 and layergroup with private tables and interactivity', function(done) {
+
+        var privateTableTemplateNameInteractivity = 'private_table_template_interactivity';
+        var privateTableTemplate = {
+            "version": "0.0.1",
+            "auth": {
+                "method": "open"
+            },
+            "name": privateTableTemplateNameInteractivity,
+            "layergroup": {
+                "layers": [
+                    {
+                        "type": "cartodb",
+                        "options": {
+                            "attributes": {
+                                "columns": [
+                                    "name"
+                                ],
+                                "id": "cartodb_id"
+                            },
+                            "cartocss": "#layer { marker-fill: #cc3300; }",
+                            "cartocss_version": "2.3.0",
+                            "interactivity": "cartodb_id",
+                            "sql": "select * from test_table_private_1"
+                        }
+                    }
+                ]
+            }
+        };
+
+        var layergroup =  {
+            version: '1.3.0',
+            layers: [
+                {
+                    type: 'named',
+                    options: {
+                        name: privateTableTemplateNameInteractivity
+                    }
+                }
+            ]
+        };
+
+        step(
+            function createTemplate() {
+                templateMaps.addTemplate(username, privateTableTemplate, this);
+            },
+            function createLayergroup(err) {
+                if (err) {
+                    throw err;
+                }
+
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map',
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        },
+                        data: JSON.stringify(layergroup)
+                    },
+                    {
+                        status: 200
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function checkLayergroup(err, response) {
+                if (err) {
+                    throw err;
+                }
+
+                var parsedBody = JSON.parse(response.body);
+                assert.ok(parsedBody.layergroupid);
+                assert.ok(parsedBody.last_updated);
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                return parsedBody.layergroupid;
+            },
+            function requestTile(err, layergroupId) {
+                if (err) {
+                    throw err;
+                }
+
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map/' + layergroupId + '/0/0/0.png',
+                        method: 'GET',
+                        headers: {
+                            host: 'localhost'
+                        },
+                        encoding: 'binary'
+                    },
+                    {
+                        status: 200,
+                        headers: {
+                            'content-type': 'image/png'
+                        }
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function handleTileResponse(err, res) {
+                if (err) {
+                    throw err;
+                }
+                test_helper.checkCache(res);
+                return true;
+            },
+            function deleteTemplate(err) {
+                var next = this;
+                templateMaps.delTemplate(username, privateTableTemplateNameInteractivity, function(/*delErr*/) {
+                    // ignore deletion error
+                    next(err);
+                });
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+
+    });
+
+    it('should return 403 when private table is accessed from non named layer', function(done) {
+
+        var layergroup =  {
+            version: '1.3.0',
+            layers: [
+                {
+                    type: 'cartodb',
+                    options: {
+                        sql: 'select * from test_table_private_1',
+                        cartocss: '#layer { marker-fill: #cc3300; }',
+                        cartocss_version: '2.3.0'
+                    }
+                },
+                {
+                    type: 'named',
+                    options: {
+                        name: templateName
+                    }
+                }
+            ]
+        };
+
+        step(
+            function createLayergroup() {
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map',
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        },
+                        data: JSON.stringify(layergroup)
+                    },
+                    {
+                        status: 403
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function checkLayergroup(err, response) {
+                if (err) {
+                    throw err;
+                }
+
+                var parsedBody = JSON.parse(response.body);
+                assert.ok(parsedBody.errors[0].match(/permission denied for relation test_table_private_1/));
+
+                return null;
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+
+    });
+
+    it('should return metadata for named layers', function(done) {
+
+        var layergroup =  {
+            version: '1.3.0',
+            layers: [
+                {
+                    type: 'plain',
+                    options: {
+                        color: '#fabada'
+                    }
+                },
+                {
+                    type: 'cartodb',
+                    options: {
+                        sql: 'select * from test_table',
+                        cartocss: '#layer { marker-fill: #cc3300; }',
+                        cartocss_version: '2.3.0'
+                    }
+                },
+                {
+                    type: 'named',
+                    options: {
+                        name: templateName
+                    }
+                },
+                {
+                    type: 'torque',
+                    options: {
+                        sql: "select * from test_table LIMIT 0",
+                        cartocss: "Map { -torque-frame-count:1; -torque-resolution:1; " +
+                        "-torque-aggregation-function:'count(*)'; -torque-time-attribute:'updated_at'; }"
+                    }
+                }
+            ]
+        };
+
+        step(
+            function createLayergroup() {
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map',
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        },
+                        data: JSON.stringify(layergroup)
+                    },
+                    {
+                        status: 200
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function checkLayergroup(err, response) {
+                if (err) {
+                    throw err;
+                }
+
+                var parsedBody = JSON.parse(response.body);
+                assert.ok(parsedBody.metadata);
+                assert.ok(parsedBody.metadata.layers);
+                assert.equal(parsedBody.metadata.layers.length, 5);
+                assert.equal(parsedBody.metadata.layers[0].type, 'plain');
+                assert.equal(parsedBody.metadata.layers[1].type, 'mapnik');
+                assert.equal(parsedBody.metadata.layers[2].type, 'mapnik');
+                assert.equal(parsedBody.metadata.layers[3].type, 'mapnik');
+                assert.equal(parsedBody.metadata.layers[4].type, 'torque');
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                return null;
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+
+    });
+
+    it('should work with named tiles', function(done) {
+
+        var namedTilesTemplateName = 'named_tiles_template';
+        var namedTilesTemplate = {
+            version: '0.0.1',
+            name: namedTilesTemplateName,
+            auth: {
+                method: 'open'
+            },
+            layergroup: {
+                layers: [
+                    namedMapLayer,
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from test_table_private_1',
+                            cartocss: '#layer { marker-fill: #cc3300; }',
+                            cartocss_version: '2.3.0'
+                        }
+                    }
+                ]
+            }
+        };
+
+        step(
+            function createTemplate() {
+                templateMaps.addTemplate(username, namedTilesTemplate, this);
+            },
+            function createLayergroup(err) {
+                if (err) {
+                    throw err;
+                }
+
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map/named/' + namedTilesTemplateName + '?api_key=1234',
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        }
+                    },
+                    {
+                        status: 200
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function checkLayergroup(err, response) {
+                if (err) {
+                    throw err;
+                }
+
+                var parsedBody = JSON.parse(response.body);
+                assert.ok(parsedBody.layergroupid);
+                assert.ok(parsedBody.last_updated);
+
+                assert.equal(parsedBody.metadata.layers[0].type, 'mapnik');
+                assert.equal(parsedBody.metadata.layers[1].type, 'mapnik');
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                return parsedBody.layergroupid;
+            },
+            function requestTile(err, layergroupId) {
+                if (err) {
+                    throw err;
+                }
+
+                var next = this;
+                assert.response(server,
+                    {
+                        url: '/api/v1/map/' + layergroupId + '/all/0/0/0.png',
+                        method: 'GET',
+                        headers: {
+                            host: 'localhost'
+                        },
+                        encoding: 'binary'
+                    },
+                    {
+                        status: 200,
+                        headers: {
+                            'content-type': 'image/png'
+                        }
+                    },
+                    function(res, err) {
+                        next(err, res);
+                    }
+                );
+            },
+            function handleTileResponse(err, res) {
+                if (err) {
+                    throw err;
+                }
+                test_helper.checkCache(res);
+                return true;
+            },
+            function deleteTemplate(err) {
+                var next = this;
+                templateMaps.delTemplate(username, namedTilesTemplateName, function(/*delErr*/) {
+                    // ignore deletion error
+                    next(err);
+                });
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+
+    });
+});

test/acceptance/named_maps_authentication.js

@@ -0,0 +1,269 @@
+var test_helper = require('../support/test_helper');
+var RedisPool = require('redis-mpool');
+var querystring = require('querystring');
+
+var assert = require('../support/assert');
+var mapnik = require('windshaft').mapnik;
+var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
+var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
+var server = new CartodbWindshaft(serverOptions);
+var TemplateMaps = require('../../lib/cartodb/backends/template_maps.js');
+var NamedMapsCacheEntry = require('../../lib/cartodb/cache/model/named_maps_entry');
+
+describe('named maps authentication', function() {
+    // configure redis pool instance to use in tests
+    var redisPool = new RedisPool(global.environment.redis);
+
+    var templateMaps = new TemplateMaps(redisPool, {
+        max_user_templates: global.environment.maxUserTemplates
+    });
+
+    var wadusLayer = {
+        type: 'cartodb',
+        options: {
+            sql: 'select 1 cartodb_id, null::geometry the_geom_webmercator',
+            cartocss: '#layer { marker-fill: <%= color %>; }',
+            cartocss_version: '2.3.0'
+        }
+    };
+
+    var username = 'localhost';
+
+    var templateName = 'valid_template';
+    var template = {
+        version: '0.0.1',
+        name: templateName,
+        auth: {
+            method: 'open'
+        },
+        "placeholders": {
+            "color": {
+                "type": "css_color",
+                "default": "#cc3300"
+            }
+        },
+        layergroup: {
+            layers: [
+                wadusLayer
+            ]
+        }
+    };
+
+    var tokenAuthTemplateName = 'auth_valid_template';
+    var tokenAuthTemplate = {
+        version: '0.0.1',
+        name: tokenAuthTemplateName,
+        auth: {
+            method: 'token',
+            valid_tokens: ['valid1', 'valid2']
+        },
+        placeholders: {
+            color: {
+                "type": "css_color",
+                "default": "#cc3300"
+            }
+        },
+        layergroup: {
+            layers: [
+                wadusLayer
+            ]
+        }
+    };
+
+
+    var namedMapLayer = {
+        type: 'named',
+        options: {
+            name: templateName,
+            config: {},
+            auth_tokens: []
+        }
+    };
+
+    var nestedNamedMapTemplateName = 'nested_template';
+    var nestedNamedMapTemplate = {
+        version: '0.0.1',
+        name: nestedNamedMapTemplateName,
+        auth: {
+            method: 'open'
+        },
+        layergroup: {
+            layers: [
+                namedMapLayer
+            ]
+        }
+    };
+
+    beforeEach(function (done) {
+        templateMaps.addTemplate(username, nestedNamedMapTemplate, function (err) {
+            if (err) {
+                return done(err);
+            }
+            templateMaps.addTemplate(username, tokenAuthTemplate, function (err) {
+                if (err) {
+                    return done(err);
+                }
+                templateMaps.addTemplate(username, template, function (err) {
+                    return done(err);
+                });
+            });
+        });
+    });
+
+    afterEach(function (done) {
+        templateMaps.delTemplate(username, nestedNamedMapTemplateName, function (err) {
+            if (err) {
+                return done(err);
+            }
+            templateMaps.delTemplate(username, tokenAuthTemplateName, function (err) {
+                if (err) {
+                    return done(err);
+                }
+                templateMaps.delTemplate(username, templateName, function (err) {
+                    return done(err);
+                });
+            });
+        });
+    });
+
+    function getNamedTile(name, z, x, y, options, callback) {
+
+        var url = '/api/v1/map/named/' + name + '/all/' + [z,x,y].join('/') + '.png';
+        if (options.params) {
+            url = url + '?' + querystring.stringify(options.params);
+        }
+        var requestOptions = {
+            url: url,
+            method: 'GET',
+            headers: {
+                host: username
+            },
+            encoding: 'binary'
+        };
+
+        var statusCode = options.status || 200;
+
+        var expectedResponse = {
+            status: statusCode,
+            headers: {
+                'Content-Type': statusCode === 200 ? 'image/png' : 'application/json; charset=utf-8'
+            }
+        };
+
+        assert.response(server,
+            requestOptions,
+            expectedResponse,
+            function (res, err) {
+                var img;
+                if (!err && res.headers['content-type'] === 'image/png') {
+                    img = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
+                }
+                return callback(err, res, img);
+            }
+        );
+    }
+
+    describe('tiles', function() {
+        it('should return a 404 error for nonexistent template name', function (done) {
+            var nonexistentName = 'nonexistent';
+            getNamedTile(nonexistentName, 0, 0, 0, { status: 404 }, function(err, res) {
+                assert.ok(!err);
+                assert.deepEqual(
+                    JSON.parse(res.body),
+                    { errors: ["Template '" + nonexistentName + "' of user '" + username + "' not found"] }
+                );
+                done();
+            });
+        });
+
+        it('should return 403 if not properly authorized', function(done) {
+            getNamedTile(tokenAuthTemplateName, 0, 0, 0, { status: 403 }, function(err, res) {
+                assert.ok(!err);
+                assert.deepEqual(JSON.parse(res.body), { errors: ['Unauthorized template instantiation'] });
+                done();
+            });
+        });
+
+        it('should return 200 if properly authorized', function(done) {
+            getNamedTile(tokenAuthTemplateName, 0, 0, 0, { params: { auth_token: 'valid1' } }, function(err, res, img) {
+                assert.equal(img.width(), 256);
+                assert.equal(img.height(), 256);
+
+                assert.ok(!err);
+                test_helper.checkSurrogateKey(res, new NamedMapsCacheEntry(username, tokenAuthTemplateName).key());
+                done();
+            });
+        });
+    });
+
+    function getStaticMap(name, options, callback) {
+
+        var url = '/api/v1/map/static/named/' + name + '/640/480.png';
+        if (options.params) {
+            url = url + '?' + querystring.stringify(options.params);
+        }
+        var requestOptions = {
+            url: url,
+            method: 'GET',
+            headers: {
+                host: username
+            },
+            encoding: 'binary'
+        };
+
+        var statusCode = options.status || 200;
+
+        var expectedResponse = {
+            status: statusCode,
+            headers: {
+                'Content-Type': statusCode === 200 ? 'image/png' : 'application/json; charset=utf-8'
+            }
+        };
+
+        assert.response(server,
+            requestOptions,
+            expectedResponse,
+            function (res, err) {
+                var img;
+                if (!err && res.headers['content-type'] === 'image/png') {
+                    img = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
+                }
+                return callback(err, res, img);
+            }
+        );
+    }
+    describe('static maps', function() {
+        it('should return a 404 error for nonexistent template name', function (done) {
+            var nonexistentName = 'nonexistent';
+            getStaticMap(nonexistentName, { status: 404 }, function(err, res) {
+                assert.ok(!err);
+                assert.deepEqual(
+                    JSON.parse(res.body),
+                    { errors: ["Template '" + nonexistentName + "' of user '" + username + "' not found"] }
+                );
+                done();
+            });
+        });
+
+        it('should return 403 if not properly authorized', function(done) {
+            getStaticMap(tokenAuthTemplateName, { status: 403 }, function(err, res) {
+                assert.ok(!err);
+                assert.deepEqual(JSON.parse(res.body), { errors: ['Unauthorized template instantiation'] });
+                done();
+            });
+        });
+
+        it('should return 200 if properly authorized', function(done) {
+            getStaticMap(tokenAuthTemplateName, { params: { auth_token: 'valid1' } }, function(err, res, img) {
+                assert.ok(!err);
+
+                assert.equal(img.width(), 640);
+                assert.equal(img.height(), 480);
+
+                test_helper.checkSurrogateKey(res, new NamedMapsCacheEntry(username, tokenAuthTemplateName).key());
+                test_helper.deleteRedisKeys({'user:localhost:mapviews:global': 5}, done);
+            });
+        });
+    });
+
+});

test/acceptance/named_maps_cache.js

@@ -0,0 +1,140 @@
+require('../support/test_helper');
+var RedisPool = require('redis-mpool');
+
+var assert = require('../support/assert');
+var mapnik = require('windshaft').mapnik;
+var CartodbWindshaft = require('../../lib/cartodb/server');
+var serverOptions = require('../../lib/cartodb/server_options');
+var server = new CartodbWindshaft(serverOptions);
+var TemplateMaps = require('../../lib/cartodb/backends/template_maps.js');
+
+describe('named maps provider cache', function() {
+    // configure redis pool instance to use in tests
+    var redisPool = new RedisPool(global.environment.redis);
+
+    var templateMaps = new TemplateMaps(redisPool, {
+        max_user_templates: global.environment.maxUserTemplates
+    });
+
+    var username = 'localhost';
+    var templateName = 'template_with_color';
+
+    var IMAGE_TOLERANCE = 20;
+
+    function createTemplate(color) {
+        return {
+            version: '0.0.1',
+            name: templateName,
+            auth: {
+                method: 'open'
+            },
+            placeholders: {
+                color: {
+                    type: "css_color",
+                    default: color
+                }
+            },
+            layergroup: {
+                layers: [
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from populated_places_simple_reduced',
+                            cartocss: '#layer { marker-fill: <%= color %>; marker-line-color: <%= color %>; }',
+                            cartocss_version: '2.3.0'
+                        }
+                    }
+                ]
+            }
+        };
+    }
+
+    afterEach(function (done) {
+        templateMaps.delTemplate(username, templateName, done);
+    });
+
+    function getNamedTile(options, callback) {
+        if (!callback) {
+            callback = options;
+            options = {};
+        }
+
+        var url = '/api/v1/map/named/' + templateName + '/all/' + [0,0,0].join('/') + '.png';
+
+        var requestOptions = {
+            url: url,
+            method: 'GET',
+            headers: {
+                host: username
+            },
+            encoding: 'binary'
+        };
+
+        var statusCode = options.statusCode || 200;
+
+        var expectedResponse = {
+            status: statusCode,
+            headers: {
+                'Content-Type': statusCode === 200 ? 'image/png' : 'application/json; charset=utf-8'
+            }
+        };
+
+        assert.response(server, requestOptions, expectedResponse, function (res, err) {
+            var img;
+            if (statusCode === 200) {
+                img = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
+            }
+            return callback(err, res, img);
+        });
+    }
+
+    function previewFixture(color) {
+        return './test/fixtures/provider/populated_places_simple_reduced-' + color + '.png';
+    }
+
+    var colors = ['red', 'red', 'green', 'blue'];
+    colors.forEach(function(color) {
+        it('should return an image estimating its bounds based on dataset', function (done) {
+            templateMaps.addTemplate(username, createTemplate(color), function (err) {
+                if (err) {
+                    return done(err);
+                }
+                getNamedTile(function(err, res, img) {
+                    assert.ok(!err);
+                    assert.imageIsSimilarToFile(img, previewFixture(color), IMAGE_TOLERANCE, done);
+                });
+            });
+        });
+    });
+
+    it('should fail to use template from named map provider after template deletion', function (done) {
+        var color = 'black';
+        templateMaps.addTemplate(username, createTemplate(color), function (err) {
+            if (err) {
+                return done(err);
+            }
+            getNamedTile(function(err, res, img) {
+                assert.ok(!err);
+                assert.imageIsSimilarToFile(img, previewFixture(color), IMAGE_TOLERANCE, function(err) {
+                    assert.ok(!err);
+
+                    templateMaps.delTemplate(username, templateName, function (err) {
+                        assert.ok(!err);
+
+                        getNamedTile({ statusCode: 404 }, function(err, res) {
+                            assert.ok(!err);
+                            assert.deepEqual(
+                                JSON.parse(res.body),
+                                { errors: ["Template 'template_with_color' of user 'localhost' not found"] }
+                            );
+
+                            // add template again so it's clean in afterEach
+                            templateMaps.addTemplate(username, createTemplate(color), done);
+                        });
+                    });
+                });
+            });
+        });
+    });
+
+});

test/acceptance/named_maps_static_view.js

@@ -0,0 +1,166 @@
+var testHelper = require('../support/test_helper');
+var RedisPool = require('redis-mpool');
+
+var assert = require('../support/assert');
+var mapnik = require('windshaft').mapnik;
+var CartodbWindshaft = require('../../lib/cartodb/server');
+var serverOptions = require('../../lib/cartodb/server_options');
+var TemplateMaps = require('../../lib/cartodb/backends/template_maps.js');
+
+describe('named maps static view', function() {
+    // configure redis pool instance to use in tests
+    var redisPool = new RedisPool(global.environment.redis);
+
+    var templateMaps = new TemplateMaps(redisPool, {
+        max_user_templates: global.environment.maxUserTemplates
+    });
+
+    var username = 'localhost';
+    var templateName = 'template_with_view';
+
+    var IMAGE_TOLERANCE = 20;
+
+    function createTemplate(view) {
+        return {
+            version: '0.0.1',
+            name: templateName,
+            auth: {
+                method: 'open'
+            },
+            placeholders: {
+                color: {
+                    type: "css_color",
+                    default: "#cc3300"
+                }
+            },
+            view: view,
+            layergroup: {
+                layers: [
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from populated_places_simple_reduced',
+                            cartocss: '#layer { marker-fill: <%= color %>; }',
+                            cartocss_version: '2.3.0'
+                        }
+                    }
+                ]
+            }
+        };
+    }
+
+    afterEach(function (done) {
+        templateMaps.delTemplate(username, templateName, done);
+    });
+
+    function getStaticMap(callback) {
+
+        var url = '/api/v1/map/static/named/' + templateName + '/640/480.png';
+
+        var requestOptions = {
+            url: url,
+            method: 'GET',
+            headers: {
+                host: username
+            },
+            encoding: 'binary'
+        };
+
+        var expectedResponse = {
+            status: 200,
+            headers: {
+                'Content-Type': 'image/png'
+            }
+        };
+
+        // this could be removed once named maps are invalidated, otherwise you hits the cache
+        var server = new CartodbWindshaft(serverOptions);
+
+        assert.response(server, requestOptions, expectedResponse, function (res, err) {
+            testHelper.deleteRedisKeys({'user:localhost:mapviews:global': 5}, function() {
+                return callback(err, mapnik.Image.fromBytes(new Buffer(res.body, 'binary')));
+            });
+        });
+    }
+
+    function previewFixture(version) {
+        return './test/fixtures/previews/populated_places_simple_reduced-' + version + '.png';
+    }
+
+    it('should return an image estimating its bounds based on dataset', function (done) {
+        templateMaps.addTemplate(username, createTemplate(), function (err) {
+            if (err) {
+                return done(err);
+            }
+            getStaticMap(function(err, img) {
+                assert.ok(!err);
+                assert.imageIsSimilarToFile(img, previewFixture('estimated'), IMAGE_TOLERANCE, done);
+            });
+        });
+    });
+
+    it('should return an image using view zoom + center', function (done) {
+        var view = {
+            zoom: 4,
+            center: {
+                lng: 40,
+                lat: 20
+            }
+        };
+        templateMaps.addTemplate(username, createTemplate(view), function (err) {
+            if (err) {
+                return done(err);
+            }
+            getStaticMap(function(err, img) {
+                assert.ok(!err);
+                assert.imageIsSimilarToFile(img, previewFixture('zoom-center'), IMAGE_TOLERANCE, done);
+            });
+        });
+    });
+
+    it('should return an image using view bounds', function (done) {
+        var view = {
+            bounds: {
+                west: 0,
+                south: 0,
+                east: 45,
+                north: 45
+            }
+        };
+        templateMaps.addTemplate(username, createTemplate(view), function (err) {
+            if (err) {
+                return done(err);
+            }
+            getStaticMap(function(err, img) {
+                assert.ok(!err);
+                assert.imageIsSimilarToFile(img, previewFixture('bounds'), IMAGE_TOLERANCE, done);
+            });
+        });
+    });
+
+    it('should return an image using view zoom + center when bounds are also present', function (done) {
+        var view = {
+            bounds: {
+                west: 0,
+                south: 0,
+                east: 45,
+                north: 45
+            },
+            zoom: 4,
+            center: {
+                lng: 40,
+                lat: 20
+            }
+        };
+        templateMaps.addTemplate(username, createTemplate(view), function (err) {
+            if (err) {
+                return done(err);
+            }
+            getStaticMap(function(err, img) {
+                assert.ok(!err);
+                assert.imageIsSimilarToFile(img, previewFixture('zoom-center'), IMAGE_TOLERANCE, done);
+            });
+        });
+    });
+
+});

test/acceptance/named_maps_stats.js

@@ -0,0 +1,110 @@
+var test_helper = require('../support/test_helper');
+var RedisPool = require('redis-mpool');
+var querystring = require('querystring');
+
+var assert = require('../support/assert');
+var mapnik = require('windshaft').mapnik;
+var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
+var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
+var server = new CartodbWindshaft(serverOptions);
+var TemplateMaps = require('../../lib/cartodb/backends/template_maps.js');
+var NamedMapsCacheEntry = require('../../lib/cartodb/cache/model/named_maps_entry');
+
+describe('named maps preview stats', function() {
+    var redisPool = new RedisPool(global.environment.redis);
+
+    var templateMaps = new TemplateMaps(redisPool, {
+        max_user_templates: global.environment.maxUserTemplates
+    });
+
+    var username = 'localhost';
+
+    var statTag = 'wadus_viz';
+    var templateName = 'with_stats';
+    var template = {
+        version: '0.0.1',
+        name: templateName,
+        auth: {
+            method: 'open'
+        },
+        "placeholders": {
+            "color": {
+                "type": "css_color",
+                "default": "#cc3300"
+            }
+        },
+        layergroup: {
+            stat_tag: statTag,
+            layers: [
+                {
+                    type: 'cartodb',
+                    options: {
+                        sql: 'select 1 cartodb_id, null::geometry the_geom_webmercator',
+                        cartocss: '#layer { marker-fill: <%= color %>; }',
+                        cartocss_version: '2.3.0'
+                    }
+                }
+            ]
+        }
+    };
+
+
+    beforeEach(function (done) {
+        templateMaps.addTemplate(username, template, done);
+    });
+
+    afterEach(function (done) {
+        templateMaps.delTemplate(username, templateName, done);
+    });
+
+    function getStaticMap(name, options, callback) {
+
+        var url = '/api/v1/map/static/named/' + name + '/640/480.png';
+        if (options.params) {
+            url = url + '?' + querystring.stringify(options.params);
+        }
+        var requestOptions = {
+            url: url,
+            method: 'GET',
+            headers: {
+                host: username
+            },
+            encoding: 'binary'
+        };
+
+        var statusCode = options.status || 200;
+
+        var expectedResponse = {
+            status: statusCode,
+            headers: {
+                'Content-Type': statusCode === 200 ? 'image/png' : 'application/json; charset=utf-8'
+            }
+        };
+
+        assert.response(server,
+            requestOptions,
+            expectedResponse,
+            function (res, err) {
+                var img;
+                if (!err && res.headers['content-type'] === 'image/png') {
+                    img = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
+                }
+                return callback(err, res, img);
+            }
+        );
+    }
+
+    it('should return 200 if properly authorized', function(done) {
+        getStaticMap(templateName, { params: { auth_token: 'valid1' } }, function(err, res, img) {
+            assert.ok(!err);
+
+            assert.equal(img.width(), 640);
+            assert.equal(img.height(), 480);
+
+            test_helper.checkSurrogateKey(res, new NamedMapsCacheEntry(username, templateName).key());
+            var redisKeysToDelete = { 'user:localhost:mapviews:global': 5 };
+            redisKeysToDelete['user:localhost:mapviews:stat_tag:' + statTag] = 5;
+            test_helper.deleteRedisKeys(redisKeysToDelete, done);
+        });
+    });
+});

test/acceptance/overviews_metadata.js

@@ -0,0 +1,110 @@
+var test_helper = require('../support/test_helper');
+
+var assert = require('../support/assert');
+var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
+var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
+var server = new CartodbWindshaft(serverOptions);
+
+var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+
+var RedisPool = require('redis-mpool');
+
+var step = require('step');
+
+var windshaft = require('windshaft');
+
+
+describe('overviews metadata', function() {
+    // configure redis pool instance to use in tests
+    var redisPool = new RedisPool(global.environment.redis);
+
+    var overviews_layer = {
+        type: 'cartodb',
+        options: {
+            sql: 'SELECT * FROM test_table_overviews',
+            cartocss: '#layer { marker-fill: black; }',
+            cartocss_version: '2.3.0'
+        }
+    };
+
+    var non_overviews_layer = {
+        type: 'cartodb',
+        options: {
+            sql: 'SELECT * FROM test_table',
+            cartocss: '#layer { marker-fill: black; }',
+            cartocss_version: '2.3.0'
+        }
+    };
+
+    var keysToDelete;
+
+    beforeEach(function() {
+        keysToDelete = {};
+    });
+
+    afterEach(function(done) {
+        test_helper.deleteRedisKeys(keysToDelete, done);
+    });
+
+    it("layers with and without overviews", function(done) {
+
+      var layergroup =  {
+        version: '1.0.0',
+        layers: [overviews_layer, non_overviews_layer]
+      };
+
+      var layergroup_url = '/api/v1/map';
+
+      var expected_token;
+      step(
+        function do_post()
+        {
+          var next = this;
+          assert.response(server, {
+              url: layergroup_url,
+              method: 'POST',
+              headers: {host: 'localhost', 'Content-Type': 'application/json' },
+              data: JSON.stringify(layergroup)
+          }, {}, function(res) {
+              assert.equal(res.statusCode, 200, res.body);
+              var parsedBody = JSON.parse(res.body);
+              assert.equal(res.headers['x-layergroup-id'], parsedBody.layergroupid);
+              expected_token = parsedBody.layergroupid;
+              next(null, res);
+          });
+        },
+        function do_get_mapconfig(err)
+        {
+            assert.ifError(err);
+            var next = this;
+
+            var mapStore  = new windshaft.storage.MapStore({
+                pool: redisPool,
+                expire_time: 500000
+            });
+            mapStore.load(LayergroupToken.parse(expected_token).token, function(err, mapConfig) {
+              assert.ifError(err);
+              assert.deepEqual(non_overviews_layer, mapConfig._cfg.layers[1]);
+              assert.equal(mapConfig._cfg.layers[0].type, 'cartodb');
+              assert.ok(mapConfig._cfg.layers[0].options.query_rewrite_data);
+              var expected_data = {
+                overviews: {
+                  test_table_overviews: {
+                    1: { table: '_vovw_1_test_table_overviews' },
+                    2: { table: '_vovw_2_test_table_overviews' }
+                  }
+                }
+              };
+              assert.deepEqual(mapConfig._cfg.layers[0].options.query_rewrite_data, expected_data);
+            });
+
+            next(err);
+        },
+        function finish(err) {
+            keysToDelete['map_cfg|' + LayergroupToken.parse(expected_token).token] = 0;
+            keysToDelete['user:localhost:mapviews:global'] = 5;
+            done(err);
+        }
+      );
+    });
+});

test/acceptance/overviews_queries.js

@@ -0,0 +1,73 @@
+var testHelper = require('../support/test_helper');
+var assert = require('../support/assert');
+
+var cartodbServer = require('../../lib/cartodb/server');
+var ServerOptions = require('./ported/support/ported_server_options');
+var testClient = require('./ported/support/test_client');
+var BaseController = require('../../lib/cartodb/controllers/base');
+
+describe('overviews_queries', function() {
+
+    var server = cartodbServer(ServerOptions);
+    server.setMaxListeners(0);
+
+    var IMAGE_EQUALS_TOLERANCE_PER_MIL = 2;
+
+    var req2paramsFn;
+    before(function() {
+        req2paramsFn = BaseController.prototype.req2params;
+        BaseController.prototype.req2params = ServerOptions.req2params;
+    });
+
+    after(function() {
+        BaseController.prototype.req2params = req2paramsFn;
+
+        testHelper.rmdirRecursiveSync(global.environment.millstone.cache_basedir);
+    });
+
+    function imageCompareFn(fixture, done) {
+        return function(err, tile) {
+            if (err) {
+                return done(err);
+            }
+            var referenceImagePath = './test/fixtures/' + fixture;
+            assert.imageBufferIsSimilarToFile(tile.body, referenceImagePath, IMAGE_EQUALS_TOLERANCE_PER_MIL, done);
+        };
+    }
+
+    it("should not use overview for tables without overviews", function(done){
+      testClient.getTile(testClient.defaultTableMapConfig('test_table'), 1, 0, 0,
+          imageCompareFn('test_table_1_0_0.png', done)
+      );
+    });
+
+    it("should not use overview for tables without overviews at z=2", function(done){
+      testClient.getTile(testClient.defaultTableMapConfig('test_table'), 2, 1, 1,
+          imageCompareFn('test_table_2_1_1.png', done)
+      );
+    });
+
+    it("should not use overview for tables without overviews at z=2", function(done){
+      testClient.getTile(testClient.defaultTableMapConfig('test_table'), 3, 3, 3,
+          imageCompareFn('test_table_3_3_3.png', done)
+      );
+    });
+
+    it("should use overview for zoom level 1", function(done){
+      testClient.getTile(testClient.defaultTableMapConfig('test_table_overviews'), 1, 0, 0,
+          imageCompareFn('_vovw_1_test_table_1_0_0.png', done)
+      );
+    });
+
+    it("should use overview for zoom level 1", function(done){
+      testClient.getTile(testClient.defaultTableMapConfig('test_table_overviews'), 2, 1, 1,
+          imageCompareFn('_vovw_2_test_table_2_1_1.png', done)
+      );
+    });
+
+    it("should not use overview for zoom level 3", function(done){
+      testClient.getTile(testClient.defaultTableMapConfig('test_table_overviews'), 3, 3, 3,
+          imageCompareFn('test_table_3_3_3.png', done)
+      );
+    });
+});

test/acceptance/ported/attributes.js

@@ -0,0 +1,303 @@
+var testHelper = require('../../support/test_helper');
+
+var assert        = require('../../support/assert');
+var step          = require('step');
+var cartodbServer = require('../../../lib/cartodb/server');
+var PortedServerOptions = require('./support/ported_server_options');
+var BaseController = require('../../../lib/cartodb/controllers/base');
+
+var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+
+
+describe('attributes', function() {
+
+    var server = cartodbServer(PortedServerOptions);
+    server.setMaxListeners(0);
+
+    var test_mapconfig_1 =  {
+        version: '1.1.0',
+        layers: [
+            { type: 'mapnik', options: {
+                sql: "select 1 as id, 'SRID=4326;POINT(0 0)'::geometry as the_geom",
+                cartocss: '#style { }',
+                cartocss_version: '2.0.1'
+            } },
+            { type: 'mapnik', options: {
+                sql: "select 1 as i, 6 as n, 'SRID=4326;POINT(0 0)'::geometry as the_geom",
+                attributes: { id:'i', columns: ['n'] },
+                cartocss: '#style { }',
+                cartocss_version: '2.0.1'
+            } }
+        ]
+    };
+
+    function checkCORSHeaders(res) {
+        assert.equal(
+            res.headers['access-control-allow-headers'],
+            'X-Requested-With, X-Prototype-Version, X-CSRF-Token'
+        );
+        assert.equal(res.headers['access-control-allow-origin'], '*');
+    }
+
+    var keysToDelete;
+
+    beforeEach(function() {
+        keysToDelete = {};
+    });
+
+    afterEach(function(done) {
+        testHelper.deleteRedisKeys(keysToDelete, done);
+    });
+
+    var req2paramsFn;
+    before(function() {
+        req2paramsFn = BaseController.prototype.req2params;
+        BaseController.prototype.req2params = PortedServerOptions.req2params;
+    });
+
+    after(function() {
+        BaseController.prototype.req2params = req2paramsFn;
+    });
+
+    it("can only be fetched from layer having an attributes spec", function(done) {
+
+            var expected_token;
+            step(
+                function do_post()
+                {
+                    var next = this;
+                    assert.response(server, {
+                        url: '/database/windshaft_test/layergroup',
+                        method: 'POST',
+                        headers: {'Content-Type': 'application/json' },
+                        data: JSON.stringify(test_mapconfig_1)
+                    }, {}, function(res, err) { next(err, res); });
+                },
+                function checkPost(err, res) {
+                    assert.ifError(err);
+                    assert.equal(res.statusCode, 200, res.statusCode + ': ' + res.body);
+                    // CORS headers should be sent with response
+                    // from layergroup creation via POST
+                    checkCORSHeaders(res);
+                    var parsedBody = JSON.parse(res.body);
+                    if ( expected_token ) {
+                        assert.deepEqual(parsedBody, {layergroupid: expected_token, layercount: 2});
+                    } else {
+                        expected_token = parsedBody.layergroupid;
+                    }
+                    return null;
+                },
+                function do_get_attr_0(err)
+                {
+                    assert.ifError(err);
+                    var next = this;
+                    assert.response(server, {
+                        url: '/database/windshaft_test/layergroup/' + expected_token + '/0/attributes/1',
+                        method: 'GET'
+                    }, {}, function(res, err) { next(err, res); });
+                },
+                function check_error_0(err, res) {
+                    assert.ifError(err);
+                    assert.equal(
+                        res.statusCode,
+                        400,
+                        res.statusCode + ( res.statusCode !== 200 ? (': ' + res.body) : '' )
+                    );
+                    var parsed = JSON.parse(res.body);
+                    assert.equal(parsed.errors[0], "Layer 0 has no exposed attributes");
+                    return null;
+                },
+                function do_get_attr_1(err)
+                {
+                    assert.ifError(err);
+                    var next = this;
+                    assert.response(server, {
+                        url: '/database/windshaft_test/layergroup/' + expected_token + '/1/attributes/1',
+                        method: 'GET'
+                    }, {}, function(res, err) { next(err, res); });
+                },
+                function check_attr_1(err, res) {
+                    assert.ifError(err);
+                    assert.equal(res.statusCode, 200, res.statusCode + ': ' + res.body);
+                    var parsed = JSON.parse(res.body);
+                    assert.deepEqual(parsed, {"n":6});
+                    return null;
+                },
+                function do_get_attr_1_404(err)
+                {
+                    assert.ifError(err);
+                    var next = this;
+                    assert.response(server, {
+                        url: '/database/windshaft_test/layergroup/' + expected_token + '/1/attributes/-666',
+                        method: 'GET'
+                    }, {}, function(res, err) { next(err, res); });
+                },
+                function check_attr_1_404(err, res) {
+                    assert.ifError(err);
+                    assert.equal(res.statusCode, 404, res.statusCode + ': ' + res.body);
+                    var parsed = JSON.parse(res.body);
+                    assert.ok(parsed.errors);
+                    var msg = parsed.errors[0];
+                    assert.ok(msg.match(/0 features.*identified by fid -666/), msg);
+                    return null;
+                },
+                function finish(err) {
+                    keysToDelete['map_cfg|' + LayergroupToken.parse(expected_token).token] = 0;
+                    keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                    done(err);
+                }
+            );
+        });
+
+    // See https://github.com/CartoDB/Windshaft/issues/131
+    it("are checked at map creation time", function(done) {
+
+            // clone the mapconfig test
+            var mapconfig = JSON.parse(JSON.stringify(test_mapconfig_1));
+            // append unexistant attribute name
+            mapconfig.layers[1].options.sql = 'SELECT * FROM test_table';
+            mapconfig.layers[1].options.attributes.id = 'unexistant';
+            mapconfig.layers[1].options.attributes.columns = ['cartodb_id'];
+
+            step(
+                function do_post()
+                {
+                    var next = this;
+                    assert.response(server, {
+                        url: '/database/windshaft_test/layergroup',
+                        method: 'POST',
+                        headers: {'Content-Type': 'application/json' },
+                        data: JSON.stringify(mapconfig)
+                    }, {}, function(res, err) { next(err, res); });
+                },
+                function checkPost(err, res) {
+                    assert.ifError(err);
+                    assert.equal(res.statusCode, 404, res.statusCode + ': ' + (res.statusCode===200?'...':res.body));
+                    var parsed = JSON.parse(res.body);
+                    assert.ok(parsed.errors);
+                    assert.equal(parsed.errors.length, 1);
+                    var msg = parsed.errors[0];
+                    assert.equal(msg, 'column "unexistant" does not exist');
+                    return null;
+                },
+                function finish(err) {
+                    done(err);
+                }
+            );
+        });
+
+    it("can be used with jsonp", function(done) {
+
+        var expected_token;
+        step(
+            function do_post()
+            {
+                var next = this;
+                assert.response(server, {
+                    url: '/database/windshaft_test/layergroup',
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json' },
+                    data: JSON.stringify(test_mapconfig_1)
+                }, {}, function(res, err) { next(err, res); });
+            },
+            function checkPost(err, res) {
+                assert.ifError(err);
+                assert.equal(res.statusCode, 200, res.statusCode + ': ' + res.body);
+                // CORS headers should be sent with response
+                // from layergroup creation via POST
+                checkCORSHeaders(res);
+                var parsedBody = JSON.parse(res.body);
+                if ( expected_token ) {
+                    assert.deepEqual(parsedBody, {layergroupid: expected_token, layercount: 2});
+                } else {
+                    expected_token = parsedBody.layergroupid;
+                }
+                return null;
+            },
+            function do_get_attr_0(err)
+            {
+                assert.ifError(err);
+                var next = this;
+                assert.response(server, {
+                    url: '/database/windshaft_test/layergroup/' + expected_token +
+                        '/0/attributes/1?callback=test',
+                    method: 'GET'
+                }, {}, function(res, err) { next(err, res); });
+            },
+            function check_error_0(err, res) {
+                assert.ifError(err);
+                // jsonp errors should be returned with HTTP status 200
+                assert.equal(res.statusCode, 200, res.statusCode + ': ' + res.body);
+                assert.equal(
+                    res.body,
+                    '/**/ typeof test === \'function\' && test({"errors":["Layer 0 has no exposed attributes"]});'
+                );
+                return null;
+            },
+            function do_get_attr_1(err)
+            {
+                assert.ifError(err);
+                var next = this;
+                assert.response(server, {
+                    url: '/database/windshaft_test/layergroup/' + expected_token + '/1/attributes/1',
+                    method: 'GET'
+                }, {}, function(res, err) { next(err, res); });
+            },
+            function check_attr_1(err, res) {
+                assert.ifError(err);
+                assert.equal(res.statusCode, 200, res.statusCode + ': ' + res.body);
+                var parsed = JSON.parse(res.body);
+                assert.deepEqual(parsed, {"n":6});
+                return null;
+            },
+            function finish(err) {
+                keysToDelete['map_cfg|' + LayergroupToken.parse(expected_token).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                done(err);
+            }
+        );
+    });
+
+    // Test that you cannot write to the database from an attributes tile request
+    //
+    // Test for http://github.com/CartoDB/Windshaft/issues/130
+    //
+    it("database access is read-only", function(done) {
+
+        // clone the mapconfig test
+        var mapconfig = JSON.parse(JSON.stringify(test_mapconfig_1));
+        mapconfig.layers[1].options.sql +=
+            ", test_table_inserter(st_setsrid(st_point(0,0),4326),'write') as w";
+        mapconfig.layers[1].options.attributes.columns.push('w');
+
+        step(
+            function do_post()
+            {
+                var next = this;
+                assert.response(server, {
+                    url: '/database/windshaft_test/layergroup',
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json' },
+                    data: JSON.stringify(mapconfig)
+                }, {}, function(res, err) { next(err, res); });
+            },
+            function checkPost(err, res) {
+                assert.ifError(err);
+                // TODO: should be 403 Forbidden
+                assert.equal(res.statusCode, 400, res.statusCode + ': ' + (res.statusCode===200?'...':res.body));
+                var parsed = JSON.parse(res.body);
+                assert.ok(parsed.errors);
+                assert.equal(parsed.errors.length, 1);
+                var msg = parsed.errors[0];
+                assert.equal(msg, "cannot execute INSERT in a read-only transaction");
+                return null;
+            },
+            function finish(err) {
+                done(err);
+            }
+        );
+    });
+
+});

test/acceptance/ported/blend.js

@@ -0,0 +1,107 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var testClient = require('./support/test_client');
+
+var PortedServerOptions = require('./support/ported_server_options');
+var BaseController = require('../../../lib/cartodb/controllers/base');
+
+describe('blend png renderer', function() {
+
+    var req2paramsFn;
+    before(function() {
+        req2paramsFn = BaseController.prototype.req2params;
+        BaseController.prototype.req2params = PortedServerOptions.req2params;
+    });
+
+    after(function() {
+        BaseController.prototype.req2params = req2paramsFn;
+    });
+
+    var IMAGE_TOLERANCE_PER_MIL = 20;
+
+    function plainTorqueMapConfig(plainColor) {
+        return {
+            version: '1.2.0',
+            layers: [
+                {
+                    type: 'plain',
+                    options: {
+                        color: plainColor
+                    }
+                },
+                {
+                    type: 'torque',
+                    options: {
+                        sql: "SELECT * FROM populated_places_simple_reduced " +
+                            "where the_geom && ST_MakeEnvelope(-90, 0, 90, 65)",
+                        cartocss: [
+                            'Map {',
+                            '    buffer-size:0;',
+                            '    -torque-frame-count:1;',
+                            '    -torque-animation-duration:30;',
+                            '    -torque-time-attribute:"cartodb_id";',
+                            '    -torque-aggregation-function:"count(cartodb_id)";',
+                            '    -torque-resolution:1;',
+                            '    -torque-data-aggregation:linear;',
+                            '}',
+                            '#populated_places_simple_reduced{',
+                            '    comp-op: multiply;',
+                            '    marker-fill-opacity: 1;',
+                            '    marker-line-color: #FFF;',
+                            '    marker-line-width: 0;',
+                            '    marker-line-opacity: 1;',
+                            '    marker-type: rectangle;',
+                            '    marker-width: 3;',
+                            '    marker-fill: #FFCC00;',
+                            '}'
+                        ].join(' '),
+                        cartocss_version: '2.3.0'
+                    }
+                }
+            ]
+        };
+    }
+
+    var testScenarios = [
+        {
+            tile: {
+                z: 2,
+                x: 2,
+                y: 1,
+                layer: 'all',
+                format: 'png'
+            },
+            plainColor: 'white'
+        },
+        {
+            tile: {
+                z: 2,
+                x: 1,
+                y: 1,
+                layer: 'all',
+                format: 'png'
+            },
+            plainColor: '#339900'
+        }
+    ];
+
+    function blendPngFixture(zxy) {
+        return './test/fixtures/blend/blend-plain-torque-' + zxy.join('.') + '.png';
+    }
+
+    testScenarios.forEach(function(testScenario) {
+        var tileRequest = testScenario.tile;
+        var zxy = [tileRequest.z, tileRequest.x, tileRequest.y];
+        it('tile all/' + zxy.join('/') + '.png', function (done) {
+            testClient.getTileLayer(plainTorqueMapConfig(testScenario.plainColor), tileRequest, function(err, res) {
+                assert.imageBufferIsSimilarToFile(res.body, blendPngFixture(zxy), IMAGE_TOLERANCE_PER_MIL,
+                    function(err) {
+                        assert.ok(!err);
+                        done();
+                    }
+                );
+            });
+        });
+    });
+});

test/acceptance/ported/blend_filtering.js

@@ -0,0 +1,168 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var testClient = require('./support/test_client');
+var fs = require('fs');
+var http = require('http');
+
+var PortedServerOptions = require('./support/ported_server_options');
+var BaseController = require('../../../lib/cartodb/controllers/base');
+
+describe('blend layer filtering', function() {
+
+    var IMG_TOLERANCE_PER_MIL = 20;
+
+    var httpRendererResourcesServer;
+
+    var req2paramsFn;
+    before(function(done) {
+        req2paramsFn = BaseController.prototype.req2params;
+        BaseController.prototype.req2params = PortedServerOptions.req2params;
+
+        // Start a server to test external resources
+        httpRendererResourcesServer = http.createServer( function(request, response) {
+            var filename = __dirname + '/../../fixtures/http/light_nolabels-1-0-0.png';
+            fs.readFile(filename, {encoding: 'binary'}, function(err, file) {
+                response.writeHead(200);
+                response.write(file, "binary");
+                response.end();
+            });
+        });
+        httpRendererResourcesServer.listen(8033, done);
+    });
+
+    after(function(done) {
+        BaseController.prototype.req2params = req2paramsFn;
+        httpRendererResourcesServer.close(done);
+    });
+
+    var mapConfig = {
+        version: '1.2.0',
+        layers: [
+            {
+                type: 'plain',
+                options: {
+                    color: '#fabada'
+                }
+            },
+            {
+                type: 'http',
+                options: {
+                    urlTemplate: 'http://127.0.0.1:8033/{s}/{z}/{x}/{y}.png',
+                    subdomains: ['abcd']
+                }
+            },
+            {
+                type: 'mapnik',
+                options: {
+                    sql: 'SELECT * FROM populated_places_simple_reduced',
+                    cartocss: '#layer { marker-fill:red; } #layer { marker-width: 2; }',
+                    cartocss_version: '2.3.0',
+                    geom_column: 'the_geom'
+                }
+            },
+            {
+                type: 'torque',
+                options: {
+                    sql: "SELECT * FROM populated_places_simple_reduced",
+                    cartocss: [
+                        'Map {',
+                        '    buffer-size:0;',
+                        '    -torque-frame-count:1;',
+                        '    -torque-animation-duration:30;',
+                        '    -torque-time-attribute:"cartodb_id";',
+                        '    -torque-aggregation-function:"count(cartodb_id)";',
+                        '    -torque-resolution:1;',
+                        '    -torque-data-aggregation:linear;',
+                        '}',
+                        '#populated_places_simple_reduced{',
+                        '    comp-op: multiply;',
+                        '    marker-fill-opacity: 1;',
+                        '    marker-line-color: #FFF;',
+                        '    marker-line-width: 0;',
+                        '    marker-line-opacity: 1;',
+                        '    marker-type: rectangle;',
+                        '    marker-width: 3;',
+                        '    marker-fill: #FFCC00;',
+                        '}'
+                    ].join(' '),
+                    cartocss_version: '2.3.0'
+                }
+            },
+            {
+                type: 'http',
+                options: {
+                    urlTemplate: 'http://127.0.0.1:8033/{s}/{z}/{x}/{y}.png',
+                    subdomains: ['abcd']
+                }
+            },
+            {
+                type: 'torque',
+                options: {
+                    sql: "SELECT * FROM populated_places_simple_reduced " +
+                        "where the_geom && ST_MakeEnvelope(-90, 0, 90, 65)",
+                    cartocss: [
+                        'Map {',
+                        '    buffer-size:0;',
+                        '    -torque-frame-count:1;',
+                        '    -torque-animation-duration:30;',
+                        '    -torque-time-attribute:"cartodb_id";',
+                        '    -torque-aggregation-function:"count(cartodb_id)";',
+                        '    -torque-resolution:1;',
+                        '    -torque-data-aggregation:linear;',
+                        '}',
+                        '#populated_places_simple_reduced{',
+                        '    comp-op: multiply;',
+                        '    marker-fill-opacity: 1;',
+                        '    marker-line-color: #FFF;',
+                        '    marker-line-width: 0;',
+                        '    marker-line-opacity: 1;',
+                        '    marker-type: rectangle;',
+                        '    marker-width: 3;',
+                        '    marker-fill: #FFCC00;',
+                        '}'
+                    ].join(' '),
+                    cartocss_version: '2.3.0'
+                }
+            }
+        ]
+    };
+
+    var filteredLayersSuite = [
+        [2, 2],
+        [0, 1],
+        [0, 2],
+        [1, 2],
+        [2, 1], // ordering doesn't matter
+        [0, 3],
+        [1, 3],
+        [1, 2, 5],
+        [1, 2, 3, 4]
+    ];
+
+    function blendPngFixture(layers) {
+        return './test/fixtures/blend/blend-filtering-layers-' + layers.join('.') + '-zxy-1.0.0.png';
+    }
+
+    filteredLayersSuite.forEach(function(filteredLayers) {
+        var layerFilter = filteredLayers.join(',');
+        var tileRequest = {
+            z: 1,
+            x: 0,
+            y: 0,
+            layer: layerFilter,
+            format: 'png'
+        };
+
+        it('should filter on ' + layerFilter + '/1/0/0.png', function (done) {
+            testClient.getTileLayer(mapConfig, tileRequest, function(err, res) {
+                assert.imageBufferIsSimilarToFile(res.body, blendPngFixture(filteredLayers), IMG_TOLERANCE_PER_MIL,
+                    function(err) {
+                        assert.ok(!err);
+                        done();
+                    }
+                );
+            });
+        });
+    });
+});

test/acceptance/ported/blend_http_fallback.js

@@ -0,0 +1,149 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var testClient = require('./support/test_client');
+var fs = require('fs');
+var http = require('http');
+
+var PortedServerOptions = require('./support/ported_server_options');
+var BaseController = require('../../../lib/cartodb/controllers/base');
+
+describe('blend http fallback', function() {
+
+    var IMG_TOLERANCE_PER_MIL = 20;
+
+    var httpRendererResourcesServer;
+
+    var req2paramsFn;
+    before(function(done) {
+        req2paramsFn = BaseController.prototype.req2params;
+        BaseController.prototype.req2params = PortedServerOptions.req2params;
+        // Start a server to test external resources
+        httpRendererResourcesServer = http.createServer( function(request, response) {
+            if (request.url.match(/^\/error404\//)) {
+                response.writeHead(404);
+                response.end();
+            } else {
+                var filename = __dirname + '/../../fixtures/http/light_nolabels-1-0-0.png';
+                if (request.url.match(/^\/dark\//)) {
+                    filename = __dirname + '/../../fixtures/http/dark_nolabels-1-0-0.png';
+                }
+                fs.readFile(filename, {encoding: 'binary'}, function(err, file) {
+                    response.writeHead(200);
+                    response.write(file, "binary");
+                    response.end();
+                });
+            }
+        });
+        httpRendererResourcesServer.listen(8033, done);
+    });
+
+    after(function(done) {
+        BaseController.prototype.req2params = req2paramsFn;
+        httpRendererResourcesServer.close(done);
+    });
+
+    var mapConfig = {
+        version: '1.2.0',
+        layers: [
+            {
+                type: 'plain', // <- 0
+                options: {
+                    color: '#fabada'
+                }
+            },
+            {
+                type: 'http', // <- 1
+                options: {
+                    urlTemplate: 'http://127.0.0.1:8033/{s}/{z}/{x}/{y}.png',
+                    subdomains: ['light']
+                }
+            },
+            {
+                type: 'http', // <- 2
+                options: {
+                    urlTemplate: 'http://127.0.0.1:8033/{s}/{z}/{x}/{y}.png',
+                    subdomains: ['dark']
+                }
+            },
+            {
+                type: 'http', // <- 3
+                options: {
+                    urlTemplate: 'http://127.0.0.1:8033/{s}/{z}/{x}/{y}.png',
+                    subdomains: ['error404']
+                }
+            },
+            {
+                type: 'mapnik', // <- 4
+                options: {
+                    sql: 'SELECT * FROM populated_places_simple_reduced',
+                    cartocss: '#layer { marker-fill:red; } #layer { marker-width: 2; }',
+                    cartocss_version: '2.3.0',
+                    geom_column: 'the_geom'
+                }
+            }
+        ]
+    };
+
+    var filteredLayersSuite = [
+        //['all'], // layers displayed: 2 + 4, skipping 3 as it fails
+        [0, 4],
+        [0, 3], // skips layer 3 as it fails
+        [1, 2],
+        [1, 3],
+        [2, 3],
+        [3, 4]
+    ];
+
+    function blendPngFixture(layers) {
+        return './test/fixtures/blend/http_fallback/blend-layers-' + layers.join('.') + '-zxy-1.0.0.png';
+    }
+
+    filteredLayersSuite.forEach(function(filteredLayers) {
+        var layerFilter = filteredLayers.join(',');
+        var tileRequest = {
+            z: 1,
+            x: 0,
+            y: 0,
+            layer: layerFilter,
+            format: 'png'
+        };
+
+        it('should fallback on http error while blending layers ' + layerFilter + '/1/0/0.png', function (done) {
+            testClient.getTileLayer(mapConfig, tileRequest, function(err, res) {
+                assert.imageBufferIsSimilarToFile(res.body, blendPngFixture(filteredLayers), IMG_TOLERANCE_PER_MIL,
+                    function(err) {
+                        assert.ok(!err, err);
+                        done();
+                    }
+                );
+            });
+        });
+    });
+
+    it('should keep failing when http layer is requested individually', function(done) {
+        var tileRequest = {
+            z: 1,
+            x: 0,
+            y: 0,
+            layer: 3,
+            format: 'png'
+        };
+        var expectedResponse = {
+            status: 400,
+            headers: {
+                'Content-Type': 'application/json; charset=utf-8'
+            }
+        };
+        testClient.getTileLayer(mapConfig, tileRequest, expectedResponse, function(err, res) {
+            assert.ok(!err);
+            var parsedBody = JSON.parse(res.body);
+            assert.deepEqual(parsedBody, {
+                errors: [
+                    "Unable to fetch http tile: http://127.0.0.1:8033/error404/1/0/0.png [404]"
+                ]
+            });
+            done();
+        });
+    });
+});

test/acceptance/ported/blend_http_timeout.js

@@ -0,0 +1,95 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var testClient = require('./support/test_client');
+var serverOptions = require('./support/ported_server_options');
+var fs = require('fs');
+var http = require('http');
+
+var PortedServerOptions = require('./support/ported_server_options');
+var BaseController = require('../../../lib/cartodb/controllers/base');
+
+describe.skip('blend http client timeout', function() {
+
+    var req2paramsFn;
+    before(function() {
+        req2paramsFn = BaseController.prototype.req2params;
+        BaseController.prototype.req2params = PortedServerOptions.req2params;
+    });
+
+    after(function() {
+        BaseController.prototype.req2params = req2paramsFn;
+    });
+
+    var mapConfig = {
+        version: '1.3.0',
+        layers: [
+            {
+                type: 'http',
+                options: {
+                    urlTemplate: 'http://127.0.0.1:8033/{s}/{z}/{x}/{y}.png',
+                    subdomains: ['light']
+                }
+            },
+            {
+                type: 'mapnik',
+                options: {
+                    sql: 'SELECT * FROM populated_places_simple_reduced',
+                    cartocss: '#layer { marker-fill:red; } #layer { marker-width: 2; }',
+                    cartocss_version: '2.3.0',
+                    geom_column: 'the_geom'
+                }
+            }
+        ]
+    };
+
+    var oldHttpRendererTimeout;
+    var httpRendererTimeout = 100;
+
+    var slowHttpRendererResourcesServer;
+
+    before(function(done) {
+        oldHttpRendererTimeout = serverOptions.renderer.http.timeout;
+        serverOptions.renderer.http.timeout = httpRendererTimeout;
+
+        // Start a server to test external resources
+        slowHttpRendererResourcesServer = http.createServer( function(request, response) {
+            setTimeout(function() {
+                var filename = __dirname + '/../fixtures/http/light_nolabels-1-0-0.png';
+                fs.readFile(filename, {encoding: 'binary'}, function(err, file) {
+                    response.writeHead(200);
+                    response.write(file, "binary");
+                    response.end();
+                });
+            }, httpRendererTimeout * 2);
+        });
+        slowHttpRendererResourcesServer.listen(8033, done);
+    });
+
+    after(function(done) {
+        serverOptions.renderer.http.timeout = oldHttpRendererTimeout;
+        slowHttpRendererResourcesServer.close(done);
+    });
+
+    it('should fail to render when http layer times out', function(done) {
+        var options = {
+            statusCode: 400,
+            contentType: 'application/json; charset=utf-8',
+            serverOptions: serverOptions
+        };
+        testClient.withLayergroup(mapConfig, options, function(err, requestTile, finish) {
+            var tileUrl = '/all/0/0/0.png';
+            requestTile(tileUrl, options, function(err, res) {
+                assert.ok(!err);
+                var parsedBody = JSON.parse(res.body);
+                assert.ok(parsedBody.errors);
+                assert.ok(parsedBody.errors.length);
+                assert.equal(parsedBody.errors[0], 'Unable to fetch http tile: http://127.0.0.1:8033/light/0/0/0.png');
+                finish(function(finishErr) {
+                    done(err || finishErr);
+                });
+            });
+        });
+    });
+
+});