application.conf

play {
  akka.actor-system = "orders-service"
  modules.enabled += ru.shadewallcorp.itdepart.sampleService.Module

  # See https://github.com/lagom/lagom-recipes/tree/master/mixed-persistence/mixed-persistence-java-sbt
  modules.disabled += com.lightbend.lagom.javadsl.persistence.jdbc.JdbcPersistenceModule
  # Hack for logging. The module of the service registers own implementations.
  modules.disabled += play.api.libs.ws.ahc.AhcWSModule

  http.filters = ru.shadewallcorp.itdepart.sampleService.Filters
}
# Logging outgoing HTTP requests
configured-ahc-ws-client {
  request-logging-enabled = false
}

# To avoid implicit changes of the state store mode in future Lagom versions
akka.cluster.sharding.state-store-mode = ddata

lagom.serialization.json {
  jackson-modules += "ru.shadewallcorp.itdepart.sampleService.JacksonCustomSetupModule"
}

# Cassandra
# write-side configuration.
orders-service.cassandra.keyspace = orders_service

# https://www.lagomframework.com/documentation/1.5.x/java/ProductionOverview.html#Using-static-Cassandra-contact-points
cassandra.default {
  ## list the contact points  here
  contact-points = [${?CASSANDRA_URL}]
  ## override Lagom’s ServiceLocator-based ConfigSessionProvider
  session-provider = akka.persistence.cassandra.ConfigSessionProvider
}

cassandra-journal {
  keyspace = ${orders-service.cassandra.keyspace}
  contact-points = ${cassandra.default.contact-points}
  session-provider = ${cassandra.default.session-provider}
}
cassandra-snapshot-store {
  keyspace = ${orders-service.cassandra.keyspace}
  contact-points = ${cassandra.default.contact-points}
  session-provider = ${cassandra.default.session-provider}
}

# Cassandra read-sides are unused in this example, but the offsetstore is still automatically created by default.
# It is possible to mix both Cassandra and JDBC/JPA read-side processors in the same service this way.
lagom.persistence.read-side.cassandra {
  keyspace = ${orders-service.cassandra.keyspace}
  contact-points = ${cassandra.default.contact-points}
  session-provider = ${cassandra.default.session-provider}
}

play.evolutions.db.default.autoApply = true
play.evolutions.db.default.useLocks = true

# JPA
# read-side configuration.
lagom.persistence.jdbc.create-tables.auto = false

db.default {
  driver = oracle.jdbc.driver.OracleDriver
  url = ${?DB_URL}
  jndiName = DefaultDS
  username = "ORDERS_SERVICE"
  password = "ToDo_Password"

  hikaricp {
    poolName: ${taymyr.lagom.metrics.prefix}".database"
    connectionTimeout = 1s
    connectionTestQuery = "SELECT 1 FROM DUAL"
  }
}

lagom.persistence.jpa {
  # This must match the name in persistence.xml
  persistence-unit = "defaultPersistenceUnit"
}

jdbc-defaults.slick.profile = "slick.jdbc.OracleProfile$"

# Finally, ensure that Cassandra is used for the journal and snapshot-store
# Lagom's Cassandra and JDBC persistence modules both define these properties,
# so the order they are applied is non-deterministic.
akka.persistence {
  journal {
    plugin = cassandra-journal
  }

  snapshot-store {
    plugin = cassandra-snapshot-store
  }
}
# Kafka

# Kafka
# Service name is empty by default
lagom.broker.kafka.service-name = ""
lagom.broker.kafka.brokers = ${?KAFKA_BROKERS}

# ES
akka {
  discovery {
    method = aggregate
    aggregate {
      discovery-methods = ["config", "akka-dns"]
    }
    config {
      services {
        elastic-search {
          endpoints = [
            {
              host = ${ELASTIC_SEARCH_HOST}
              port = ${ELASTIC_SEARCH_PORT}
            }
          ]
        }
        elastic-document {
          endpoints = [
            {
              host = ${ELASTIC_SEARCH_HOST}
              port = ${ELASTIC_SEARCH_PORT}
            }
          ]
        }
      }
    }
  }
}

# Split Brain Resolver
akka.cluster.downing-provider-class = "tanukki.akka.cluster.autodown.MajorityLeaderAutoDowning"

custom-downing {
  stable-after = 7s

  majority-leader-auto-downing {
    majority-member-role = ""
    down-if-in-minority = true
    shutdown-actor-system-on-resolution = true
  }
}

# The service-name needs to match the app label applied to your pods in the deployment spec.
akka.management {
  cluster.bootstrap {
    contact-point-discovery {
      discovery-method = kubernetes-api
      service-name = "sampleService"
      required-contact-point-nr = ${?REQUIRED_CONTACT_POINT_NR}
    }
  }
}

taymyr.lagom.metrics {
  prefix = "sampleService"
  enableJVM = true
  enableHikari = true
  enableCassandra = true
}

# Enable the serializer provided in Akka 2.5.8+ for akka.Done and other internal
# messages to avoid the use of Java serialization.
akka.actor.serialization-bindings {
  "akka.Done"                 = akka-misc
  "akka.actor.Address"        = akka-misc
  "akka.remote.UniqueAddress" = akka-misc
}
akka.actor.allow-java-serialization = off