assessment-service_application.conf

# This is the main configuration file for the application.
# https://www.playframework.com/documentation/latest/ConfigFile
# ~~~~~
# Play uses HOCON as its configuration file format.  HOCON has a number
# of advantages over other config formats, but there are two things that
# can be used when modifying settings.
#
# You can include other configuration files in this main application.conf file:
#include "extra-config.conf"
#
# You can declare variables and substitute for them:
#mykey = ${some.value}
#
# And if an environment variable exists when there is no other substitution, then
# HOCON will fall back to substituting environment variable:
#mykey = ${JAVA_HOME}

## Akka
# https://www.playframework.com/documentation/latest/ScalaAkka#Configuration
# https://www.playframework.com/documentation/latest/JavaAkka#Configuration
# ~~~~~
# Play uses Akka internally and exposes Akka Streams and actors in Websockets and
# other streaming HTTP responses.
akka {
  # "akka.log-config-on-start" is extraordinarly useful because it log the complete
  # configuration at INFO level, including defaults and overrides, so it s worth
  # putting at the very top.
  #
  # Put the following in your conf/logback.xml file:
  #
  # <logger name="akka.actor" level="INFO" />
  #
  # And then uncomment this line to debug the configuration.
  #
  #log-config-on-start = true
  default-dispatcher {
    # This will be used if you have set "executor = "fork-join-executor""
    fork-join-executor {
      # Min number of threads to cap factor-based parallelism number to
      parallelism-min = 8

      # The parallelism factor is used to determine thread pool size using the
      # following formula: ceil(available processors * factor). Resulting size
      # is then bounded by the parallelism-min and parallelism-max values.
      parallelism-factor = 32.0

      # Max number of threads to cap factor-based parallelism number to
      parallelism-max = 64

      # Setting to "FIFO" to use queue like peeking mode which "poll" or "LIFO" to use stack
      # like peeking mode which "pop".
      task-peeking-mode = "FIFO"
    }
  }
  actors-dispatcher {
    type = "Dispatcher"
    executor = "fork-join-executor"
    fork-join-executor {
      parallelism-min = 8
      parallelism-factor = 32.0
      parallelism-max = 64
    }
    # Throughput for default Dispatcher, set to 1 for as fair as possible
    throughput = 1
  }
  actor {
    deployment {
      /healthActor
        {
          router = smallest-mailbox-pool
          nr-of-instances = 5
          dispatcher = actors-dispatcher
        }
      /itemSetActor
        {
          router = smallest-mailbox-pool
          nr-of-instances = 2
          dispatcher = actors-dispatcher
        }
      /questionActor
        {
          router = smallest-mailbox-pool
          nr-of-instances = 5
          dispatcher = actors-dispatcher
        }
      /questionSetActor
        {
          router = smallest-mailbox-pool
          nr-of-instances = 5
          dispatcher = actors-dispatcher
        }
    }
  }
}

## Secret key
# http://www.playframework.com/documentation/latest/ApplicationSecret
# ~~~~~
# The secret key is used to sign Play's session cookie.
# This must be changed for production, but we don't recommend you change it in this file.
play.http.secret.key="{{ graph_passport_key }}"

## Modules
# https://www.playframework.com/documentation/latest/Modules
# ~~~~~
# Control which modules are loaded when Play starts.  Note that modules are
# the replacement for "GlobalSettings", which are deprecated in 2.5.x.
# Please see https://www.playframework.com/documentation/latest/GlobalSettings
# for more information.
#
# You can also extend Play functionality by using one of the publically available
# Play modules: https://playframework.com/documentation/latest/ModuleDirectory
play.modules {
  # By default, Play will load any class called Module that is defined
  # in the root package (the "app" directory), or you can define them
  # explicitly below.
  # If there are any built-in modules that you want to enable, you can list them here.
  #enabled += my.application.Module

  # If there are any built-in modules that you want to disable, you can list them here.
  #disabled += ""
  enabled += modules.AssessmentModule
}

## IDE
# https://www.playframework.com/documentation/latest/IDE
# ~~~~~
# Depending on your IDE, you can add a hyperlink for errors that will jump you
# directly to the code location in the IDE in dev mode. The following line makes
# use of the IntelliJ IDEA REST interface:
#play.editor="http://localhost:63342/api/file/?file=%s&line=%s"

## Internationalisation
# https://www.playframework.com/documentation/latest/JavaI18N
# https://www.playframework.com/documentation/latest/ScalaI18N
# ~~~~~
# Play comes with its own i18n settings, which allow the user's preferred language
# to map through to internal messages, or allow the language to be stored in a cookie.
play.i18n {
  # The application languages
  langs = [ "en" ]

  # Whether the language cookie should be secure or not
  #langCookieSecure = true

  # Whether the HTTP only attribute of the cookie should be set to true
  #langCookieHttpOnly = true
}

