Сборка и развёртывание

#
# Copyright © 2021 ProStore
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

logging:
  level:
    ru.datamart.prostore.query.execution: ${DTM_LOGGING_LEVEL:TRACE}

server:
  port: ${DTM_METRICS_PORT:8080}

management:
  endpoints:
    enabled-by-default: ${DTM_METRICS_ENABLED:true}
    web:
      exposure:
        include: ${DTM_METRICS_SCOPE:info, health, requests}

core:
  plugins:
    active: ${CORE_PLUGINS_ACTIVE:ADP}

  http:
    port: ${DTM_CORE_HTTP_PORT:9090}
    tcpNoDelay: ${DTM_CORE_HTTP_TCP_NO_DELAY:true}
    tcpFastOpen: ${DTM_CORE_HTTP_TCP_FAST_OPEN:true}
    tcpQuickAck: ${DTM_CORE_HTTP_TCP_QUICK_ACK:true}

  env:
    name: ${DTM_NAME:test}

  restoration:
    autoRestoreState: ${AUTO_RESTORE_STATE:true}

  matviewsync:
    periodMs: ${MATERIALIZED_VIEWS_SYNC_PERIOD_MS:5000}
    retryCount: ${MATERIALIZED_VIEWS_RETRY_COUNT:10}
    maxConcurrent: ${MATERIALIZED_VIEWS_CONCURRENT:2}

  metrics:
    enabled: ${DTM_CORE_METRICS_ENABLED:true}

  datasource:
    edml:
      defaultChunkSize: ${EDML_DEFAULT_CHUNK_SIZE:1000}
      pluginStatusCheckPeriodMs: ${EDML_STATUS_CHECK_PERIOD_MS:1000}
      firstOffsetTimeoutMs: ${EDML_FIRST_OFFSET_TIMEOUT_MS:15000}
      changeOffsetTimeoutMs: ${EDML_CHANGE_OFFSET_TIMEOUT_MS:10000}
    zookeeper:
      connection-string: ${ZOOKEEPER_DS_ADDRESS:localhost}
      connection-timeout-ms: ${ZOOKEEPER_DS_CONNECTION_TIMEOUT_MS:30000}
      session-timeout-ms: ${ZOOKEEPER_DS_SESSION_TIMEOUT_MS:86400000}
      chroot: ${ZOOKEEPER_DS_CHROOT:/adtm}

  kafka:
    producer:
      property:
        key.serializer: org.apache.kafka.common.serialization.StringSerializer
        value.serializer: org.apache.kafka.common.serialization.StringSerializer
    cluster:
      zookeeper:
        connection-string: ${ZOOKEEPER_KAFKA_ADDRESS:localhost}
        connection-timeout-ms: ${ZOOKEEPER_KAFKA_CONNECTION_TIMEOUT_MS:30000}
        session-timeout-ms: ${ZOOKEEPER_KAFKA_SESSION_TIMEOUT_MS:86400000}
        chroot: ${ZOOKEEPER_KAFKA_CHROOT:}
    admin:
      inputStreamTimeoutMs: ${KAFKA_INPUT_STREAM_TIMEOUT_MS:2000}
    status.event.publish:
      enabled: ${KAFKA_STATUS_EVENT_ENABLED:false}
    statusMonitor:
      statusUrl: ${STATUS_MONITOR_URL:http://localhost:9095/status}
      versionUrl: ${STATUS_MONITOR_VERSION_URL:http://localhost:9095/versions}

  vertx:
    blocking-stacktrace-time: ${DTM_VERTX_BLOCKING_STACKTRACE_TIME:1}
    pool:
      worker-pool: ${DTM_CORE_WORKER_POOL_SIZE:20}
      event-loop-pool: ${DTM_CORE_EVENT_LOOP_POOL_SIZE:20}
      task-pool: ${DTM_CORE_TASK_POOL_SIZE:20}
      task-timeout: ${DTM_CORE_TASK_TIMEOUT:86400000}

  cache:
    initialCapacity: ${CACHE_INITIAL_CAPACITY:100000}
    maximumSize: ${CACHE_MAXIMUM_SIZE:100000}
    expireAfterAccessMinutes: ${CACHE_EXPIRE_AFTER_ACCESS_MINUTES:99960}

  delta:
    rollback-status-calls-ms: ${DELTA_ROLLBACK_STATUS_CALLS_MS:2000}

adp:
  datasource:
    user: ${ADP_USERNAME:dtm}
    password: ${ADP_PASS:dtm}
    host: ${ADP_HOST:localhost}
    port: ${ADP_PORT:5432}
    poolSize: ${ADP_MAX_POOL_SIZE:3}
    executorsCount: ${ADP_EXECUTORS_COUNT:3}
    fetchSize: ${ADP_FETCH_SIZE:1000}
    preparedStatementsCacheMaxSize: ${ADP_PREPARED_CACHE_MAX_SIZE:256}
    preparedStatementsCacheSqlLimit: ${ADP_PREPARED_CACHE_SQL_LIMIT:2048}
    preparedStatementsCache: ${ADP_PREPARED_CACHE:true}

  mppw:
    restStartLoadUrl: ${ADP_REST_START_LOAD_URL:http://localhost:8096/newdata/start}
    restStopLoadUrl: ${ADP_REST_STOP_LOAD_URL:http://localhost:8096/newdata/stop}
    restVersionUrl: ${ADP_MPPW_CONNECTOR_VERSION_URL:http://localhost:8096/versions}
    kafkaConsumerGroup: ${ADP_KAFKA_CONSUMER_GROUP:adp-load}

  mppr:
    restLoadUrl: ${ADP_MPPR_QUERY_URL:http://localhost:8094/query}
    restVersionUrl: ${ADP_MPPR_CONNECTOR_VERSION_URL:http://localhost:8094/versions}

logging:
  level:
    ru.datamart.kafka: ${LOG_LEVEL:DEBUG}
    org.apache.kafka: ${KAFKA_LOG_LEVEL:INFO}

http:
  port: ${SERVER_PORT:8096}

vertx:
  pools:
    eventLoopPoolSize: ${VERTX_EVENT_LOOP_SIZE:12}
    workersPoolSize: ${VERTX_WORKERS_POOL_SIZE:32}
  verticle:
    query:
      instances: ${QUERY_VERTICLE_INSTANCES:12}
    insert:
      poolSize: ${INSERT_WORKER_POOL_SIZE:32}
      insertPeriodMs: ${INSERT_PERIOD_MS:1000}
      batchSize: ${INSERT_BATCH_SIZE:500}
    consumer:
      poolSize: ${KAFKA_CONSUMER_WORKER_POOL_SIZE:32}
      maxFetchSize: ${KAFKA_CONSUMER_MAX_FETCH_SIZE:10000}
    commit:
      poolSize: ${KAFKA_COMMIT_WORKER_POOL_SIZE:1}
      commitPeriodMs: ${KAFKA_COMMIT_WORKER_COMMIT_PERIOD_MS:1000}

client:
  kafka:
    consumer:
      checkingTimeoutMs: ${KAFKA_CHECKING_TIMEOUT_MS:10000}
      responseTimeoutMs: ${KAFKA_RESPONSE_TIMEOUT_MS:10000}
      consumerSize: ${KAFKA_CONSUMER_SIZE:10}
      closeConsumersTimeout: ${KAFKA_CLOSE_CONSUMER_TIMEOUT:15000}
      property:
        bootstrap.servers: ${KAFKA_BOOTSTRAP_SERVERS:kafka.host:9092}
        group.id: ${KAFKA_CONSUMER_GROUP_ID:postgres-query-execution}
        auto.offset.reset: ${KAFKA_AUTO_OFFSET_RESET:earliest}
        enable.auto.commit: ${KAFKA_AUTO_COMMIT:false}
        auto.commit.interval.ms: ${KAFKA_AUTO_INTERVAL_MS:1000}

datasource:
  postgres:
    database: ${POSTGRES_DB_NAME:test}
    user: ${POSTGRES_USERNAME:dtm}
    password: ${POSTGRES_PASS:dtm}
    hosts: ${POSTGRES_HOSTS:localhost:5432}
    poolSize: ${POSTGRES_POOLSIZE:10}
    preparedStatementsCacheMaxSize: ${POSTGRES_CACHE_MAX_SIZE:256}
    preparedStatementsCacheSqlLimit: ${POSTGRES_CACHE_SQL_LIMIT:2048}
    preparedStatementsCache: ${POSTGRES_CACHE:true}

logging:
  level:
    ru.datamart.kafka: ${LOG_LEVEL:DEBUG}
    org.apache.kafka: ${KAFKA_LOG_LEVEL:INFO}

http:
  port: ${SERVER_PORT:8094}

vertx:
  pools:
    eventLoopPoolSize: ${VERTX_EVENT_LOOP_SIZE:12}
    workersPoolSize: ${VERTX_WORKERS_POOL_SIZE:32}
  verticle:
    query:
      instances: ${QUERY_VERTICLE_INSTANCES:12}

datasource:
  postgres:
    database: ${POSTGRES_DB_NAME:test}
    user: ${POSTGRES_USERNAME:dtm}
    password: ${POSTGRES_PASS:dtm}
    hosts: ${POSTGRES_HOSTS:localhost:5432}
    poolSize: ${POSTGRES_POOLSIZE:10}
    preparedStatementsCacheMaxSize: ${POSTGRES_CACHE_MAX_SIZE:256}
    preparedStatementsCacheSqlLimit: ${POSTGRES_CACHE_SQL_LIMIT:2048}
    preparedStatementsCache: ${POSTGRES_CACHE:true}
    fetchSize: ${POSTGRES_FETCH_SIZE:1000}

kafka:
  client:
    property:
      key.serializer: org.apache.kafka.common.serialization.ByteArraySerializer
      value.serializer: org.apache.kafka.common.serialization.ByteArraySerializer