app.conf

# All application specific configuration should reside here
app {
  # The service description namespace
  description {
    # The name of the service
    name = "kg"
  }

  default-ask-timeout = 5 seconds
  default-ask-timeout = ${?DEFAULT_ASK_TIMEOUT}

  # 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 {
    ask-timeout = ${app.default-ask-timeout}
    ask-timeout = ${?STORAGE_SEARCH_ASK_TIMEOUT}

    # 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"
      default-endpoint = ${?REMOTE_DISK_DEFAULT_ENDPOINT}
      default-endpoint-prefix = "v1"
      default-endpoint-prefix = ${?REMOTE_DISK_DEFAULT_ENDPOINT_PREFIX}
      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}
    }

    # File attributes retry configuration
    file-attr-retry {
      # possible values are: "never", "once","constant" and  "exponential"
      strategy = "exponential"
      strategy = ${?FILE_ATTR_FETCH_RETRY_STRATEGY}
      # the initial delay before retrying that will be multiplied with the 'factor' for each attempt
      initial-delay = 300 milliseconds
      initial-delay = ${?FILE_ATTR_FETCH_RETRY_INITIAL_DELAY}
      # the maximum delay applied to the retrying strategy
      max-delay = 10 seconds
      max-delay = ${?FILE_ATTR_FETCH_RETRY_MAX_DELAY}
      # maximum number of retries in case of failure (applicable for strategy "exponential" and "constant")
      max-retries = 1000
      max-retries = ${?FILE_ATTR_FETCH_RETRY_MAX_RETRIES}
      # the constant increment (applicable only for strategy "constant")
      constant = 1 second
      constant = ${?FILE_ATTR_FETCH_RETRY_CONSTANT}
    }

    # the indexing process dealing with attributes computation
    indexing {
      # Maximum number of events taken on each batch
      batch = 10
      batch = ${?INDEXING_FILE_ATTR_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_FILE_ATTR_BATCH_TIMEOUT}

      retry {
        # possible values are: "never", "once","constant" and  "exponential"
        strategy = "exponential"
        strategy = ${?INDEXING_FILE_ATTR_RETRY_STRATEGY}
        # the initial delay before retrying that will be multiplied with the 'factor' for each attempt
        initial-delay = 100 milliseconds
        initial-delay = ${?INDEXING_FILE_ATTR_RETRY_INITIAL_DELAY}
        # the maximum delay applied to the retrying strategy
        max-delay = 3 minutes
        max-delay = ${?INDEXING_FILE_ATTR_RETRY_MAX_DELAY}
        # maximum number of retries in case of failure (applicable for strategy "exponential" and "constant")
        max-retries = 30
        max-retries = ${?INDEXING_FILE_ATTR_RETRY_MAX_RETRIES}
        # the constant increment (applicable only for strategy "constant")
        constant = 500 millisecond
        constant = ${?INDEXING_FILE_ATTR_RETRY_CONSTANT}
      }

      # indexing progress persistence settings
      progress {
        # number of events after which the indexing progress is being persisted
        persist-after-processed = 5000
        persist-after-processed = ${?INDEXING_FILE_ATTR_PROGRESS_EVENTS}
        # amount of time after which the indexing progress is being persisted
        max-time-window = 2 minutes
        max-time-window = ${?INDEXING_FILE_ATTR_PROGRESS_TIME}
      }
    }

    # 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"
    public-iri = ${?ADMIN_PUBLIC_IRI}
    # The internal iri to the admin service
    internal-iri = "http://localhost:8080"
    internal-iri = ${?ADMIN_INTERNAL_IRI}
    # The version prefix
    prefix = "v1"
    prefix = ${?ADMIN_PREFIX}
  }

  iam {
    # The public iri to the iam service
    public-iri = "http://localhost:8080"
    public-iri = ${?IAM_PUBLIC_IRI}
    # The internal iri to the iam service
    internal-iri = "http://localhost:8080"
    internal-iri = ${?IAM_INTERNAL_IRI}

    # The version prefix
    prefix = "v1"
    prefix = ${?IAM_PREFIX}

    # 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"

    ask-timeout = ${app.default-ask-timeout}
    ask-timeout = ${?SPARQL_ASK_TIMEOUT}

    # Sparql query retry configuration
    query {
      # possible values are: "never", "once","constant" 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 "constant")
      max-retries = 4
      max-retries = ${?QUERYING_SPARQL_RETRY_MAX_RETRIES}
      # the constant increment (applicable only for strategy "constant")
      constant = 500 millisecond
      constant = ${?QUERYING_SPARQL_RETRY_CONSTANT}
    }

    # Sparql indexing configuration
    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","constant" 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 "constant")
        max-retries = 30
        max-retries = ${?INDEXING_SPARQL_RETRY_MAX_RETRIES}
        # the constant increment (applicable only for strategy "constant")
        constant = 500 millisecond
        constant = ${?INDEXING_SPARQL_RETRY_CONSTANT}
      }

      # indexing progress persistence settings
      progress {
        # number of events after which the indexing progress is being persisted
        persist-after-processed = 5000
        persist-after-processed = ${?INDEXING_SPARQL_PROGRESS_EVENTS}
        # amount of time after which the indexing progress is being persisted
        max-time-window = 2 minutes
        max-time-window = ${?INDEXING_SPARQL_PROGRESS_TIME}
      }
    }
  }

  # 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"

    ask-timeout = ${app.default-ask-timeout}
    ask-timeout = ${?ELASTIC_SEARCH_ASK_TIMEOUT}

    # ElasticSearch query retry configuration
    query {
      # possible values are: "never", "once","constant" 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 "constant")
      max-retries = 4
      max-retries = ${?QUERYING_ELASTIC_SEARCH_RETRY_MAX_RETRIES}
      # the constant increment (applicable only for strategy "constant")
      constant = 500 millisecond
      constant = ${?QUERYING_ELASTIC_SEARCH_RETRY_CONSTANT}
    }

    # Elastic Search indexing configuration
    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","constant" 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 "constant")
        max-retries = 30
        max-retries = ${?INDEXING_ELASTICSEARCH_RETRY_MAX_RETRIES}
        # the constant increment (applicable only for strategy "constant")
        constant = 500 millisecond
        constant = ${?INDEXING_ELASTICSEARCH_RETRY_CONSTANT}
      }
      # indexing progress persistence settings
      progress {
        # number of events after which the indexing progress is being persisted
        persist-after-processed = 5000
        persist-after-processed = ${?INDEXING_ELASTICSEARCH_PROGRESS_EVENTS}
        # amount of time after which the indexing progress is being persisted
        max-time-window = 2 minutes
        max-time-window = ${?INDEXING_ELASTICSEARCH_PROGRESS_TIME}
      }
    }
  }

  composite {
    # the maximum number of sources allowed
    max-sources = 5
    max-sources = ${?COMPOSITE_MAX_SOURCES}
    # the maximum number of projections allowed
    max-projections = 5
    max-projections = ${?COMPOSITE_MAX_PROJECTIONS}
    # the minimum allowed value for interval rebuild
    min-interval-rebuild = 5 minutes
    min-interval-rebuild = ${?COMPOSITE_MIN_REBUILD_INTERVAL}

    # Password and salt used to encrypt token
    password = "changeme"
    password = ${?COMPOSITE_TOKEN_PASSWORD}
    salt = "salt"
    salt = ${?OMPOSITE_TOKEN_SALT}
  }
  # 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 aggregate configuration
  aggregate {
    # the maximum duration to wait for an aggregate to reply
    ask-timeout = 10 seconds
    ask-timeout = ${?AGGREGATE_ASK_TIMEOUT}
    # the journal plugin used to create event streams for arbitrary replays
    query-journal-plugin = ${app.persistence.query-journal-plugin}
    query-journal-plugin = ${?AGGREGATE_QUERY_JOURNAL_PLUGIN}
    # the maximum duration before a command evaluation times out
    command-evaluation-timeout = 5 seconds
    command-evaluation-timeout = ${?AGGREGATE_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 = ${?AGGREGATE_COMMAND_EVALUATION_EXECUTION_CONTEXT}
    # the total number of shards to allocate
    shards = 10
    shards = ${?AGGREGATE_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 = ${?AGGREGATE_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 = ${?AGGREGATE_RECOVERY_PASSIVATION_TIMEOUT}
    }
    retry {
      # the retry strategy to use; possible values are: "never", "once","constant" and  "exponential"
      strategy = "exponential"
      strategy = ${?AGGREGATE_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 = ${?AGGREGATE_RETRY_INITIAL_DELAY}
      # the maximum delay applied to the retrying strategy
      max-delay = 10 minutes
      max-delay = ${?AGGREGATE_RETRY_MAX_DELAY}
      # maximum number of retries in case of failure (applicable for strategy "exponential" and "constant")
      max-retries = 10
      max-retries = ${?AGGREGATE_RETRY_MAX_RETRIES}
      # the constant increment (applicable only for strategy "constant")
      constant = 500 millisecond
      constant = ${?AGGREGATE_RETRY_CONSTANT}
    }
  }

  # 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","constant" 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 "constant")
      max-retries = 10
      max-retries = ${?KEY_VALUE_STORE_RETRY_MAX_RETRIES}
      # the constant increment (applicable only for strategy "constant")
      constant = 500 millisecond
      constant = ${?KEY_VALUE_STORE_RETRY_CONSTANT}
    }

    # 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","constant" 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 "constant")
        max-retries = 30
        max-retries = ${?INDEXING_KEY_VALUE_STORE_RETRY_MAX_RETRIES}
        # the constant increment (applicable only for strategy "constant")
        constant = 500 millisecond
        constant = ${?INDEXING_KEY_VALUE_STORE_RETRY_CONSTANT}
      }
      # indexing progress persistence settings
      progress {
        # number of events after which the indexing progress is being persisted
        persist-after-processed = 5000
        persist-after-processed = ${?INDEXING_KEY_VALUE_STORE_PROGRESS_EVENTS}
        # amount of time after which the indexing progress is being persisted
        max-time-window = 2 minutes
        max-time-window = ${?INDEXING_KEY_VALUE_STORE_PROGRESS_TIME}
      }
    }
  }

  # archive cache configuration
  archives {
    # the time resource is kept in the archive cache before being invalidated
    cache-invalidate-after = 5 hours
    cache-invalidate-after = ${?ARCHIVES_CACHE_INVALIDATE_AFTER}
    # the maximum number of resources that can be contain in the archive
    max-resources = 1000
    max-resources = ${?ARCHIVES_MAX_RESOURCES}
    cache {
      # the maximum accepted delay for waiting for a response from the group cache
      ask-timeout = 15 seconds
      ask-timeout = ${?ARCHIVES_CACHE_ASK_TIMEOUT}
      # the maximum duration before a command evaluation times out
      command-evaluation-timeout = 5 seconds
      command-evaluation-timeout = ${?ARCHIVES_CACHE_CACHE_COMMAND_EVALUATION_TIMEOUT}
      # the execution context where commands are being evaluated; possible values are "akka" and "global"
      command-evaluation-execution-context = "akka"
      command-evaluation-execution-context = ${?ARCHIVES_CACHE_CACHE_COMMAND_EVALUATION_EXECUTION_CONTEXT}
      shards = 10
      shards = ${?ARCHIVES_CACHE_CACHE_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"
        strategy = ${?ARCHIVES_CACHE_RETRY_STRATEGY}
        # the initial delay before retrying that will be multiplied with the 'factor' for each attempt
        initial-delay = 0 seconds
        initial-delay = ${?ARCHIVES_CACHE_RETRY_INITIAL_DELAY}
        # the maximum delay applied to the retrying strategy
        max-delay = 5 seconds
        max-delay = ${?ARCHIVES_CACHE_RETRY_MAX_DELAY}
        # maximum number of retries in case of failure (applicable only for strategy "exponential")
        max-retries = 7
        max-retries = ${?ARCHIVES_CACHE_RETRY_MAX_RETRIES}
        # the constant increment (applicable only for strategy "constant")
        constant = 500 milliseconds
        constant = ${?ARCHIVES_CACHE_RETRY_CONSTANT}
      }
    }
  }
}