## Play HTTP settings
# ~~~~~
play.http {
  ## Router
  # https://www.playframework.com/documentation/latest/JavaRouting
  # https://www.playframework.com/documentation/latest/ScalaRouting
  # ~~~~~
  # Define the Router object to use for this application.
  # This router will be looked up first when the application is starting up,
  # so make sure this is the entry point.
  # Furthermore, it's assumed your route file is named properly.
  # So for an application router like `my.application.Router`,
  # you may need to define a router file `conf/my.application.routes`.
  # Default to Routes in the root package (aka "apps" folder) (and conf/routes)
  #router = my.application.Router

  ## Action Creator
  # https://www.playframework.com/documentation/latest/JavaActionCreator
  # ~~~~~
  #actionCreator = null

  ## ErrorHandler
  # https://www.playframework.com/documentation/latest/JavaRouting
  # https://www.playframework.com/documentation/latest/ScalaRouting
  # ~~~~~
  # If null, will attempt to load a class called ErrorHandler in the root package,
  #errorHandler = null

  ## Session & Flash
  # https://www.playframework.com/documentation/latest/JavaSessionFlash
  # https://www.playframework.com/documentation/latest/ScalaSessionFlash
  # ~~~~~
  session {
    # Sets the cookie to be sent only over HTTPS.
    #secure = true

    # Sets the cookie to be accessed only by the server.
    #httpOnly = true

    # Sets the max-age field of the cookie to 5 minutes.
    # NOTE: this only sets when the browser will discard the cookie. Play will consider any
    # cookie value with a valid signature to be a valid session forever. To implement a server side session timeout,
    # you need to put a timestamp in the session and check it at regular intervals to possibly expire it.
    #maxAge = 300

    # Sets the domain on the session cookie.
    #domain = "example.com"
  }

  flash {
    # Sets the cookie to be sent only over HTTPS.
    #secure = true

    # Sets the cookie to be accessed only by the server.
    #httpOnly = true
  }
}

play.server.http.idleTimeout = 60s
play.http.parser.maxDiskBuffer = 10MB
parsers.anyContent.maxLength = 10MB

## Netty Provider
# https://www.playframework.com/documentation/latest/SettingsNetty
# ~~~~~
play.server.netty {
  # Whether the Netty wire should be logged
  log.wire = true

  # If you run Play on Linux, you can use Netty's native socket transport
  # for higher performance with less garbage.
  transport = "native"
}

## WS (HTTP Client)
# https://www.playframework.com/documentation/latest/ScalaWS#Configuring-WS
# ~~~~~
# The HTTP client primarily used for REST APIs.  The default client can be
# configured directly, but you can also create different client instances
# with customized settings. You must enable this by adding to build.sbt:
#
# libraryDependencies += ws // or javaWs if using java
#
play.ws {
  # Sets HTTP requests not to follow 302 requests
  #followRedirects = false

  # Sets the maximum number of open HTTP connections for the client.
  #ahc.maxConnectionsTotal = 50

  ## WS SSL
  # https://www.playframework.com/documentation/latest/WsSSL
  # ~~~~~
  ssl {
    # Configuring HTTPS with Play WS does not require programming.  You can
    # set up both trustManager and keyManager for mutual authentication, and
    # turn on JSSE debugging in development with a reload.
    #debug.handshake = true
    #trustManager = {
    #  stores = [
    #    { type = "JKS", path = "exampletrust.jks" }
    #  ]
    #}
  }
}

## Cache
# https://www.playframework.com/documentation/latest/JavaCache
# https://www.playframework.com/documentation/latest/ScalaCache
# ~~~~~
# Play comes with an integrated cache API that can reduce the operational
# overhead of repeated requests. You must enable this by adding to build.sbt:
#
# libraryDependencies += cache
#
play.cache {
  # If you want to bind several caches, you can bind the individually
  #bindCaches = ["db-cache", "user-cache", "session-cache"]
}

## Filter Configuration
# https://www.playframework.com/documentation/latest/Filters
# ~~~~~
# There are a number of built-in filters that can be enabled and configured
# to give Play greater security.
#
play.filters {

  # Enabled filters are run automatically against Play.
  # CSRFFilter, AllowedHostFilters, and SecurityHeadersFilters are enabled by default.
  enabled = [filters.AccessLogFilter]

  # Disabled filters remove elements from the enabled list.
  # disabled += filters.CSRFFilter


  ## CORS filter configuration
  # https://www.playframework.com/documentation/latest/CorsFilter
  # ~~~~~
  # CORS is a protocol that allows web applications to make requests from the browser
  # across different domains.
  # NOTE: You MUST apply the CORS configuration before the CSRF filter, as CSRF has
  # dependencies on CORS settings.
  cors {
    # Filter paths by a whitelist of path prefixes
    #pathPrefixes = ["/some/path", ...]

    # The allowed origins. If null, all origins are allowed.
    #allowedOrigins = ["http://www.example.com"]

    # The allowed HTTP methods. If null, all methods are allowed
    #allowedHttpMethods = ["GET", "POST"]
  }

  ## Security headers filter configuration
  # https://www.playframework.com/documentation/latest/SecurityHeaders
  # ~~~~~
  # Defines security headers that prevent XSS attacks.
  # If enabled, then all options are set to the below configuration by default:
  headers {
    # The X-Frame-Options header. If null, the header is not set.
    #frameOptions = "DENY"

    # The X-XSS-Protection header. If null, the header is not set.
    #xssProtection = "1; mode=block"

    # The X-Content-Type-Options header. If null, the header is not set.
    #contentTypeOptions = "nosniff"

    # The X-Permitted-Cross-Domain-Policies header. If null, the header is not set.
    #permittedCrossDomainPolicies = "master-only"

    # The Content-Security-Policy header. If null, the header is not set.
    #contentSecurityPolicy = "default-src 'self'"
  }

  ## Allowed hosts filter configuration
  # https://www.playframework.com/documentation/latest/AllowedHostsFilter
  # ~~~~~
  # Play provides a filter that lets you configure which hosts can access your application.
  # This is useful to prevent cache poisoning attacks.
  hosts {
    # Allow requests to example.com, its subdomains, and localhost:9000.
    #allowed = [".example.com", "localhost:9000"]
  }
}

