Skip to content
Permalink
v1.4.1
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time
674 lines (629 sloc) 25.4 KB
# All application specific configuration should reside here
app {
# The service description namespace
description {
# The name of the service
name = "delta"
}
# Service instance specific settings
instance {
# The default interface to bind to
interface = 127.0.0.1
}
# Default pagination information
pagination {
# Default page size
default-size = 20
# Maximum page size allowed
size-limit = 100
# Maximum `from` parameter value
from-limit = 10000
}
# Http binding settings
http {
# The interface to bind to
interface = ${app.instance.interface}
# The port to bind to
port = 8080
# The default uri prefix
prefix = "v1"
# The service public uri
public-uri = "http://"${app.http.interface}":"${app.http.port}
}
# Service runtime settings
runtime {
# The shutdown timeout
shutdown-timeout = 30 seconds
}
# caller settings for when the service wants perform service calls. Do not asign a value if you want the caller to be anonymous
# service-account-caller {
# realm = "myrealm"
# subject = "mysubject"
# groups = ["mygroup1", "mygroup2"]
# }
# Cluster specific settings
cluster {
# Duration after which actors are shutdown if they have no interaction
passivation-timeout = 2 seconds
# Timeout for requests to the distributed data
replication-timeout = 5 seconds
# Total number of shards in the cluster
shards = 30
# The seeds to use for joining a cluster. Should not contain the self address.
# Example: 127.0.0.1:2552,127.0.0.2:2552,127.0.0.3:2552
seeds = null
}
# Persistence specific settings
persistence {
journal-plugin = "akka.persistence.cassandra.journal"
snapshot-store-plugin = "akka.persistence.cassandra.snapshot"
query-journal-plugin = "akka.persistence.cassandra.query"
}
indexing {
# maximum number of events taken on each batch
batch = 10
# maximum amount of time to wait for the number of events to be taken on each batch
batch-timeout = 500ms
# indexing retry configuration
retry {
# possible values are: "never", "once", "constant" and "exponential"
strategy = "exponential"
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
# (applicable only for strategy "exponential")
initial-delay = 200 milliseconds
# the maximum delay applied to the retrying strategy
max-delay = 10 minutes
# the maximum number of times an index function is retried
max-retries = 10
# the constant increment (applicable only for strategy "constant")
constant = 500 milliseconds
}
# indexing progress persistence settings
progress {
# number of events after which the indexing progress is being persisted
persist-after-processed = 5000
# amount of time after which the indexing progress is being persisted
max-time-window = 2 minutes
}
}
key-value-store {
# the maximum duration to wait for the replicator to reply
ask-timeout = 10 seconds
# the maximum duration to wait for a consistent read or write across the cluster
consistency-timeout = 10 seconds
# retry strategy
retry {
# possible values are: "never", "once", "constant" and "exponential"
strategy = "exponential"
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 100 milliseconds
# the maximum delay applied to the retrying strategy
max-delay = 10 minutes
# maximum number of retries in case of failure (applicable only for strategy "exponential")
max-retries = 7
# the constant increment (applicable only for strategy "constant")
constant = 500 milliseconds
}
# key value store indexing configuration
indexing {
batch = ${app.indexing.batch}
batch-timeout = ${app.indexing.batch-timeout}
retry {
strategy = ${app.indexing.retry.strategy}
initial-delay = ${app.indexing.retry.initial-delay}
max-delay = ${app.indexing.retry.max-delay}
max-retries = ${app.indexing.retry.max-retries}
constant = ${app.indexing.retry.constant}
}
# indexing progress persistence settings
progress {
persist-after-processed = ${app.indexing.progress.persist-after-processed}
max-time-window = ${app.indexing.progress.max-time-window}
}
}
}
# aggregate configuration
aggregate {
# the maximum duration to wait for an aggregate to reply
ask-timeout = 10 seconds
# the journal plugin used to create event streams for arbitrary replays
query-journal-plugin = ${app.persistence.query-journal-plugin}
# the maximum duration before a command evaluation times out
command-evaluation-timeout = 5 seconds
# the execution context where commands are being evaluated; possible values are "akka" and "global"
command-evaluation-execution-context = "global"
# the total number of shards to allocate
shards = 10
# the aggregate actor passivation strategy
passivation {
# duration since the last received message after which the aggregate actors should shut down (0 - disabled)
lapsed-since-last-interaction = 5 seconds
# duration since the aggregate actors' recovery after which they should shut down (0 - disabled)
lapsed-since-recovery-completed = 0 milliseconds
}
retry {
# possible values are: "never", "once", "constant" and "exponential"
strategy = "exponential"
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
# (applicable only for strategy "exponential")
initial-delay = 100 milliseconds
# the maximum delay applied to the retrying strategy
max-delay = 10 minutes
# maximum number of retries in case of failure (applicable only for strategy "exponential")
max-retries = 7
# the constant increment (applicable only for strategy "constant")
constant = 500 milliseconds
}
}
# acls configuration
acls {
# acls aggregate configuration
aggregate {
ask-timeout = ${app.aggregate.ask-timeout}
query-journal-plugin = ${app.aggregate.query-journal-plugin}
command-evaluation-timeout = ${app.aggregate.command-evaluation-timeout}
# the execution context where commands are being evaluated; possible values are "akka" and "global"
command-evaluation-execution-context = "akka"
shards = ${app.aggregate.shards}
passivation {
lapsed-since-last-interaction = ${app.aggregate.passivation.lapsed-since-last-interaction}
lapsed-since-recovery-completed = ${app.aggregate.passivation.lapsed-since-recovery-completed}
}
retry {
strategy = ${app.aggregate.retry.strategy}
initial-delay = ${app.aggregate.retry.initial-delay}
max-delay = ${app.aggregate.retry.max-delay}
max-retries = ${app.aggregate.retry.max-retries}
constant = ${app.aggregate.retry.constant}
}
}
# acls indexing configuration
indexing {
batch = ${app.indexing.batch}
batch-timeout = ${app.indexing.batch-timeout}
retry {
strategy = ${app.indexing.retry.strategy}
initial-delay = ${app.indexing.retry.initial-delay}
max-delay = ${app.indexing.retry.max-delay}
max-retries = ${app.indexing.retry.max-retries}
constant = ${app.indexing.retry.constant}
}
progress {
persist-after-processed = ${app.indexing.progress.persist-after-processed}
max-time-window = ${app.indexing.progress.max-time-window}
}
}
}
# permissions configuration
permissions {
# minimum permission set (cannot be removed and are part of the initial state of permissions)
minimum = [
# default permissions for acls, with the exception that everyone should be able to see his own permissions
"acls/read",
"acls/write",
# default permissions for permissions
"permissions/read",
"permissions/write",
# default permissions for realms
"realms/read",
"realms/write",
# generic permissions for full read access to the global event log
"events/read",
# admin specific permissions
"projects/read",
"projects/write",
"projects/create",
"organizations/read",
"organizations/write",
"organizations/create",
# kg specific permissions
"resources/read",
"resources/write",
"resolvers/write",
"views/query",
"views/write",
"schemas/write",
"files/write",
"storages/write",
"archives/write"
]
# permissions aggregate configuration
aggregate {
ask-timeout = ${app.aggregate.ask-timeout}
query-journal-plugin = ${app.aggregate.query-journal-plugin}
command-evaluation-timeout = ${app.aggregate.command-evaluation-timeout}
# the execution context where commands are being evaluated; possible values are "akka" and "global"
command-evaluation-execution-context = "akka"
# the total number of shards to allocate; anything other than '1' doesn't make sense here
shards = 1
passivation {
lapsed-since-last-interaction = ${app.aggregate.passivation.lapsed-since-last-interaction}
lapsed-since-recovery-completed = ${app.aggregate.passivation.lapsed-since-recovery-completed}
}
retry {
strategy = ${app.aggregate.retry.strategy}
initial-delay = ${app.aggregate.retry.initial-delay}
max-delay = ${app.aggregate.retry.max-delay}
max-retries = ${app.aggregate.retry.max-retries}
constant = ${app.aggregate.retry.constant}
}
}
# permissions applied to the creator of the project
owner = [
#permissions
"acls/read",
"acls/write",
# admin specific permissions
"projects/read",
"projects/write",
"projects/create",
"organizations/read",
"organizations/write",
"organizations/create",
# kg specific permissions
"resources/read",
"resources/write",
"resolvers/write",
"views/query",
"views/write",
"schemas/write",
"files/write",
"storages/write",
"archives/write"
]
}
# realms configuration
realms {
# realms aggregate configuration
aggregate {
ask-timeout = ${app.aggregate.ask-timeout}
query-journal-plugin = ${app.aggregate.query-journal-plugin}
command-evaluation-timeout = ${app.aggregate.command-evaluation-timeout}
# the execution context where commands are being evaluated; possible values are "akka" and "global"
command-evaluation-execution-context = "akka"
shards = ${app.aggregate.shards}
passivation {
lapsed-since-last-interaction = ${app.aggregate.passivation.lapsed-since-last-interaction}
lapsed-since-recovery-completed = ${app.aggregate.passivation.lapsed-since-recovery-completed}
}
retry {
strategy = ${app.aggregate.retry.strategy}
initial-delay = ${app.aggregate.retry.initial-delay}
max-delay = ${app.aggregate.retry.max-delay}
max-retries = ${app.aggregate.retry.max-retries}
constant = ${app.aggregate.retry.constant}
}
}
# realms key value store configuration
key-value-store {
# the maximum duration to wait for the replicator to reply
ask-timeout = ${app.key-value-store.ask-timeout}
# the maximum duration to wait for a consistent read or write across the cluster
consistency-timeout = ${app.key-value-store.consistency-timeout}
# retry strategy
retry {
strategy = ${app.key-value-store.retry.strategy}
initial-delay = ${app.key-value-store.retry.initial-delay}
max-delay = ${app.aggregate.retry.max-delay}
max-retries = ${app.key-value-store.retry.max-retries}
constant = ${app.aggregate.retry.constant}
}
}
# realms indexing configuration
indexing {
batch = ${app.indexing.batch}
batch-timeout = ${app.indexing.batch-timeout}
retry {
strategy = ${app.indexing.retry.strategy}
initial-delay = ${app.indexing.retry.initial-delay}
max-delay = ${app.indexing.retry.max-delay}
max-retries = ${app.indexing.retry.max-retries}
constant = ${app.indexing.retry.constant}
}
# indexing progress persistence settings
progress {
persist-after-processed = ${app.indexing.progress.persist-after-processed}
max-time-window = ${app.indexing.progress.max-time-window}
}
}
}
# groups configuration
groups {
# the maximum accepted delay for waiting for a response from the group cache
ask-timeout = 15 seconds
command-evaluation-timeout = ${app.aggregate.command-evaluation-timeout}
# the execution context where commands are being evaluated; possible values are "akka" and "global"
command-evaluation-execution-context = "akka"
# the total number of shards to allocate; anything other than '1' doesn't make sense here
shards = 1
invalidation {
# duration since the last received message after which the aggregate actors should shut down (0 - disabled)
lapsed-since-last-interaction = 5 minutes
# flag to decide whether or not the invalidation timer is influenced by the reception of a get state message
influence-invalidation-on-get = true
}
# retry configuration for fetching the user info & cache
retry {
# possible values are: "never", "once" "constant" and "exponential"
strategy = "once"
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 0 seconds
# the maximum delay applied to the retrying strategy
max-delay = 5 seconds
# maximum number of retries in case of failure (applicable only for strategy "exponential")
max-retries = 7
# the constant increment (applicable only for strategy "constant")
constant = 500 milliseconds
}
}
# organizations configuration
organizations {
# organizations aggregate configuration
aggregate {
ask-timeout = ${app.aggregate.ask-timeout}
query-journal-plugin = ${app.aggregate.query-journal-plugin}
command-evaluation-timeout = ${app.aggregate.command-evaluation-timeout}
# the execution context where commands are being evaluated; possible values are "akka" and "global"
command-evaluation-execution-context = "akka"
shards = ${app.aggregate.shards}
passivation {
lapsed-since-last-interaction = ${app.aggregate.passivation.lapsed-since-last-interaction}
lapsed-since-recovery-completed = ${app.aggregate.passivation.lapsed-since-recovery-completed}
}
retry {
strategy = ${app.aggregate.retry.strategy}
initial-delay = ${app.aggregate.retry.initial-delay}
max-delay = ${app.aggregate.retry.max-delay}
max-retries = ${app.aggregate.retry.max-retries}
constant = ${app.aggregate.retry.constant}
}
}
retry {
strategy = ${app.aggregate.retry.strategy}
initial-delay = ${app.aggregate.retry.initial-delay}
max-delay = ${app.aggregate.retry.max-delay}
max-retries = ${app.aggregate.retry.max-retries}
constant = ${app.aggregate.retry.constant}
}
}
# projects configuration
projects {
# projects aggregate configuration
aggregate {
ask-timeout = ${app.aggregate.ask-timeout}
query-journal-plugin = ${app.aggregate.query-journal-plugin}
command-evaluation-timeout = ${app.aggregate.command-evaluation-timeout}
# the execution context where commands are being evaluated; possible values are "akka" and "global"
command-evaluation-execution-context = "akka"
shards = ${app.aggregate.shards}
passivation {
lapsed-since-last-interaction = ${app.aggregate.passivation.lapsed-since-last-interaction}
lapsed-since-recovery-completed = ${app.aggregate.passivation.lapsed-since-recovery-completed}
}
retry {
strategy = ${app.aggregate.retry.strategy}
initial-delay = ${app.aggregate.retry.initial-delay}
max-delay = ${app.aggregate.retry.max-delay}
max-retries = ${app.aggregate.retry.max-retries}
constant = ${app.aggregate.retry.constant}
}
}
retry {
strategy = ${app.aggregate.retry.strategy}
initial-delay = ${app.aggregate.retry.initial-delay}
max-delay = ${app.aggregate.retry.max-delay}
max-retries = ${app.aggregate.retry.max-retries}
constant = ${app.aggregate.retry.constant}
}
}
# instance storage configuration specific settings
storage {
ask-timeout = ${app.default-ask-timeout}
# Disk storage configuration
disk {
# the base path where the files are stored
volume = "/tmp"
# algorithm for checksum calculation
digest-algorithm = "SHA-256"
# the default permission required in order to download a file from a disk storage
read-permission = "resources/read"
# the default permission required in order to upload a file to a disk storage
write-permission = "files/write"
# flag to decide whether or not to show the absolute location of the files in the metadata response
show-location = false
# the default maximum allowed file size (in bytes) for uploaded files. 10 GB
max-file-size = 10737418240
}
# Remote disk storage configuration
remote-disk {
# the default endpoint
default-endpoint = "http://localhost:8084"
# the default endpoint prefix
default-endpoint-prefix = "v1"
# the default credentials for the endpoint
default-credentials = null
# the default digest algorithm
digest-algorithm = "SHA-256"
# the default permission required in order to download a file from a remote disk storage
read-permission = "resources/read"
# the default permission required in order to upload a file to a remote disk storage
write-permission = "files/write"
# flag to decide whether or not to show the absolute location of the files in the metadata response
show-location = true
# the default maximum allowed file size (in bytes) for uploaded files. 10 GB
max-file-size = 10737418240
}
# Amazon S3 storage configuration
amazon {
# the default digest algorithm
digest-algorithm = "SHA-256"
# the default permission required in order to download a file from an S3 storage
read-permission = "resources/read"
# the default permission required in order to upload a file to a S3 storage
write-permission = "files/write"
# flag to decide whether or not to show the absolute location of the files in the metadata response
show-location = true
# the default maximum allowed file size (in bytes) for uploaded files. 10 GB
max-file-size = 10737418240
}
# File attributes retry configuration
file-attr-retry {
# possible values are: "never", "once","constant" and "exponential"
strategy = "exponential"
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 300 milliseconds
# the maximum delay applied to the retrying strategy
max-delay = 10 seconds
# maximum number of retries in case of failure (applicable for strategy "exponential" and "constant")
max-retries = 1000
# the constant increment (applicable only for strategy "constant")
constant = 1 second
}
# the indexing process dealing with attributes computation
indexing {
batch = ${app.indexing.batch}
batch-timeout = ${app.indexing.batch-timeout}
retry {
strategy = ${app.indexing.retry.strategy}
initial-delay = ${app.indexing.retry.initial-delay}
max-delay = ${app.indexing.retry.max-delay}
max-retries = ${app.indexing.retry.max-retries}
constant = ${app.indexing.retry.constant}
}
progress {
persist-after-processed = ${app.indexing.progress.persist-after-processed}
max-time-window = ${app.indexing.progress.max-time-window}
}
}
# Password and salt used to encrypt credentials at rest
password = "changeme"
salt = "salt"
}
# sparql endpoint specific settings
sparql {
# The base uri to the sparql http endpoint
base = "http://localhost:9999/blazegraph"
# Index prefix (keyspace) for indexing
index-prefix = "delta"
# The optional basic auth credentials to access the endpoint
username = null
password = null
ask-timeout = ${app.default-ask-timeout}
# Sparql query retry configuration
query {
# possible values are: "never", "once","constant" and "exponential"
strategy = "exponential"
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 100 milliseconds
# the maximum delay applied to the retrying strategy
max-delay = 1 minutes
# maximum number of retries in case of failure (applicable for strategy "exponential" and "constant")
max-retries = 4
# the constant increment (applicable only for strategy "constant")
constant = 500 millisecond
}
# Sparql indexing configuration
indexing {
batch = ${app.indexing.batch}
batch-timeout = ${app.indexing.batch-timeout}
retry {
strategy = ${app.indexing.retry.strategy}
initial-delay = ${app.indexing.retry.initial-delay}
max-delay = ${app.indexing.retry.max-delay}
max-retries = ${app.indexing.retry.max-retries}
constant = ${app.indexing.retry.constant}
}
progress {
persist-after-processed = ${app.indexing.progress.persist-after-processed}
max-time-window = ${app.indexing.progress.max-time-window}
}
}
}
# elasticSearch endpoint specific settings
elastic-search {
# The base uri to the ElasticSearch http endpoint
base = "http://localhost:9200"
# Index prefix (namespace) for indexing
index-prefix = "delta"
ask-timeout = ${app.default-ask-timeout}
# ElasticSearch query retry configuration
query {
# possible values are: "never", "once","constant" and "exponential"
strategy = "exponential"
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 100 milliseconds
# the maximum delay applied to the retrying strategy
max-delay = 1 minutes
# maximum number of retries in case of failure (applicable for strategy "exponential" and "constant")
max-retries = 4
# the constant increment (applicable only for strategy "constant")
constant = 500 millisecond
}
# elastic Search indexing configuration
indexing {
batch = ${app.indexing.batch}
batch-timeout = ${app.indexing.batch-timeout}
retry {
strategy = ${app.indexing.retry.strategy}
initial-delay = ${app.indexing.retry.initial-delay}
max-delay = ${app.indexing.retry.max-delay}
max-retries = ${app.indexing.retry.max-retries}
constant = ${app.indexing.retry.constant}
}
progress {
persist-after-processed = ${app.indexing.progress.persist-after-processed}
max-time-window = ${app.indexing.progress.max-time-window}
}
}
}
# composite view configuration
composite {
# the maximum number of sources allowed
max-sources = 5
# the maximum number of projections allowed
max-projections = 5
# the minimum allowed value for interval rebuild
min-interval-rebuild = 5 minutes
# Password and salt used to encrypt token
password = "changeme"
salt = "salt"
}
# archive cache configuration
archives {
# the time resource is kept in the archive cache before being invalidated
cache-invalidate-after = 5 hours
# the maximum number of resources that can be contain in the archive
max-resources = 1000
cache {
# the maximum accepted delay for waiting for a response from the group cache
ask-timeout = ${app.default-ask-timeout}
# the maximum duration before a command evaluation times out
command-evaluation-timeout = ${app.aggregate.command-evaluation-timeout}
# the execution context where commands are being evaluated; possible values are "akka" and "global"
command-evaluation-execution-context = "akka"
shards = ${app.aggregate.shards}
invalidation {
# duration since the last received message after which the aggregate actors should shut down (0 - disabled)
lapsed-since-last-interaction = ${app.archives.cache-invalidate-after}
# flag to decide whether or not the invalidation timer is influenced by the reception of a get state message
influence-invalidation-on-get = false
}
# retry configuration for fetching the user info & cache
retry {
# possible values are: "never", "once" "constant" and "exponential"
strategy = "once"
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 0 seconds
# the maximum delay applied to the retrying strategy
max-delay = 5 seconds
# maximum number of retries in case of failure (applicable only for strategy "exponential")
max-retries = 7
# the constant increment (applicable only for strategy "constant")
constant = 500 milliseconds
}
}
}
default-ask-timeout = 5 seconds
migration: ${migration}
repair: ${repair}
}