Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
1027 lines (843 sloc) 28.7 KB
//
// Copyright 2018 SenX S.A.S.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
/////////////////////////////////////////////////////////////////////////////////////////
//
// S T A N D A L O N E
//
/////////////////////////////////////////////////////////////////////////////////////////
//
// Secret for REPORT, if unset, a random secret will be generated and output in the logs and on stdout
//
#warp10.report.secret =
//
// Manager secret, must be set to use the managing functions
//
#warp10.manager.secret =
//
// Maximum number of classes for which to report detailed stats in 'FINDSTATS'
//
directory.stats.class.maxcardinality = 100
//
// Maximum number of labels for which to report detailed stats in 'FINDSTATS'
//
directory.stats.labels.maxcardinality = 100
//
// Set to true to only run the Warp 10™ Analytics Engine
//
#analytics.engine.only = true
//
// Comma separated list of headers to return in Access-Control-Allow-Headers on top of the token header
// This applies to all HTTP endpoints.
//
#cors.headers =
//
// 128 bits key for verifying class names, format is hex:hhhhh...hhhh
//
warp.hash.class = @key:128:warp.hash.class@
//
// 128 bits key for verifying labels, format is hex:hhhhh...hhhh
//
warp.hash.labels = @key:128:warp.hash.labels@
//
// 128 bits key for verifying index names, format is hex:hhhhh...hhhh
//
warp.hash.index = @key:128:warp.hash.index@
//
// 128 bits key for verifying tokens, format is hex:hhhhh...hhhh
//
warp.hash.token = @key:128:warp.hash.token@
//
// 128 bits key for verifying app names, format is hex:hhhhh...hhhh
//
warp.hash.app = @key:128:warp.hash.app@
//
// 256 bits key for protecting tokens, format is hex:hhhh...hhhh
//
warp.aes.token = @key:256:warp.aes.token@
//
// 256 bits key to generate secure scripts
//
warp.aes.scripts = @key:256:warp.aes.scripts@
//
// AES key to wrap metasets
//
warp.aes.metasets = @key:256:warp.aes.metasets@
//
// 256 bits key for protecting log messages, format is hex:hhhhh...hhhh
//
#warp.aes.logging = @key:256:warp.aes.logging@
//
// OSS Master Key, used to decrypt any 'wrapped:base64' key
//
#oss.master.key = hex:hhhhhh...
//
// Maximum number of Geo Time Series a single Plasma session can subscribe to
//
#warp.plasma.maxsubs
//
// Set to true to disable plasma
//
#warp.plasma.disable =
//
// Set to true to disable mobius
//
#warp.mobius.disable =
//
// Set to true to disable streaming updates
//
#warp.streamupdate.disable =
//
// Set to a message indicating the reason why updates are disabled, they are enabled if this is not set
//
#warp.update.disabled = Updates are momentarily disabled
//
// Set to a message indicating the reason why deletes are disabled, they are enabled if this is not set
//
#warp.delete.disabled = Deletes are momentarily disabled
//
// Set to a message indicating the reason why meta updates are disabled, they are enabled if this is not set
//
#warp.meta.disabled = Meta updates are momentarily disabled
// Maximum time that TIMEBOX can wait for an execution (in ms), defaults to 30s
#warpscript.timebox.maxtime=30000
//
// Number of registers to allocate in the stack defaults to 256
//
#warpscript.registers = 256
//
// This configuration parameter determines if undefining a function (via NULL 'XXX' DEF)
// will unshadow the original statement thus making it available again or if it will replace
// it with a function that will fail with a message saying the function is undefined.
// The safest behavior is to leave this undefined or set to 'false'.
//
warpscript.def.unshadow = false
//
// Default maximum number of operations a single WarpScript execution can do
//
warpscript.maxops = 1000
warpscript.maxops.hard = 20000
//
// Maximum number of buckets which can result of a call to BUCKETIZE
// Can be modified by MAXBUCKETS up to the hard limit below
//
warpscript.maxbuckets = 1000000
warpscript.maxbuckets.hard = 1000000
//
// Maximum number of cells in geographic shapes
// Can be modified by MAXGEOCELLS up to the hard limit below
//
warpscript.maxgeocells = 10000
warpscript.maxgeocells.hard = 100000
//
// Maximum depth of the stack
// Can be modified by MAXDEPTH up to the hard limit below
//
warpscript.maxdepth = 1000
warpscript.maxdepth.hard = 2000
//
// Maximum number of datapoint which can be fetched during a WarpScript execution
// Can be modified by LIMIT up to the hard limit below
//
warpscript.maxfetch = 100000
warpscript.maxfetch.hard = 1000000
//
// Maximum number of GTS which can be retrieved from Directory during a WarpScript execution
// Can be modified by MAXGTS up to the hard limit below
//
warpscript.maxgts = 100000
warpscript.maxgts.hard = 100000
//
// Maximum time (in ms) that can be spent in a loop
// Can be modified by MAXLOOP up to the hard limit below
//
warpscript.maxloop = 5000
warpscript.maxloop.hard = 10000
// Path of the 'bootstrap' WarpScript code for the interactive mode
#warpscript.interactive.bootstrap.path =
// How often to reload the bootstrap code (in ms) for the interactive mode
#warpscript.interactive.bootstrap.period =
// Maximum number of parallel interactive sessions (defaults to 1).
#warpscript.interactive.capacity =
// Port on which the TCP endpoint of the interactive mode will listen. If undefined, no TCP endpoint will be available.
#warpscript.interactive.tcp.port =
// Set to 'true' to disable the interactive mode completely
#warp.interactive.disable = true
//
// Directory of Warp10 standalone install
//
standalone.home = /opt/warp10-@VERSION@
//
// Jar Repository - for Warp10 UDF only
//
warpscript.jars.directory = ${standalone.home}/jars
warpscript.jars.refresh = 60000
warpscript.jars.fromclasspath = true
//
// Macro Repository
//
// Secret to use for setting configuration accessible via MACROCONFIG
#warpscript.macroconfig.secret =
warpscript.repository.directory = ${standalone.home}/macros
warpscript.repository.refresh = 60000
// Set to false to disable on demand loading of macros not yet loaded.
#warpscript.repository.ondemand = false
// Default TTL for macros loaded on demand
#warpscript.repository.ttl = 600000
// TTL to use for failed macros, a new on-demand loading will occur after this delay.
// Defaults to the max of 10s or half of warpscript.repository.refresh
#warpscript.repository.ttl =
// Maximum TTL that can be set using MACROTTL (defaults to 2**62 ms)
#warpscript.repository.ttl.hard =
//
// WarpFleet
//
// Comma separated list of default WarpFleet™ repositories
warpfleet.macros.repos = https://warpfleet.senx.io/macros
// Read timeout when fetching macro source code from a repository, in ms. Defaults to 10s.
#warpfleet.timeout.read =
// Connection timeout when fetching macro source code from a repository, in ms. Defaults to 5s.
#warpfleet.timeout.connect =
// Configure this property to 'true' to disable the function WF.GETREPOS. This is useful when some of your repo URLs have sensitive information.
#warpfleet.getrepos.disable = true
// Maximum number of macros from WarpFleet™ to cache, defaults to 10000
#warpfleet.cache.size = 10000
// Default TTL (in ms) for macros loaded from a WarpFleet repository (defaults to 10 minutes)
#warpfleet.macros.ttl = 600000
// Lower limit for TTL (in ms) of macros loaded from a WarpFleet repository (defaults to 60 seconds)
#warpfleet.macros.ttl.min = 60000
// Upper limit for TTL (in ms) of macros loaded from a WarpFleet repository (defaults to 24 hours)
#warpfleet.macros.ttl.max =
// Default TTL (in ms) for WarpFleet macros which had errors (defaults to 10 seconds)
#warpfleet.macros.ttl.failed = 10000
// Default TTL (in ms) for WarpFleet macros which were not found. If > 0, a dummy macro
// will be generated which will fail with an informative error message
#warpfleet.macros.ttl.unknown = 0
// Name of WarpFleet repository macro. This macro consumes a URL and emits a boolean.
#warpfleet.macros.validator =
//
// Maximum levels of recursion in macro calls
//
warpscript.maxrecursion = 16
warpscript.maxrecursion.hard = 32
//
// Maximum number of symbols which can be defined by a single WarpScript
// Can be modified by MAXSYMBOLS up to the hard limit below
warpscript.maxsymbols = 64
warpscript.maxsymbols.hard = 256
//
// PGraphics Maximum number of pixels per image
//
warpscript.maxpixels = 1000000
warpscript.maxpixels.hard = 1000000
//
// WEBCALL limit per WarpScript
//
warpscript.maxwebcalls = 4
//
// WEBCALL user agent
//
webcall.user.agent = Warp10-WebCall
//
// List of patterns to include/exclude for hosts in WEBCALL calls
//
// Typical value is .*,!^127.0.0.1$,!^localhost$,!^192.168.*,!^10.*,!^172.(16|17|18|19|20|21|22|23|24|25|26|27|28|29|39|31)\..*
// Defaults to .*
//
webcall.host.patterns = !.*
//
// CALL root directory property
//
warpscript.call.directory = ${standalone.home}/calls
//
// Maximum number of subprogram instances which can be spawned by CALL
//
//warpscript.call.maxcapacity = 1
//
// Path of the 'bootstrap' WarpScript code
//
//warpscript.bootstrap.path = /opt/warp10/etc/hello.mc2
//
// How often to reload the bootstrap code (in ms)
//
//warpscript.bootstrap.period = 120000
//
// Comma separated list of WarpScriptExtension classes to instantiate to modify the defined WarpScript functions.
// Extension classes can be prefixed with SORTKEY# to force the order in which the extensions will be loaded.
// The SORTKEY# prefix will be used only for sorting.
//
#warpscript.extensions = packageW.classX,packageY.classZ
//
// Specific extension loading
// Extension classes can be prefixed with SORTKEY# to force the order in which the extensions will be loaded.
// The SORTKEY# prefix will be used only for sorting.
//
#warpscript.extension.xxx = package.class
// Integrated extensions:
// CEVAL, SYNC
#warpscript.extension.concurrent = io.warp10.script.ext.concurrent.ConcurrentWarpScriptExtension
// LOGMSG, NOLOG, STDERR, STDOUT, TDESCRIBE
#warpscript.extension.debug = io.warp10.script.ext.debug.DebugWarpScriptExtension
// HLOCATE
#warpscript.extension.hbase = io.warp10.script.ext.debug.HBaseWarpScriptExtension
// FUNCTIONS
#warpscript.extension.inventory = io.warp10.script.ext.inventory.InventoryWarpScriptExtension
// LOGEVENTTO
#warpscript.extension.logging = io.warp10.script.ext.logging.LoggingWarpScriptExtension
// REXEC
#warpscript.extension.rexec = io.warp10.script.ext.rexec.RexecWarpScriptExtension
// Comma separated list of included and excluded (! prefixed) host patterns
#warpscript.rexec.endpoint.patterns = .*
// SENSISIONEVENT, SENSISIONGET, SENSISIONSET, SENSISIONUPDATE
#warpscript.extension.sensision = io.warp10.script.ext.sensision.SensisionWarpScriptExtension
// MUTEX, SHMLOAD, SHMSTORE
#warpscript.extension.shm = io.warp10.script.ext.shm.SharedMemoryWarpScriptExtension
// TOKENDUMP, TOKENGEN, TOKENSECRET
#warpscript.extension.token = io.warp10.script.ext.token.TokenWarpScriptExtension
#token.secret = ....
// URLFETCH, MAXURLFETCHCOUNT, MAXURLFETCHSIZE
#warpscript.extension.urlfetch = io.warp10.script.ext.urlfetch.UrlFetchWarpScriptExtension
//
// Specific namespace under which to load an extension. The specified namespace will be used as a prefix for all functions of the extension.
//
//warpscript.namespace.package.class = namespace.
//
// Time units of the platform
// ns means we store nanoseconds
// us means we store microseconds
// ms means we store milliseconds
//
warp.timeunits = us
//
// Comma separated list of Warp 10 plugins to instantiate.
//
#warp10.plugins = packageW.classX,packageY.classZ
//
// Specific plugin loading
//
#warpscript.plugins.xxx = package.class
// Integrated plugins:
// Quantum MUST be loaded using this line to make sure its jar is automatically added to the classpath
warp10.plugin.quantum = io.warp10.plugins.quantum.QuantumPlugin
#warp10.plugin.http = io.warp10.plugins.http.HTTPWarp10Plugin
#warp10.plugin.udp = io.warp10.plugins.udp.UDPWarp10Plugin
#warp10.plugin.tcp = io.warp10.plugins.tcp.TCPWarp10Plugin
#warp10.plugin.influxdb = io.warp10.plugins.influxdb.InfluxDBWarp10Plugin
//
// Path of the 'bootstrap' warpscript code for Egress
//
warpscript.bootstrap.path = ${standalone.home}/etc/bootstrap/egress.mc2
//
// How often to reload the bootstrap code (in ms) for Egress
//
warpscript.bootstrap.period = 120000
//
// Path of the 'bootstrap' warpscript code for Mobius
//
warpscript.mobius.bootstrap.path = ${standalone.home}/etc/bootstrap/mobius.mc2
//
// Number of threads in the Mobius pool (those threads are used to execute the mobius macros)
//
warpscript.mobius.pool = 16
//
// How often to reload the bootstrap code (in ms) for Mobius
//
warpscript.mobius.bootstrap.period = 120000
//
// Path of the 'bootstrap' warpscript code for Runner
//
warpscript.runner.bootstrap.path = ${standalone.home}/etc/bootstrap/runner.mc2
//
// How often to reload the bootstrap code (in ms) for Runner
//
warpscript.runner.bootstrap.period = 120000
//
// URL for the 'update' endpoint
//
warpscript.update.endpoint = http://${standalone.host}:${standalone.port}/api/v0/update
//
// URL for the 'meta' endpoint
//
warpscript.meta.endpoint = http://${standalone.host}:${standalone.port}/api/v0/meta
//
// URL for the 'delete' endpoint
//
warpscript.delete.endpoint = http://${standalone.host}:${standalone.port}/api/v0/delete
//
// Directory where the leveldb files should be created
//
leveldb.home = ${standalone.home}/leveldb
//
// Flag to disable the native LevelDB implementation
// This flag is false by default if the configuration is missing
// When running WarpInit or WarpRepair, use a system property with the same name
//
leveldb.native.disable = false
//
// Flag to disable the use of the pure Java LevelDB implementation
// This flag is false by default if the configuration is missing
// When running WarpInit or WarpRepair, use a system property with the same name
//
leveldb.java.disable = false
//
// Rate of synchronous writes for the datapoints (update/deletes).
// This is a double between 0.0 (all writes asynchronous) and 1.0 (all writes synchronous).
// The default value is 1.0 (all writes are synchronous)
//
leveldb.data.syncrate = 1.0
//
// Rate of synchronous writes for the directory writes.
// This is a double between 0.0 (all writes asynchronous) and 1.0 (all writes synchronous)
// The default value is 1.0 (all writes are synchronous)
//
leveldb.directory.syncrate = 1.0
//
// AES key to use for wrapping metadata prior to storage in leveldb
//
#leveldb.metadata.aes =
//
// AES key to use for wrapping datapoints prior to storage in leveldb
//
#leveldb.data.aes =
//
// @deprecated
// AES key to use for storing index details in leveldb
//
#leveldb.index.aes =
//
// Cache size for leveldb (in bytes)
//
leveldb.cache.size = 100000000
//
// Compression type to use for leveldb (SNAPPY/NONE)
//
leveldb.compression.type = SNAPPY
//
// Maximum number of open files to use for LevelDB
//
//leveldb.maxopenfiles =
//
// IP to bind to for listening to incoming connections. Use 0.0.0.0 to listen to all interfaces
//
standalone.host = 127.0.0.1
//
// Port to bind to for listening to incoming connections.
//
standalone.port = 8080
//
// Number of Jetty acceptors
//
standalone.acceptors = 1
//
// Idle timeout (in ms)
//
standalone.idle.timeout = 30000
//
// Number of Jetty selectors
//
standalone.selectors = 4
//
// Maximum encoder size (in bytes) for internal data transfers. Use values from 64k to 512k
//
standalone.max.encoder.size = 100000
//
// Path to a file to use for triggering compaction suspension to take snapshots
//
standalone.snapshot.trigger = ${leveldb.home}/snapshot.trigger
//
// Path to a file to use for signaling that compactions are suspended
//
standalone.snapshot.signal = ${leveldb.home}/snapshot.signal
//
// Set to true to disable the delete endpoint.
//
standalone.delete.disable = false
//
// Set the size of delete batches in number of records (defaults to 100000)
//
#standalone.max.delete.batchsize =
//
// Configuration parameter to modify the datalog header. DO NOT MODIFY
//
#http.header.datalog =
//
// Max message size for the stream update websockets
//
ingress.websocket.maxmessagesize = 1048576
//
// Max message size for the Plasma Frontend Websocket
//
plasma.frontend.websocket.maxmessagesize = 1048576
//
// Period between updates of last activity timestamps for Geo Time Series
// The value of this parameter is in ms and determines how often the directory
// will be updated when activity is being tracked.
//
#ingress.activity.window = 3600000
//
// Set to true to consider updates when tracking activity of GTS
//
#ingress.activity.update = true
//
// Set to true to consider attributes updates (calls to /meta) when tracking activity of GTS
//
#ingress.activity.meta = true
//
// Set to 'true' to indicate the instance will use memory only for storage. This type of instance is non persistent.
//
in.memory = false
//
// Depth of timestamps to retain (in ms)
//
//in.memory.depth =
//
// High water mark in bytes. When memory goes above this threshold, attempts to remove expired datapoints will be
// done until consumed memory goes below the low water mark (see below) or no more expired datapoints can be found.
//
//in.memory.highwatermark =
//
// Low water mark in bytes for garbage collection (see above)
//
//in.memory.lowwatermark =
//
// If set to true, then only the last recorded value of a GTS is kept
//
//in.memory.ephemeral =
//
// Set to 'true' to use a chunked version of the in memory datastore
// When this datastore is in effect, the depth of data retained is
// configured using in.memory.chunk.count and in.memory.chunk.length
// All other in.memory.* parameters are ignored
//
//in.memory.chunked = true
//
// Number of chunks to retain (defaults to 3)
//
//in.memory.chunk.count =
//
// Length in platform time units of each chunk (defaults to 2**63)
//
//in.memory.chunk.length =
//
// Path to a dump file containing the state of an in-memory Warp 10 to restore.
//
#in.memory.load =
//
// Set to true to tolerate errors while loading a dumped state. Setting this to true can lead to partial data being loaded.
//
#in.memory.load.failsafe = true
//
// Path to a dump file in which the current state of an in-memory Warp 10 will be persisted.
//
#in.memory.dump =
//
// How often (in ms) to perform a gc of the in-memory store.
//
#in.memory.gcperiod =
//
// Maximum size (in bytes) of re-allocations performed during a gc cycle of the chunked in-memory store.
//
#in.memory.gc.maxalloc =
//
// Set to 'true' to only forward data to Plasma. Not data storage will take place.
//
//pureplasma =
//
// Number of threads to use for scheduling parallel scanners. Use 0 to disable parallel scanners
//
#standalone.parallelscanners.poolsize =
//
// Maximum number of parallel scanners per fetch request. Use 0 to disable parallel scanners.
//
#standalone.parallelscanners.maxinflightperrequest =
//
// Minimum number of GTS to assign to a parallel scanner. If the number of GTS to fetch is below this limit, no
// parallel scanners will be spawned. Defaults to 4.
//
#standalone.parallelscanners.min.gts.perscanner =
//
// Maximum number of parallel scanners to use when fetching datapoints for a batch of GTS (see EGRESS_FETCH_BATCHSIZE).
// Defaults to 16.
//
#standalone.parallelscanners.max.parallel.scanners =
//
// Set to true to enable splits generation to allow access to the standalone instance using Warp10InputFormat
//
#standalone.splits.enable = true
//
// Key to use for encrypting GTSSplit instances
//
#egress.fetcher.aes =
//
// Maximum age of a valid GTSSplit (in ms)
//
#egress.fetcher.maxsplitage =
//
// Should the egress exec handler expose its store/directory clients?
//
egress.clients.expose = false
//
// Q U A N T U M
//
/////////////////////////////////////////////////////////////////////////////////////////
//
// Quantum - Host/Port to bind to
//
quantum.port = 8090
quantum.host = ${standalone.host}
//
// D A T A L O G
//
/////////////////////////////////////////////////////////////////////////////////////////
//
// Datalogging directory. If set, every data modification action (UPDATE, META, DELETE) will produce
// a file in this directory with the timestamp, the token used and the action type. These files can then
// be used to update another instance of Warp 10
//
#datalog.dir = ${standalone.home}/datalog
//
// Set datalog.sync to true to force a call to fsync upon closing each datalog file, thus ensuring
// the file blocks are written to the underlying device. This defaults to false if the property is not set.
//
datalog.sync = true
//
// Unique id for this datalog instance.
//
#datalog.id = datalog-0
//
// Datalog pre-shared key to protect the DatalogRequest instances. If this AES key is not set, the requests will not be
// encrypted and could be altered.
//
#datalog.psk = hex:hhhhhhhh....
//
// Set this property to 'false' to skip logging forwarded requests or to 'true' if you want to log them to
// forward them to an additional hop.
//
#datalog.logforwarded = false
//
// Directory where datalog files to forward reside. If this property and 'datalog.forwarder.dstdir' are set, then
// the DatalogForwarder daemon will run.
//
#datalog.forwarder.srcdir = ${standalone.home}/datalog
//
// Directory where forwarded datalog files will be moved. MUST be on the same device as datalog.forwarder.srcdir
//
#datalog.forwarder.dstdir = ${standalone.home}/datalog_done
//
// Set to 'true' to delete the datalog files which were forwarded. If set to false or absent, such files will be moved
// to 'datalog.forwarder.dstdir'.
//
#datalog.forwarder.deleteforwarded = true
//
// Set to 'true' to delete the datalog files which were ignored. If set to false or absent, such files will be moved
// to 'datalog.forwarder.dstdir'.
//
#datalog.forwarder.deleteignored = true
//
// How often (in ms) to scan 'datalog.forwarder.srcdir' for datalog files to forward
//
#datalog.forwarder.period = 1000
//
// Comma separated list of datalog ids which should not be forwarded. This is used to avoid loops.
//
#datalog.forwarder.ignored =
//
// Set this property to 'true' to compress the forwarded requests
//
#datalog.forwarder.compress = true
//
// Set this property to 'true' to behave like a normal Warp 10 client. If not set to 'true' then
// the original datalog requests will be forwarded. Set to 'true' when forwarding to a distributed Warp 10.
//
#datalog.forwarder.actasclient = true
//
// Number of threads which will process the datalog requests. Requests for a identical (producer,app,owner) tuple
// will always be processed by the same thread to guarantee the sequence of actions.
//
#datalog.forwarder.nthreads = 4
//
// Endpoint to use when forwarding datalog UPDATE requests.
//
#datalog.forwarder.endpoint.update = http://host:port/api/v0/update
//
// Endpoint to use when forwarding datalog META requests.
//
#datalog.forwarder.endpoint.meta = http://host:port/api/v0/meta
//
// Endpoint to use when forwarding datalog DELETE requests.
//
#datalog.forwarder.endpoint.delete = http://host:port/api/v0/delete
//
// TRL (TOKEN REVOCATION LIST)
//
/////////////////////////////////////////////////////////////////////////////////////////
//
// root directory where trl files are stored.
//
# warp.trl.dir = ${standalone.home}/etc/trl
//
// Period (in ms) between two scans of the trl directory
//
# warp.trl.scan.period = 60000
//
// Delay (in ms) Startup delay authorized without a TRL present
// during this time tokens are decoded, even if TRL is missing.
// After this delay, if the TRL is still missing, token decoding is locked.
//
// 0 the TRL is mandatory for the token filter startup.
//
//
# warp.trl.startup.delay = 60000
//
// T H R O T T L I N G M A N A G E R
//
/////////////////////////////////////////////////////////////////////////////////////////
//
// Name of system property (configuration property) which contains the
// root directory where throttle files are stored.
//
throttling.manager.dir = ${standalone.home}/etc/throttle
//
// Period (in ms) between two scans of the THROTTLING_MANAGER_DIR
//
throttling.manager.period = 1000
//
// Ramp up period (in ms) during which we do not push the estimators to Sensision.
// This period (in ms) should be greater than the period at which the throttling files
// are updated, so we get a chance to have a merged estimator pushed to us even when
// we just restarted.
//
throttling.manager.rampup = 120000
//
// Default value for the rate when not configured through a file
//
throttling.manager.rate.default = 1000000.0
//
// Default value for the mads when not configured through a file
//
throttling.manager.mads.default = 100000
//
// R U N N E R
//
/////////////////////////////////////////////////////////////////////////////////////////
//
// Set to true to run each script a first time at startup, to false to schedule the
// first run at the next timestamp which is congruent to 0 modulo the period of the
// script
runner.runatstartup = true
//
// String uniquely identifying this instance of ScriptRunner
//
runner.id = runner-standalone-1
//
// Roles of the ScriptRunner instance. Can either be 'standalone' or any combination of 'scheduler' and 'worker'.
//
runner.roles = standalone
//
// warpscript endpoint to use for executing the scripts. If this is omitted then
// execution will take place in the scheduling thread.
//
//runner.endpoint = http://127.0.0.1:8881/api/v0/exec/warpscript
//
// AES key for wrapping a runner nonce which can later be extracted using RUNNERNONCE
//
//runner.psk = @key:256:runner.psk@
//
// Root directory under which scripts to run reside.
// This directory contains subdirectories, each one of them contains other
// subdirectories whose name is the periodicity (in ms) at which the scripts under it
// should be run. The scripts MUST end with the '.mc2' extension.
//
runner.root = ${standalone.home}/warpscripts
//
// Number of threads to use for running scripts.
//
runner.nthreads = 1
//
// How often (in ms) to scan RUNNER_ROOT for new scripts
//
runner.scanperiod = 60000
//
// Minimum period at which a script can be scheduled. Any script scheduled
// more often than that won't be run
//
runner.minperiod = 1000
//
// HTTP Plugin
//
// IP the HTTP plugin will listen on
#http.host = 127.0.0.1
// Port the HTTP plugin will listen on
#http.port = 10080
// Number of Jetty acceptors to use (defaults to 2)
#http.acceptors = 2
// Number of Jetty selectors to use (defaults to 4)
#http.selectors = 4
// Number of threads Jetty should use (defaults to 1 + acceptors + acceptors * selectors which is the minimum)
#http.maxthreads = 11
// Timeout (in ms) when expecting a HTTP request (defaults to 30000 ms)
#http.idle.timeout = 30000
// Directory where spec files are located
#http.dir =
// Period (in ms) at which to scan 'http.dir' (defaults to 60s)
#http.period = 60000
// Size of the queue to use for the Jetty thread pool. By default no queue is used
#http.queuesize = 8
//
// UDP Plugin
//
// Directory where UDP 'spec' files will be located
#udp.dir =
// Period (in ms) at which to rescan 'udp.dir' for spec files changes (defaults to 60s)
#udp.period = 60000
//
// TCP Plugin
//
// Directory where TCP 'spec' files will be located
#tcp.dir =
// Period (in ms) at which to rescan 'tcp.dir' for spec files changes (defaults to 60s)
#tcp.scanperiod = 60000
//
// InfluxDB Plugin
//
// Port the InfluxDB plugin will listen on
#influxdb.port = 18086
// IP the InfluxDB plugin will listen on (defaults to 127.0.0.1)
#influxdb.host = 127.0.0.1
// Timeout (in ms) when expecting a HTTP request (defaults to 30000 ms)
#influxdb.idle.timeout = 30000
// Number of threads Jetty should use (defaults to 1 + acceptors + acceptors * selectors which is the minimum)
#influxdb.jetty.threadpool = 11
// Size of the queue to use for the Jetty thread pool. By default no queue is used
#influxdb.jetty.maxqueuesize = 8
// Number of Jetty acceptors to use (defaults to 2)
#influxdb.acceptors = 2
// Number of Jetty selectors to use (defaults to 4)
#influxdb.selectors = 4
// Warp 10 instance update endpoint to push the data to
#influxdb.warp10.endpoint = http://ip:port/api/v0/update
// Default token to be used to update the data to the specified Warp 10 instance. By default uses the password in the request as token.
#influxdb.default.token =
//
// URLFETCH extension
//
// Maximum number of URLFETCH calls, 64 by default for soft and hard
#warpscript.urlfetch.limit =
#warpscript.urlfetch.limit.hard =
// Maximum downloaded bytes by URLFETCH, 1000000 by default for soft and hard
#warpscript.urlfetch.maxsize =
#warpscript.urlfetch.maxsize.hard =
// List of patterns to include/exclude for hosts, works the same way as webcall.host.patterns. Defaults to the value of webcall.host.patterns.
#warpscript.urlfetch.host.patterns =
You can’t perform that action at this time.