play.http.parser.maxMemoryBuffer = 50MB
akka.http.parsing.max-content-length = 50MB
schema.base_path="{{ inquiry_schema_path | default('/home/sunbird/assessment-service-1.0-SNAPSHOT/schemas')}}"

# Cassandra Configuration
cassandra.lp.connection="{{ inquiry_cassandra_connection }}"

# Redis Configuration
redis.host="{{ inquiry_redis_host }}"
redis.port=6379
redis.maxConnections=128

# Configuration
graph.dir=/data/graphDB
akka.request_timeout=30
environment.id={{ environment_id }}
graph.ids=["domain"]
graph.passport.key.base="{{ graph_passport_key }}"
route.domain="{{ learning_neo4j_bolt_url }}"
route.bolt.write.domain="{{ learning_write_elb_url }}"
route.bolt.read.domain="{{ learning_read_elb_url }}"
route.all="{{ language_neo4j_bolt_url }}"
route.bolt.write.all="{{ language_write_elb_url }}"
route.bolt.read.all="{{ language_read_elb_url }}"

shard.id={{ mw_shard_id }}
platform.auth.check.enabled=false
platform.cache.ttl=3600000

#Top N Config for Search Telemetry
telemetry_env=dev

installation.id=ekstep


languageCode {
  assamese : "as"
  bengali : "bn"
  english : "en"
  gujarati : "gu"
  hindi : "hi"
  kannada : "ka"
  marathi : "mr"
  odia : "or"
  tamil : "ta"
  telugu : "te"
}

kafka {
  urls : "{{ inquiry_kafka_urls }}"
  topic.send.enable : true
  topics.instruction : "{{ inquiry_assessment_publish_kafka_topic_name }}"
}
objectcategorydefinition.keyspace="{{ inquiry_cassandra_keyspace_prefix }}_category_store"
question.keyspace="{{ inquiry_cassandra_keyspace_prefix }}_question_store"
questionset.keyspace="{{ inquiry_cassandra_keyspace_prefix }}_hierarchy_store"

composite {
  search {
    url : "{{ inquiry_search_service_base_url }}"
  }
}

import {
  request_size_limit : 300
  output_topic_name : "{{ inquiry_assessment_import_kafka_topic_name }}"
  required_props {
    question : ["name", "code", "mimeType", "framework", "channel"]
    questionset : ["name", "code", "mimeType", "framework", "channel"]
  }
}

master.category.validation.enabled="{{ master_category_validation_enabled }}"

question.cache.enable=true
questionset.cache.enable=true
assessment.copy.origin_data=["name", "author", "license", "organisation"]
assessment.copy.props_to_remove=["downloadUrl", "artifactUrl", "variants",
  "createdOn", "collections", "children", "lastUpdatedOn", "SYS_INTERNAL_LAST_UPDATED_ON",
  "versionKey", "s3Key", "status", "pkgVersion", "toc_url", "mimeTypesCount",
  "contentTypesCount", "leafNodesCount", "childNodes", "prevState", "lastPublishedOn",
  "flagReasons", "compatibilityLevel", "size", "publishChecklist", "publishComment",
  "LastPublishedBy", "rejectReasons", "rejectComment", "gradeLevel", "subject",
  "medium", "board", "topic", "purpose", "subtopic", "contentCredits",
  "owner", "collaborators", "creators", "contributors", "badgeAssertions", "dialcodes",
  "concepts", "keywords", "reservedDialcodes", "dialcodeRequired", "leafNodes", "sYS_INTERNAL_LAST_UPDATED_ON", "prevStatus", "lastPublishedBy", "streamingUrl"]

cloud_storage_container: "{{ cloud_storage_content_bucketname }}"

cloudstorage {
  metadata.replace_absolute_path={{ cloudstorage_replace_absolute_path | default('false') }}
  metadata.list={{ cloudstorage_metadata_list }}
  relative_path_prefix="{{ cloudstorage_relative_path_prefix | default('CLOUD_STORAGE_BASE_PATH') }}"
  read_base_path="{{ cloudstorage_base_path }}"
  write_base_path={{ valid_cloudstorage_base_urls }}
}