Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
4 contributors

Users who have contributed to this file

@umbreak @hygt @bogdanromanx @wwajerowicz
437 lines (402 sloc) 17.1 KB
# All application specific configuration should reside here
app {
# The service description namespace
description {
# The name of the service
name = "kg"
}
# Service instance specific settings
instance {
# The default interface to bind to
interface = 127.0.0.1
interface = ${?BIND_INTERFACE}
}
# Http binding settings
http {
# The interface to bind to
interface = ${app.instance.interface}
# The port to bind to
port = 8080
port = ${?BIND_PORT}
# The default uri prefix
prefix = "v1"
prefix = ${?HTTP_PREFIX}
# The service public uri
public-uri = "http://"${app.http.interface}":"${app.http.port}
public-uri = ${?PUBLIC_URI}
}
# Service runtime settings
runtime {
# Arbitrary Future completion timeout
default-timeout = 30 seconds
}
# Cluster specific settings
cluster {
# Duration after which actors are shutdown if they have no interaction
passivation-timeout = 2 seconds
passivation-timeout = ${?PASSIVATION_TIMEOUT}
# Timeout for requests to the distributed data
replication-timeout = 5 seconds
replication-timeout = ${?REPLICATION_TIMEOUT}
# Total number of shards in the cluster
shards = 30
shards = ${?SHARDS}
# 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 = ${?SEED_NODES}
}
# Persistence specific settings
persistence {
journal-plugin = "cassandra-journal"
snapshot-store-plugin = "cassandra-snapshot-store"
query-journal-plugin = "cassandra-query-journal"
}
# Instance storage configuration specific settings
storage {
# Disk storage configuration
disk {
volume = "/tmp"
volume = ${?VOLUME_PATH}
digest-algorithm = "SHA-256"
digest-algorithm = ${?DIGEST_ALGORITHM}
read-permission = "resources/read"
read-permission = ${?DISK_READ_PERMISSION}
write-permission = "files/write"
write-permission = ${?DISK_WRITE_PERMISSION}
show-location = false
show-location = ${?DISK_SHOW_LOCATION}
# 10 GB (expressed in bytes)
max-file-size = 10737418240
max-file-size = ${?DISK_MAX_FILE_SIZE}
}
# Remote disk storage configuration
remote-disk {
default-endpoint = "http://localhost:8084/v1"
default-endpoint = ${?REMOTE_DISK_DEFAULT_ENDPOINT}
default-credentials = ${?REMOTE_DISK_DEFAULT_CREDENTIALS}
digest-algorithm = "SHA-256"
digest-algorithm = ${?DIGEST_ALGORITHM}
read-permission = "resources/read"
read-permission = ${?REMOTE_DISK_READ_PERMISSION}
write-permission = "files/write"
write-permission = ${?REMOTE_DISK_WRITE_PERMISSION}
show-location = true
show-location = ${?REMOTE_DISK_SHOW_LOCATION}
# 10 GB (expressed in bytes)
max-file-size = 10737418240
max-file-size = ${?REMOTE_DISK_MAX_FILE_SIZE}
}
# Amazon S3 storage configuration
amazon {
digest-algorithm = "SHA-256"
digest-algorithm = ${?DIGEST_ALGORITHM}
read-permission = "resources/read"
read-permission = ${?S3_READ_PERMISSION}
write-permission = "files/write"
write-permission = ${?S3_WRITE_PERMISSION}
show-location = true
show-location = ${?S3_SHOW_LOCATION}
# 10 GB (expressed in bytes)
max-file-size = 10737418240
max-file-size = ${?S3_MAX_FILE_SIZE}
}
# Digest retry configuration
# This setup will retry linearly starting at 1 second, capped to 10 seconds
# In the worse case, it will retry up to 2.7 hours
digest-retry {
# possible values are: "never", "once" and "exponential"
strategy = "linear"
strategy = ${?DIGEST_FETCH_RETRY_STRATEGY}
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 300 milliseconds
initial-delay = ${?DIGEST_FETCH_RETRY_INITIAL_DELAY}
# the maximum delay applied to the retrying strategy
max-delay = 10 seconds
max-delay = ${?DIGEST_FETCH_RETRY_MAX_DELAY}
# maximum number of retries in case of failure (applicable for strategy "exponential" and "linear")
max-retries = 10000
max-retries = ${?DIGEST_FETCH_RETRY_MAX_RETRIES}
# the exponential factor (applicable only for strategy "exponential")
factor = 0.2
factor = ${?DIGEST_FETCH_RETRY_RANDOM_FACTOR}
# the linear increment (applicable only for strategy "linear")
increment = 1 second
increment = ${?DIGEST_FETCH_RETRY_INCREMENT}
}
# Password and salt used to encrypt credentials at rest
password = "changeme"
password = ${?STORAGE_PASSWORD}
salt = "salt"
salt = ${?STORAGE_SALT}
}
# Nexus-admin settings
admin {
# The public iri to the admin service
public-iri = "http://localhost:8080/v1"
public-iri = ${?ADMIN_PUBLIC_IRI}
# The internal iri to the admin service
internal-iri = "http://localhost:8080/v1"
internal-iri = ${?ADMIN_INTERNAL_IRI}
}
iam {
# The public iri to the iam service
public-iri = "http://localhost:8080/v1"
public-iri = ${?IAM_PUBLIC_IRI}
# The internal iri to the iam service
internal-iri = "http://localhost:8080/v1"
internal-iri = ${?IAM_INTERNAL_IRI}
# The service account token to execute calls to IAM
service-account-token = ${?IAM_SA_TOKEN}
# The delay for retrying after completion on SSE
sse-retry-delay = 1 second
sse-retry-delay = ${?IAM_SSE_RETRY_DELAY}
}
# Sparql endpoint specific settings
sparql {
# The base uri to the sparql http endpoint
base = "http://localhost:9999/bigdata"
base = ${?SPARQL_BASE_URI}
# Index prefix (keyspace) for indexing
index-prefix = "kg"
index-prefix = ${?SPARQL_PREFIX_INDEX}
# The optional basic auth credentials to access the endpoint
username = ${?SPARQL_USERNAME}
password = ${?SPARQL_PASSWORD}
# Sparql default index
default-index = "kg"
# Sparql query retry configuration
query {
# possible values are: "never", "once" and "exponential"
strategy = "exponential"
strategy = ${?QUERYING_SPARQL_RETRY_STRATEGY}
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 100 milliseconds
initial-delay = ${?QUERYING_SPARQL_RETRY_INITIAL_DELAY}
# the maximum delay applied to the retrying strategy
max-delay = 1 minutes
max-delay = ${?QUERYING_SPARQL_RETRY_MAX_DELAY}
# maximum number of retries in case of failure (applicable for strategy "exponential" and "linear")
max-retries = 4
max-retries = ${?QUERYING_SPARQL_RETRY_MAX_RETRIES}
# the exponential factor (applicable only for strategy "exponential")
factor = 0.2
factor = ${?QUERYING_SPARQL_RETRY_RANDOM_FACTOR}
# the linear increment (applicable only for strategy "linear")
increment = 500 millisecond
increment = ${?QUERYING_SPARQL_RETRY_INCREMENT}
}
# Sparql indexing configuration
# This setup will retry exponentially starting at 500 millis, capped to 3 minutes
# In the worse case, it will retry up to almost 90 minutes
indexing {
# Maximum number of events taken on each batch
batch = 10
batch = ${?INDEXING_SPARQL_BATCH}
# Maximum amount of time to wait for the number of events to be taken on each batch
batch-timeout = 300 millis
batch-timeout = ${?INDEXING_SPARQL_BATCH_TIMEOUT}
retry {
# possible values are: "never", "once" and "exponential"
strategy = "exponential"
strategy = ${?INDEXING_SPARQL_RETRY_STRATEGY}
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 100 milliseconds
initial-delay = ${?INDEXING_SPARQL_RETRY_INITIAL_DELAY}
# the maximum delay applied to the retrying strategy
max-delay = 3 minutes
max-delay = ${?INDEXING_SPARQL_RETRY_MAX_DELAY}
# maximum number of retries in case of failure (applicable for strategy "exponential" and "linear")
max-retries = 30
max-retries = ${?INDEXING_SPARQL_RETRY_MAX_RETRIES}
# the exponential factor (applicable only for strategy "exponential")
factor = 0.2
factor = ${?INDEXING_SPARQL_RETRY_RANDOM_FACTOR}
# the linear increment (applicable only for strategy "linear")
increment = 500 millisecond
increment = ${?INDEXING_SPARQL_RETRY_INCREMENT}
}
}
}
# ElasticSearch endpoint specific settings
elastic-search {
# The base uri to the ElasticSearch http endpoint
base = "http://localhost:9200"
base = ${?ELASTIC_SEARCH_BASE_URI}
# Index prefix (namespace) for indexing
index-prefix = "kg"
index-prefix = ${?ELASTIC_SEARCH_PREFIX_INDEX}
# ElasticSearch default index
default-index = "kg_default"
# ElasticSearch query retry configuration
query {
# possible values are: "never", "once" and "exponential"
strategy = "exponential"
strategy = ${?QUERYING_ELASTIC_SEARCH_RETRY_STRATEGY}
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 100 milliseconds
initial-delay = ${?QUERYING_ELASTIC_SEARCH_RETRY_INITIAL_DELAY}
# the maximum delay applied to the retrying strategy
max-delay = 1 minutes
max-delay = ${?QUERYING_ELASTIC_SEARCH_RETRY_MAX_DELAY}
# maximum number of retries in case of failure (applicable for strategy "exponential" and "linear")
max-retries = 4
max-retries = ${?QUERYING_ELASTIC_SEARCH_RETRY_MAX_RETRIES}
# the exponential factor (applicable only for strategy "exponential")
factor = 0.2
factor = ${?QUERYING_ELASTIC_SEARCH_RETRY_RANDOM_FACTOR}
# the linear increment (applicable only for strategy "linear")
increment = 500 millisecond
increment = ${?QUERYING_ELASTIC_SEARCH_RETRY_INCREMENT}
}
# Elastic Search indexing configuration
# This setup will retry exponentially starting at 500 millis, capped to 3 minutes
# In the worse case, it will retry up to almost 90 minutes
indexing {
# Maximum number of events taken on each batch
batch = 30
batch = ${?INDEXING_ELASTICSEARCH_BATCH}
# Maximum amount of time to wait for the number of events to be taken on each batch
batch-timeout = 300 millis
batch-timeout = ${?INDEXING_ELASTICSEARCH_BATCH_TIMEOUT}
retry {
# possible values are: "never", "once" and "exponential"
strategy = "exponential"
strategy = ${?INDEXING_ELASTICSEARCH_RETRY_STRATEGY}
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 100 milliseconds
initial-delay = ${?INDEXING_ELASTICSEARCH_RETRY_INITIAL_DELAY}
# the maximum delay applied to the retrying strategy
max-delay = 3 minutes
max-delay = ${?INDEXING_ELASTICSEARCH_RETRY_MAX_DELAY}
# maximum number of retries in case of failure (applicable for strategy "exponential" and "linear")
max-retries = 30
max-retries = ${?INDEXING_ELASTICSEARCH_RETRY_MAX_RETRIES}
# the exponential factor (applicable only for strategy "exponential")
factor = 0.2
factor = ${?INDEXING_ELASTICSEARCH_RETRY_RANDOM_FACTOR}
# the linear increment (applicable only for strategy "linear")
increment = 500 millisecond
increment = ${?INDEXING_ELASTICSEARCH_RETRY_INCREMENT}
}
}
}
# Default pagination information
pagination {
# Default page size
default-size = 20
default-size = ${?PAGINATION_DEFAULT_SIZE}
# Maximum page size allowed
size-limit = 100
size-limit = ${?PAGINATION_MAX_SIZE}
# Maximum `from` parameter value
from-limit = 10000
from-limit = ${?PAGINATION_MAX_FROM}
}
# default sourcing configuration
sourcing {
# the maximum duration to wait for an aggregate to reply
ask-timeout = 10 seconds
ask-timeout = ${?SOURCING_ASK_TIMEOUT}
# the journal plugin used to create event streams for arbitrary replays
query-journal-plugin = ${app.persistence.query-journal-plugin}
query-journal-plugin = ${?SOURCING_QUERY_JOURNAL_PLUGIN}
# the maximum duration before a command evaluation times out
command-evaluation-timeout = 5 seconds
command-evaluation-timeout = ${?SOURCING_COMMAND_EVALUATION_TIMEOUT}
# the execution context where commands are being evaluated; possible values are "akka" and "global"
command-evaluation-execution-context = "global"
command-evaluation-execution-context = ${?SOURCING_COMMAND_EVALUATION_EXECUTION_CONTEXT}
# the total number of shards to allocate
shards = 10
shards = ${?SOURCING_SHARDS}
# 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
lapsed-since-last-interaction = ${?SOURCING_LAST_INTERACTION_PASSIVATION_TIMEOUT}
# duration since the aggregate actors' recovery after which they should shut down (0 - disabled)
lapsed-since-recovery-completed = 0 milliseconds
lapsed-since-recovery-completed = ${?SOURCING_RECOVERY_PASSIVATION_TIMEOUT}
}
retry {
# the retry strategy to use; possible values are: "never", "once" and "exponential"
strategy = "exponential"
strategy = ${?SOURCING_RETRY_STRATEGY}
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
# (applicable only for strategy "exponential")
initial-delay = 100 milliseconds
initial-delay = ${?SOURCING_RETRY_INITIAL_DELAY}
# the maximum delay applied to the retrying strategy
max-delay = 10 minutes
max-delay = ${?SOURCING_RETRY_MAX_DELAY}
# maximum number of retries in case of failure (applicable for strategy "exponential" and "linear")
max-retries = 7
max-retries = ${?SOURCING_RETRY_MAX_RETRIES}
# the exponential factor (applicable only for strategy "exponential")
factor = 0.2
factor = ${?SOURCING_RETRY_RANDOM_FACTOR}
# the linear increment (applicable only for strategy "linear")
increment = 500 millisecond
increment = ${?SOURCING_RETRY_INCREMENT}
}
}
# default key value store configuration
key-value-store {
# the maximum duration to wait for the replicator to reply
ask-timeout = 10 seconds
ask-timeout = ${?KEY_VALUE_STORE_ASK_TIMEOUT}
# the maximum duration to wait for a consistent read or write across the cluster
consistency-timeout = 10 seconds
consistency-timeout = ${?KEY_VALUE_STORE_CONSISTENCY_TIMEOUT}
# retry strategy
retry {
# possible values are: "never", "once" and "exponential"
strategy = "exponential"
strategy = ${?KEY_VALUE_STORE_RETRY_STRATEGY}
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 100 milliseconds
initial-delay = ${?KEY_VALUE_STORE_RETRY_INITIAL_DELAY}
# the maximum delay applied to the retrying strategy
max-delay = 10 minutes
max-delay = ${?KEY_VALUE_STORE_RETRY_MAX_DELAY}
# maximum number of retries in case of failure (applicable for strategy "exponential" and "linear")
max-retries = 7
max-retries = ${?KEY_VALUE_STORE_RETRY_MAX_RETRIES}
# the exponential factor (applicable only for strategy "exponential")
factor = 0.2
factor = ${?KEY_VALUE_STORE_RETRY_RANDOM_FACTOR}
# the linear increment (applicable only for strategy "linear")
increment = 500 millisecond
increment = ${?KEY_VALUE_STORE_RETRY_INCREMENT}
}
# Indexing keyvalue-store configuration
indexing {
# Maximum number of events taken on each batch
batch = 5
batch = ${?INDEXING_KEY_VALUE_STORE_BATCH}
# Maximum amount of time to wait for the number of events to be taken on each batch
batch-timeout = 300 millis
batch-timeout = ${?INDEXING_KEY_VALUE_STORE_BATCH_TIMEOUT}
retry {
# possible values are: "never", "once" and "exponential"
strategy = "exponential"
strategy = ${?INDEXING_KEY_VALUE_STORE_RETRY_STRATEGY}
# the initial delay before retrying that will be multiplied with the 'factor' for each attempt
initial-delay = 100 milliseconds
initial-delay = ${?INDEXING_KEY_VALUE_STORE_RETRY_INITIAL_DELAY}
# the maximum delay applied to the retrying strategy
max-delay = 3 minutes
max-delay = ${?INDEXING_KEY_VALUE_STORE_RETRY_MAX_DELAY}
# maximum number of retries in case of failure (applicable for strategy "exponential" and "linear")
max-retries = 10
max-retries = ${?INDEXING_KEY_VALUE_STORE_RETRY_MAX_RETRIES}
# the exponential factor (applicable only for strategy "exponential")
factor = 0.2
factor = ${?INDEXING_KEY_VALUE_STORE_RETRY_RANDOM_FACTOR}
# the linear increment (applicable only for strategy "linear")
increment = 500 millisecond
increment = ${?INDEXING_KEY_VALUE_STORE_RETRY_INCREMENT}
}
}
}
}
You can’t perform that action at this time.