412 lines
18 KiB
JavaScript
412 lines
18 KiB
JavaScript
var config = {
|
|
environment: process.env.CARTO_WINDSHAFT_NODE_ENV,
|
|
port: 8181,
|
|
host: null, // null on purpouse so it listens to whatever address docker assigns
|
|
// 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,
|
|
// Time in milliseconds to force GC cycle.
|
|
// Disable by using <=0 value.
|
|
gc_interval: 10000,
|
|
// Regular expression pattern to extract username
|
|
// from hostname. Must have a single grabbing block.
|
|
user_from_host: process.env.CARTO_WINDSHAFT_USER_FROM_HOST || '^(.*)\\.cartodb\\.com$',
|
|
|
|
// Base URLs for the APIs
|
|
//
|
|
// See https://github.com/CartoDB/Windshaft-cartodb/wiki/Unified-Map-API
|
|
//
|
|
// Note: each entry corresponds with an express' router.
|
|
// You must define at least one path. However, middlewares are optional.
|
|
routes: {
|
|
api: [{
|
|
paths: [
|
|
'/api/v1',
|
|
'/user/:user/api/v1'
|
|
],
|
|
// Optional: attach middlewares at the begining of the router
|
|
// to perform custom operations.
|
|
middlewares: [
|
|
function noop () {
|
|
return function noopMiddleware (req, res, next) {
|
|
next();
|
|
};
|
|
}
|
|
],
|
|
// Base url for the Detached Maps API
|
|
// "/api/v1/map" is the new API,
|
|
map: [{
|
|
paths: [
|
|
'/map'
|
|
],
|
|
middlewares: [] // Optional
|
|
}],
|
|
// Base url for the Templated Maps API
|
|
// "/api/v1/map/named" is the new API,
|
|
template: [{
|
|
paths: [
|
|
'/map/named'
|
|
],
|
|
middlewares: [] // Optional
|
|
}]
|
|
}]
|
|
},
|
|
|
|
// Resource URLs expose endpoints to request/retrieve metadata associated to Maps: dataviews, analysis node status.
|
|
//
|
|
// This URLs depend on how `routes` and `user_from_host` are configured: the application can be
|
|
// configured to accept request with the {user} in the header host or in the request path.
|
|
// It also might depend on the configured cdn_url via `serverMetadata.cdn_url`.
|
|
//
|
|
// This template allows to make the endpoints generation more flexible, the template exposes the following params:
|
|
// 1. {{=it.cdn_url}}: will be used when `serverMetadata.cdn_url` exists.
|
|
// 2. {{=it.user}}: will use the username as extraced from `user_from_host` or `routes`.
|
|
// 3. {{=it.port}}: will use the `port` from this very same configuration file.
|
|
resources_url_templates: {
|
|
http: 'http://{{=it.cdn_url}}/{{=it.user}}/api/v1/map',
|
|
https: 'https://{{=it.cdn_url}}/{{=it.user}}/api/v1/map'
|
|
},
|
|
// Specify the maximum length of the queue of pending connections for the HTTP server.
|
|
// The actual length will be determined by the OS through sysctl settings such as tcp_max_syn_backlog and somaxconn on Linux.
|
|
// The default value of this parameter is 511 (not 512).
|
|
// See: https://nodejs.org/docs/latest/api/net.html#net_server_listen
|
|
maxConnections: 128,
|
|
// 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,
|
|
// Templated database username for authorized user
|
|
// Supported labels: 'user_id' (read from redis)
|
|
postgres_auth_user: process.env.CARTO_WINDSHAFT_DB_USER || 'cartodb_user_<%= user_id %>',
|
|
// Templated database password for authorized user
|
|
// Supported labels: 'user_id', 'user_password' (both read from redis)
|
|
postgres_auth_pass: '<%= user_password %>',
|
|
postgres: {
|
|
user: 'publicuser',
|
|
password: 'public',
|
|
host: process.env.CARTO_WINDSHAFT_POSTGRES_HOST || 'localhost',
|
|
port: process.env.CARTO_WINDSHAFT_POSTGRES_PORT || 5432,
|
|
pool: {
|
|
// 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
|
|
}
|
|
},
|
|
mapnik_version: undefined,
|
|
mapnik_tile_format: 'png8:m=h',
|
|
statsd: {
|
|
host: process.env.CARTO_WINDSHAFT_STATSD_HOST || 'localhost',
|
|
port: 8125,
|
|
prefix: process.env.CARTO_WINDSHAFT_STATSD_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,
|
|
statsInterval: 5000, // milliseconds between each report to statsd about number of renderers and mapnik pool status
|
|
mvt: {
|
|
// If enabled, MVTs will be generated with PostGIS directly
|
|
// If disabled, MVTs will be generated with Mapnik MVT
|
|
usePostGIS: true
|
|
},
|
|
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,
|
|
|
|
// The maximum number of waiting clients of the pool of internal mapnik backend
|
|
// This maximum number is per mapnik renderer created in Windshaft's RendererFactory
|
|
poolMaxWaitingClients: 64,
|
|
|
|
// Whether grainstore will use a child process or not to transform CartoCSS into Mapnik XML.
|
|
// This will prevent blocking the main thread.
|
|
useCartocssWorkers: false,
|
|
|
|
// 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: true,
|
|
|
|
postgis: {
|
|
// Parameters to pass to datasource plugin of mapnik
|
|
// See http://github.com/mapnik/mapnik/wiki/PostGIS
|
|
user: 'publicuser',
|
|
password: 'public',
|
|
host: process.env.CARTO_WINDSHAFT_POSTGRES_HOST || '127.0.0.1',
|
|
port: process.env.CARTO_WINDSHAFT_POSTGRES_PORT || 5432,
|
|
extent: '-20037508.3,-20037508.3,20037508.3,20037508.3',
|
|
// max number of rows to return when querying data, 0 means no limit
|
|
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,
|
|
twkb_encoding: true
|
|
},
|
|
|
|
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
|
|
},
|
|
|
|
// If enabled Mapnik will reuse the features retrieved from the database
|
|
// instead of requesting them once per style inside a layer
|
|
'cache-features': true,
|
|
|
|
// Require metrics to the renderer
|
|
metrics: false,
|
|
|
|
// Options for markers attributes, ellipses and images caches
|
|
markers_symbolizer_caches: {
|
|
disabled: false
|
|
}
|
|
},
|
|
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: {}
|
|
},
|
|
// anything analyses related
|
|
analysis: {
|
|
// batch configuration
|
|
batch: {
|
|
// Inline execution avoid the use of SQL API as batch endpoint
|
|
// When set to true it will run all analysis queries in series, with a direct connection to the DB
|
|
// This might be useful for:
|
|
// - testing
|
|
// - running an standalone server without any dependency on external services
|
|
inlineExecution: false,
|
|
// where the SQL API is running, it will use a custom Host header to specify the username.
|
|
endpoint: 'http://127.0.0.1:8080/api/v2/sql/job',
|
|
// the template to use for adding the host header in the batch api requests
|
|
hostHeaderTemplate: '{{=it.username}}.localhost.lan'
|
|
},
|
|
// Define max execution time in ms for analyses or tags
|
|
// If analysis or tag are not found in redis this values will be used as default.
|
|
limits: {
|
|
moran: { timeout: 120000, maxNumberOfRows: 1e5 },
|
|
cpu2x: { timeout: 60000 }
|
|
}
|
|
},
|
|
millstone: {
|
|
// Needs to be writable by server user
|
|
cache_basedir: process.env.CARTO_WINDSHAFT_TILE_CACHE || '/home/ubuntu/tile_assets/'
|
|
},
|
|
redis: {
|
|
host: process.env.CARTO_WINDSHAFT_REDIS_HOST || '127.0.0.1',
|
|
port: process.env.CARTO_WINDSHAFT_REDIS_PORT || 6379,
|
|
// 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 2 pools involved in serving
|
|
// windshaft-cartodb requests so multiply this number
|
|
// by 2 to know how many possible connections will be
|
|
// kept open by the servelsr. 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
|
|
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
|
|
},
|
|
// 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: process.env.CARTO_WINDSHAFT_VARNISH_PORT || 'localhost',
|
|
port: process.env.CARTO_WINDSHAFT_VARNISH_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: process.env.CARTO_WINDSHAFT_VARNISH_PURGE_ENABLED === 'true' || false, // whether the purge/invalidation mechanism is enabled in varnish or not
|
|
secret: 'xxx',
|
|
ttl: 86400,
|
|
fallbackTtl: 300,
|
|
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
|
|
// 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: process.env.CARTO_WINDSHAFT_HEALTH_ENABLED === 'true' || 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: false,
|
|
// 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
|
|
layerStats: process.env.CARTO_WINDSHAFT_LAYERSTATS_ENABLED === 'true' || false,
|
|
// whether it should rate limit endpoints (global configuration)
|
|
rateLimitsEnabled: false,
|
|
// whether it should rate limit one or more endpoints (only if rateLimitsEnabled = true)
|
|
rateLimitsByEndpoint: {
|
|
anonymous: false,
|
|
static: false,
|
|
static_named: false,
|
|
dataview: false,
|
|
dataview_search: false,
|
|
analysis: false,
|
|
analysis_catalog: false,
|
|
tile: false,
|
|
attributes: false,
|
|
named_list: false,
|
|
named_create: false,
|
|
named_get: false,
|
|
named: false,
|
|
named_update: false,
|
|
named_delete: false,
|
|
named_tiles: false
|
|
}
|
|
},
|
|
pubSubMetrics: {
|
|
enabled: process.env.CARTO_WINDSHAFT_METRICS_ENABLED === 'true' || false,
|
|
project_id: process.env.CARTO_WINDSHAFT_METRICS_PROJECT_ID || 'avid-wavelet-844',
|
|
credentials: '',
|
|
topic: process.env.CARTO_WINDSHAFT_METRICS_PROJECT_ID || 'raw-metric-events'
|
|
}
|
|
};
|
|
|
|
// override some defaults for tests
|
|
if (process.env.NODE_ENV === 'test') {
|
|
config.user_from_host = '(.*)';
|
|
config.postgres_auth_pass = 'test_windshaft_cartodb_user_<%= user_id %>_pass';
|
|
config.millstone.cache_basedir = '/tmp/tile_assets';
|
|
config.postgres.user = 'test_windshaft_publicuser';
|
|
config.resources_url_templates = {
|
|
http: 'http://{{=it.user}}.localhost.lan:{{=it.port}}/api/v1/map',
|
|
https: 'https://{{=it.user}}.localhost.lan:{{=it.port}}/api/v1/map'
|
|
};
|
|
config.cache_enabled = false;
|
|
config.postgres_auth_user = 'test_windshaft_cartodb_user_<%= user_id %>';
|
|
config.renderer.mapnik.postgis.twkb_encoding = false;
|
|
config.renderer.mapnik['cache-features'] = false;
|
|
config.renderer.http.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'
|
|
];
|
|
config.analysis.batch.inlineExecution = true;
|
|
config.redis.idleTimeoutMillis = 1;
|
|
config.redis.reapIntervalMillis = 1;
|
|
config.varnish.purge_enabled = false;
|
|
config.health.enabled = false;
|
|
config.enabledFeatures.layerStats = true;
|
|
}
|
|
|
|
module.exports = config;
|