Type Members

1.  trait AdminServerConfig extends ServerConfig

   A variant of ServerConfig that by default listens to connections only on the loopback interface.

2.  final case class ApiLoggingConfig(messagePayloads: Option[Boolean] = None, maxMethodLength: Int = ApiLoggingConfig.defaultMaxMethodLength, maxMessageLines: Int = ApiLoggingConfig.defaultMaxMessageLines, maxStringLength: Int = ApiLoggingConfig.defaultMaxStringLength, maxMetadataSize: Int = ApiLoggingConfig.defaultMaxMetadataSize) extends Product with Serializable

   Control logging of the ApiRequestLogger

   Control logging of the ApiRequestLogger

   Every GRPC service invocation is logged through the ApiRequestLogger. This allows to monitor all incoming traffic to a node (ledger API, sequencer API, admin API).

   messagePayloads

   Indicates whether to log message payloads. (To be disabled in production!) Also applies to metadata. None is equivalent to false.

   maxMethodLength

   indicates how much to abbreviate the name of the called method. E.g. "com.digitalasset.canton.MyMethod" may get abbreviated to "c.d.c.MyMethod". The last token will never get abbreviated.

   maxMessageLines

   maximum number of lines to log for a message

   maxStringLength

   maximum number of characters to log for a string within a message

   maxMetadataSize

   maximum size of metadata

3.  sealed trait ApiType extends PrettyPrinting
4.  sealed trait BaseTlsArguments extends AnyRef
5.  sealed trait BatchAggregatorConfig extends Product with Serializable

   Parameters for that batcher that batches queries (e.g., to a DB).

6.  final case class CacheConfig(maximumSize: PositiveNumeric[Long], expireAfterAccess: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofMinutes(10)) extends Product with Serializable

   Configurations settings for a single cache

   Configurations settings for a single cache

   maximumSize

   the maximum size of the cache

   expireAfterAccess

   how quickly after last access items should be expired from the cache

7.  final case class CachingConfigs(indexedStrings: CacheConfig = CachingConfigs.defaultStaticStringCache, contractStore: CacheConfig = CachingConfigs.defaultContractStoreCache, topologySnapshot: CacheConfig = CachingConfigs.defaultTopologySnapshotCache, partyCache: CacheConfig = CachingConfigs.defaultPartyCache, participantCache: CacheConfig = CachingConfigs.defaultParticipantCache, keyCache: CacheConfig = CachingConfigs.defaultKeyCache, packageVettingCache: CacheConfig = CachingConfigs.defaultPackageVettingCache, mySigningKeyCache: CacheConfig = CachingConfigs.defaultMySigningKeyCache) extends Product with Serializable

   Configuration settings for various internal caches

   Configuration settings for various internal caches

   indexedStrings

   cache size configuration for the static string index cache

   contractStore

   cache size configuration for the contract store

   topologySnapshot

   cache size configuration for topology snapshots

8.  case class CantonCommunityConfig(domains: Map[InstanceName, CommunityDomainConfig] = Map.empty, participants: Map[InstanceName, CommunityParticipantConfig] = Map.empty, remoteDomains: Map[InstanceName, RemoteDomainConfig] = Map.empty, remoteParticipants: Map[InstanceName, RemoteParticipantConfig] = Map.empty, monitoring: MonitoringConfig = MonitoringConfig(), parameters: CantonParameters = CantonParameters(), features: CantonFeatures = CantonFeatures()) extends CantonConfig with ConfigDefaults[DefaultPorts, CantonCommunityConfig] with Product with Serializable
9.  trait CantonConfig extends AnyRef

   Root configuration parameters for a single Canton process.

10.  final case class CantonEnterpriseConfig(sequencers: Map[InstanceName, SequencerNodeConfig] = Map.empty, domains: Map[InstanceName, EnterpriseDomainConfig] = Map.empty, domainManagers: Map[InstanceName, DomainManagerConfig] = Map.empty, mediators: Map[InstanceName, MediatorNodeConfig] = Map.empty, participants: Map[InstanceName, EnterpriseParticipantConfig] = Map.empty, remoteSequencers: Map[InstanceName, RemoteSequencerConfig] = Map.empty, remoteMediators: Map[InstanceName, RemoteMediatorConfig] = Map.empty, remoteDomains: Map[InstanceName, RemoteDomainConfig] = Map.empty, remoteDomainManagers: Map[InstanceName, RemoteDomainManagerConfig] = Map.empty, remoteParticipants: Map[InstanceName, RemoteParticipantConfig] = Map.empty, monitoring: MonitoringConfig = MonitoringConfig(), parameters: CantonParameters = CantonParameters(), features: CantonFeatures = CantonFeatures()) extends CantonConfig with ConfigDefaults[DefaultPorts, CantonEnterpriseConfig] with Product with Serializable
11.  case class CantonFeatures(enablePreviewCommands: Boolean = false, enableTestingCommands: Boolean = false, enableRepairCommands: Boolean = false) extends Product with Serializable

    Control which features are turned on / off in Canton

    Control which features are turned on / off in Canton

    enablePreviewCommands

    Feature flag to enable the set of commands that use functionality which we don't deem stable.

    enableTestingCommands

    Feature flag to enable the set of commands used by Canton developers for testing purposes.

    enableRepairCommands

    Feature flag to enable the set of commands used by Canton operators for manual repair purposes.

12.  final case class CantonParameters(clock: ClockConfig = ClockConfig.WallClock(), enableAdditionalConsistencyChecks: Boolean = false, manualStart: Boolean = false, nonStandardConfig: Boolean = false, devVersionSupport: Boolean = false, portsFile: Option[String] = None, timeouts: TimeoutSettings = TimeoutSettings(), retentionPeriodDefaults: RetentionPeriodDefaults = RetentionPeriodDefaults(), console: AmmoniteConsoleConfig = AmmoniteConsoleConfig()) extends Product with Serializable

    Parameters for testing Canton.

    Parameters for testing Canton. Use default values in a production environment.

    enableAdditionalConsistencyChecks

    if true, run additional consistency checks. This will degrade performance.

    manualStart

    If set to true, the nodes have to be manually started via console (default false)

    nonStandardConfig

    don't fail config validation on non-standard configuration settings

    devVersionSupport

    If true, allow domain nodes to use unstable protocol versions and participant nodes to connect to such domains

    portsFile

    A ports file name, where the ports of all participants will be written to after startup

    timeouts

    Sets the timeouts used for processing and console

13.  sealed trait CheckConfig extends AnyRef

    Configuration for a check

14.  case class ClientConfig(address: String = "127.0.0.1", port: Port, tls: Option[TlsClientConfig] = None, keepAliveClient: Option[KeepAliveClientConfig] = Some(KeepAliveClientConfig())) extends Product with Serializable

    A client configuration to a corresponding server configuration

15.  sealed trait ClockConfig extends Product with Serializable
16.  case class CommunityAdminServerConfig(address: String = defaultAddress, internalPort: Option[Port] = None, tls: Option[TlsServerConfig] = None, keepAliveServer: Option[KeepAliveServerConfig] = Some(KeepAliveServerConfig()), maxInboundMessageSize: NonNegativeInt = ServerConfig.defaultMaxInboundMessageSize) extends AdminServerConfig with CommunityServerConfig with Product with Serializable
17.  case class CommunityCryptoConfig(provider: CryptoProvider = CryptoProvider.Tink, signing: CryptoSchemeConfig[SigningKeyScheme] = CryptoSchemeConfig(), encryption: CryptoSchemeConfig[EncryptionKeyScheme] = CryptoSchemeConfig(), symmetric: CryptoSchemeConfig[SymmetricKeyScheme] = CryptoSchemeConfig(), hash: CryptoSchemeConfig[HashAlgorithm] = CryptoSchemeConfig()) extends CryptoConfig with Product with Serializable
18.  sealed trait CommunityDbConfig extends CommunityStorageConfig with DbConfig
19.  trait CommunityLocalNodeConfig extends LocalNodeConfig
20.  trait CommunityServerConfig extends ServerConfig
21.  sealed trait CommunityStorageConfig extends StorageConfig

    Determines how a node stores persistent data.

22.  sealed trait ConcurrencyLimitConfig extends AnyRef

    Use Netflix's https://github.com/Netflix/concurrency-limits to cap the number of concurrent requests.

23.  class ConfidentialConfigWriter extends AnyRef
24.  trait ConfigDefaults[Defaults, Self] extends AnyRef
25.  final case class ConsoleCommandTimeout(bounded: NonNegativeDuration = ConsoleCommandTimeout.defaultBoundedTimeout, unbounded: NonNegativeDuration = ConsoleCommandTimeout.defaultUnboundedTimeout, ledgerCommand: NonNegativeDuration = ConsoleCommandTimeout.defaultLedgerCommandsTimeout, ping: NonNegativeDuration = ConsoleCommandTimeout.defaultPingTimeout, testingBong: NonNegativeDuration = ConsoleCommandTimeout.defaultTestingBongTimeout) extends Product with Serializable

    Configuration for console command timeouts

    Configuration for console command timeouts

    bounded

    timeout on how long "bounded" operations, i.e. operations which normally are supposed to conclude in a fixed timeframe can run before the console considers them as failed.

    unbounded

    timeout on how long "unbounded" operations can run, potentially infinite.

    ledgerCommand

    default timeout used for ledger commands

    ping

    default ping timeout

    testingBong

    default bong timeout

26.  trait CryptoConfig extends AnyRef

    Cryptography configuration.

27.  sealed trait CryptoProvider extends PrettyPrinting
28.  case class CryptoProviderScheme[S](default: S, supported: NonEmpty[Set[S]]) extends Product with Serializable
29.  case class CryptoSchemeConfig[S](default: Option[S] = None, allowed: Option[NonEmpty[Set[S]]] = None) extends Product with Serializable

    Configures the optional default and allowed schemes of kind S.

    Configures the optional default and allowed schemes of kind S.

    default

    The optional scheme to use. If none is specified, use the provider's default scheme of kind S.

    allowed

    The optional allowed schemes to use. If none is specified, all the provider's supported schemes of kind S are allowed.

30.  final case class DbCacheConfig(maximumCacheSize: PositiveNumeric[Long] = DbCacheConfig.defaultMaximumCacheSize) extends Product with Serializable

    Parameters for the in-memory cache that can be used in front of a db-based data provider.

    Parameters for the in-memory cache that can be used in front of a db-based data provider.

    maximumCacheSize

    Maximum number of elements of the cache.

31.  trait DbConfig extends StorageConfig with PrettyPrinting

    Dictates that persistent data is stored in a database.

32.  case class DbParametersConfig(maxConnections: Option[Int] = None, failFastOnStartup: Boolean = true, migrationsPaths: Seq[String] = Seq.empty, ledgerApiJdbcUrl: Option[String] = None, connectionTimeout: time.NonNegativeFiniteDuration = DbConfig.defaultConnectionTimeout, warnOnSlowQuery: Option[PositiveFiniteDuration] = None, warnOnSlowQueryInterval: PositiveFiniteDuration = DbParametersConfig.defaultWarnOnSlowQueryInterval, unsafeCleanOnValidationError: Boolean = false, unsafeBaselineOnMigrate: Boolean = false) extends PrettyPrinting with Product with Serializable

    Various database related settings

    Various database related settings

    maxConnections

    Allows for setting the maximum number of db connections used by Canton and the ledger API server. If None or non-positive, the value will be auto-detected from the number of processors. Has no effect, if the number of connections is already set via slick options (i.e., config.numThreads).

    failFastOnStartup

    If true, the node will fail-fast when the database cannot be connected to If false, the node will wait indefinitely for the database to come up

    ledgerApiJdbcUrl

    Canton attempts to generate appropriate configuration for the daml ledger-api to persist the data it requires. In most circumstances this should be sufficient and there is no need to override this. However if this generation fails or an advanced configuration is required, the ledger-api jdbc url can be explicitly configured using this property. The jdbc url **must** specify the schema of ledger_api (using h2 parameter schema or postgres parameter currentSchema). This property is not used by a domain node as it does not run a ledger-api instance, and will be ignored if the node is configured with in-memory persistence.

    connectionTimeout

    How long to wait for acquiring a database connection

    warnOnSlowQuery

    Optional time when we start logging a query as slow.

    warnOnSlowQueryInterval

    How often to repeat the logging statement for slow queries.

    unsafeCleanOnValidationError

    TO BE USED ONLY FOR TESTING! Clean the database if validation during DB migration fails.

    unsafeBaselineOnMigrate

    TO BE USED ONLY FOR TESTING! Whether to automatically call baseline when migrate is executed against a non-empty schema with no schema history table. This schema will then be baselined with the baselineVersion before executing the migrations. Only migrations above baselineVersion will then be applied. This is useful for databases projects where the initial vendor schema is not empty If baseline should be called on migrate for non-empty schemas, { @code false} if not. (default: { @code false})

33.  final case class DeadlockDetectionConfig(enabled: Boolean = true, interval: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(3), warnInterval: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(10)) extends Product with Serializable

    Deadlock detection configuration

    Deadlock detection configuration

    A simple deadlock detection method. Using a background scheduler, we schedule a trivial future on the EC. If the Future is not executed until we check again, we alert.

    enabled

    if true, we'll monitor the EC for deadlocks (or slow processings)

    interval

    how often we check the EC

    warnInterval

    how often we report a deadlock as still being active

34.  class DefaultPorts extends AnyRef
35.  sealed trait EncryptedPrivateStoreConfig extends AnyRef

    Encapsulates possible configurations for different encrypted private stores

36.  case class EnterpriseAdminServerConfig(address: String = AdminServerConfig.defaultAddress, internalPort: Option[Port] = None, tls: Option[TlsServerConfig] = None, keepAliveServer: Option[KeepAliveServerConfig] = Some(KeepAliveServerConfig()), maxInboundMessageSize: NonNegativeInt = ServerConfig.defaultMaxInboundMessageSize, concurrencyLimit: Option[ConcurrencyLimitConfig] = None) extends AdminServerConfig with EnterpriseServerConfig with Product with Serializable
37.  case class EnterpriseCryptoConfig(provider: CryptoProvider = CryptoProvider.Tink, signing: CryptoSchemeConfig[SigningKeyScheme] = CryptoSchemeConfig(), encryption: CryptoSchemeConfig[EncryptionKeyScheme] = CryptoSchemeConfig(), symmetric: CryptoSchemeConfig[SymmetricKeyScheme] = CryptoSchemeConfig(), hash: CryptoSchemeConfig[HashAlgorithm] = CryptoSchemeConfig(), kms: Option[KmsConfig] = None, privateKeyStore: PrivateKeyStoreConfig = PrivateKeyStoreConfig()) extends CryptoConfig with Product with Serializable

    Defines an enterprise crypto configuration with two new configurations kms and privateKeyStore.

    Defines an enterprise crypto configuration with two new configurations kms and privateKeyStore.

    kms

    defines a KMS client configuration (e.g. Aws)

    privateKeyStore

    define the type of a private key store

38.  sealed trait EnterpriseDbConfig[A <: EnterpriseDbConfig[A]] extends EnterpriseStorageConfig with DbConfig
39.  trait EnterpriseLocalNodeConfig extends LocalNodeConfig
40.  trait EnterpriseServerConfig extends ServerConfig
41.  sealed trait EnterpriseStorageConfig extends StorageConfig
42.  case class FixedLimit(limit: Int) extends LimitConfig with Product with Serializable

    A constant concurrency limit.

43.  case class Gradient2Limit(maxConcurrency: Option[Int], smoothing: Option[Double], rttTolerance: Option[Double]) extends LimitConfig with Product with Serializable

    Gradient-based algorithm to estimate the ideal limit.

    Gradient-based algorithm to estimate the ideal limit.

    https://javadoc.io/static/com.netflix.concurrency-limits/concurrency-limits-core/0.3.6/com/netflix/concurrency/limits/limit/Gradient2Limit.html

44.  final case class GrpcHealthServerConfig(address: String = "0.0.0.0", internalPort: Option[Port] = None, keepAliveServer: Option[KeepAliveServerConfig] = Some(KeepAliveServerConfig()), parallelism: Int = 4) extends ServerConfig with Product with Serializable

    Configuration of the gRPC health server for a canton node.

    Configuration of the gRPC health server for a canton node.

    parallelism

    number of threads to be used in the gRPC server

45.  trait H2DbConfig extends DbConfig
46.  final case class HealthConfig(server: HealthServerConfig, check: CheckConfig) extends Product with Serializable

    Configuration to expose a health endpoint on the given server running the configured check

    Configuration to expose a health endpoint on the given server running the configured check

    server

    Server details for hosting the health endpoint

    check

    Check for determining whether this canton process is healthy

47.  final case class HealthServerConfig(address: String = "0.0.0.0", port: Port) extends Product with Serializable

    Configuration of health server backend.

48.  case class InitConfig(identity: Option[Identity] = None, nodeIdentifier: NodeIdentifierConfig = NodeIdentifierConfig.Config) extends InitConfigBase with Product with Serializable

    Configuration for the node's init process

    Configuration for the node's init process

    nodeIdentifier

    Controls the identifier that will be assigned to the node during auto-init

49.  trait InitConfigBase extends AnyRef
50.  case class KeepAliveClientConfig(time: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(40), timeout: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(20)) extends Product with Serializable

    GRPC keep alive client configuration

    GRPC keep alive client configuration

    Settings according to https://grpc.github.io/grpc-java/javadoc/io/grpc/ManagedChannelBuilder.html#keepAliveTime-long-java.util.concurrent.TimeUnit-

    time

    Sets the time without read activity before sending a keepalive ping. Do not set to small numbers (default is 40s)

    timeout

    Sets the time waiting for read activity after sending a keepalive ping (default is 20s)

51.  case class KeepAliveServerConfig(time: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(40), timeout: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(20), permitKeepAliveTime: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(20)) extends Product with Serializable

    GRPC keep alive server configuration

    GRPC keep alive server configuration

    time

    Sets the time without read activity before sending a keepalive ping. Do not set to small numbers (default is 40s) Corresponds to https://grpc.github.io/grpc-java/javadoc/io/grpc/netty/NettyServerBuilder.html#keepAliveTime-long-java.util.concurrent.TimeUnit-

    timeout

    Sets the time waiting for read activity after sending a keepalive ping (default is 20s) Corresponds to https://grpc.github.io/grpc-java/javadoc/io/grpc/netty/NettyServerBuilder.html#keepAliveTimeout-long-java.util.concurrent.TimeUnit-

    permitKeepAliveTime

    Sets the most aggressive keep-alive time that clients are permitted to configure (default is 20s) Corresponds to https://grpc.github.io/grpc-java/javadoc/io/grpc/netty/NettyServerBuilder.html#permitKeepAliveTime-long-java.util.concurrent.TimeUnit-

52.  case class KeyStoreConfig(path: File, password: Password) extends Product with Serializable

    Configuration for Java keystore with optional password protection.

53.  class KeyStoreConfigWriters extends AnyRef

    Annotations

    @nowarn()

54.  sealed trait KmsConfig extends AnyRef

    Encapsulates configurations for different KMS

55.  sealed trait LimitConfig extends ConcurrencyLimitConfig

    Corresponds to https://javadoc.io/doc/com.netflix.concurrency-limits/concurrency-limits-core/latest/com/netflix/concurrency/limits/Limit.html

56.  trait LocalNodeConfig extends NodeConfig
57.  final case class LoggingConfig(api: ApiLoggingConfig = ApiLoggingConfig(), eventDetails: Boolean = false) extends Product with Serializable

    Detailed logging configurations

    Detailed logging configurations

    This section allows to configure additional data such as transaction details to be logged to the standard logback system

    api

    Configuration settings for the ApiRequestLogger

    eventDetails

    If set to true, we will log substantial details of internal messages being processed. To be disabled in production!

58.  trait MemoryStorageConfig extends StorageConfig
59.  final case class MonitoringConfig(deadlockDetection: DeadlockDetectionConfig = DeadlockDetectionConfig(), health: Option[HealthConfig] = None, metrics: MetricsConfig = MetricsConfig(), delayLoggingThreshold: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(20), tracing: TracingConfig = TracingConfig(), logMessagePayloads: Option[Boolean] = None, logQueryCost: Option[QueryCostMonitoringConfig] = None, logSlowFutures: Boolean = false, logging: LoggingConfig = LoggingConfig()) extends LazyLogging with Product with Serializable

    Configuration for metrics and tracing

    Configuration for metrics and tracing

    deadlockDetection

    Should we regularly check our environment EC for deadlocks?

    health

    Optional Health check to expose an http server to monitor is the canton process is healthy

    metrics

    Optional Metrics Reporter used to expose internally captured metrics

    delayLoggingThreshold

    Logs a warning message once the sequencer client falls behind in processing messages from the sequencer (based on the sequencing timestamp).

    tracing

    Tracing configuration

    logMessagePayloads

    Determines whether message payloads (as well as metadata) sent through GRPC are logged.

    logQueryCost

    Determines whether to log the 15 most expensive db queries

    logSlowFutures

    Whether we should active log slow futures (where instructed)

60.  trait NodeConfig extends AnyRef
61.  final case class NodeMonitoringConfig(grpcHealthServer: Option[GrpcHealthServerConfig] = None) extends Product with Serializable

    Monitoring configuration for a canton node.

    Monitoring configuration for a canton node.

    grpcHealthServer

    Optional gRPC Health server configuration

62.  final case class NonNegativeDuration(duration: Duration) extends RefinedNonNegativeDuration[NonNegativeDuration] with Product with Serializable

    Duration class used for non-negative durations.

    Duration class used for non-negative durations.

    There are two options: either it's a non-negative duration or an infinite duration

63.  final case class NonNegativeFiniteDuration(underlying: FiniteDuration) extends RefinedNonNegativeDuration[NonNegativeFiniteDuration] with Product with Serializable

    Duration class used for non-negative finite durations.

64.  final case class Password(pw: String) extends AnyVal with Product with Serializable

    Password wrapper for keystores to prevent the values being printed in logs.

    Password wrapper for keystores to prevent the values being printed in logs.

    pw

    password value - public for supporting PureConfig parsing but callers should prefer accessing through unwrap

65.  final case class PositiveDurationSeconds(underlying: FiniteDuration) extends RefinedNonNegativeDuration[PositiveDurationSeconds] with Product with Serializable

    Duration class used for positive durations that are rounded to the second.

66.  trait PostgresDbConfig extends DbConfig
67.  case class PrivateKeyStoreConfig(encryption: Option[EncryptedPrivateStoreConfig] = None) extends Product with Serializable

    Stores the configuration for a private store

    Stores the configuration for a private store

    encryption

    flags that the store is encrypted with a specific encryption approach. The default value is None which means unencrypted.

68.  final case class ProcessingTimeout(unbounded: NonNegativeDuration = DefaultProcessingTimeouts.unbounded, io: NonNegativeDuration = DefaultProcessingTimeouts.io, default: NonNegativeDuration = DefaultProcessingTimeouts.default, network: NonNegativeDuration = DefaultProcessingTimeouts.network, shutdownProcessing: NonNegativeDuration = DefaultProcessingTimeouts.shutdownProcessing, shutdownNetwork: NonNegativeDuration = DefaultProcessingTimeouts.shutdownNetwork, shutdownShort: NonNegativeDuration = DefaultProcessingTimeouts.shutdownShort, closing: NonNegativeDuration = DefaultProcessingTimeouts.closing, inspection: NonNegativeDuration = DefaultProcessingTimeouts.inspection, storageMaxRetryInterval: NonNegativeDuration = DefaultProcessingTimeouts.maxRetryInterval, verifyActive: NonNegativeDuration = DefaultProcessingTimeouts.verifyActive, activeInit: NonNegativeDuration = DefaultProcessingTimeouts.activeInit, slowFutureWarn: NonNegativeDuration = DefaultProcessingTimeouts.slowFutureWarn, activeInitRetryDelay: NonNegativeDuration = DefaultProcessingTimeouts.activeInitRetryDelay) extends Product with Serializable

    Configuration for internal await timeouts

    Configuration for internal await timeouts

    unbounded

    timeout on how long "unbounded" operations can run. should be infinite in theory.

    io

    timeout for disk based operations

    default

    default finite processing timeout

    network

    timeout for things related to networking

    shutdownProcessing

    timeout used for shutdown of some processing where we'd like to keep the result (long)

    shutdownNetwork

    timeout used for shutdown where we interact with some remote system

    shutdownShort

    everything else shutdown releated (default)

    closing

    our closing time (which should be strictly larger than any of the shutdown values)

    inspection

    timeout for the storage inspection commands (can run a long long time)

    storageMaxRetryInterval

    max retry interval for storage

    verifyActive

    how long should we wait for the domain to tell us whether we are active or not

    activeInit

    how long a passive replica should wait for the initialization by the active replica

    slowFutureWarn

    when using future supervision, when should we start to warn about a slow future

    activeInitRetryDelay

    delay between attempts while waiting for initialization of the active replica

69.  trait ProtocolConfig extends AnyRef
70.  final case class QueryCostMonitoringConfig(every: time.NonNegativeFiniteDuration, resetOnOutput: Boolean = true) extends Product with Serializable

    Configuration for monitoring the cost of db queries.

    Configuration for monitoring the cost of db queries.

    every

    determines the duration between reports

    resetOnOutput

    determines whether the statistics will be reset after creating a report

71.  trait RefinedNonNegativeDuration[D <: RefinedNonNegativeDuration[D]] extends PrettyPrinting
72.  trait RefinedNonNegativeDurationCompanion[D <: RefinedNonNegativeDuration[D]] extends AnyRef
73.  case class ReplicationConfig(enabled: Option[Boolean] = None, connectionPool: DbLockedConnectionPoolConfig = DbLockedConnectionPoolConfig()) extends Product with Serializable

    Configuration of node replication for high availability

    Configuration of node replication for high availability

    enabled

    Needs to be set to true for a replicated node, which shares the database with other replicas.

    connectionPool

    Configuration for the write connection pool.

74.  final case class RetentionPeriodDefaults(sequencer: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofDays(7), mediator: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofDays(7), unauthenticatedMembers: time.NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofHours(1)) extends Product with Serializable

    Default retention periods used by pruning commands where no values are explicitly specified.

    Default retention periods used by pruning commands where no values are explicitly specified. Although by default the commands will retain enough data to remain operational, however operators may like to retain more than this to facilitate possible disaster recovery scenarios or retain evidence of completed transactions.

75.  sealed trait SequencerConnectionConfig extends AnyRef

    Definition provided by the domain node to members with details on how to connect to the domain sequencer.

    Definition provided by the domain node to members with details on how to connect to the domain sequencer. *

76.  sealed trait ServerAuthRequirementConfig extends AnyRef

    Configuration on whether server requires auth, requests auth, or no auth

77.  trait ServerConfig extends Product with Serializable

    Configuration for hosting a server api

78.  trait StorageConfig extends AnyRef
79.  case class TestSequencerClientFor(environmentId: String, memberName: String, domainName: String) extends Product with Serializable
    environmentId

    ID used to disambiguate tests running in parallel

    memberName

    The name of the member that should use a delayed sequencer client

    domainName

    The name of the domain for which the member should use a delayed sequencer client

80.  case class TestingConfigInternal(testSequencerClientFor: Set[TestSequencerClientFor] = Set.empty, useCausalityTracking: Boolean = false, metricsFactoryType: MetricsFactoryType = External, initializeGlobalOpenTelemetry: Boolean = true) extends Product with Serializable

    Used to set parameters for testing when these don't need to be exposed in a config file.

    Used to set parameters for testing when these don't need to be exposed in a config file.

    initializeGlobalOpenTelemetry

    Determines whether the OpenTelemetry instance we build is set as the global OpenTelemetry instance. This is set to false during tests to prevent failures as the global OpenTelemetry instance can be initialized just once.

81.  final case class TimeoutSettings(console: ConsoleCommandTimeout = ConsoleCommandTimeout(), processing: ProcessingTimeout = ProcessingTimeout()) extends Product with Serializable

    Timeout settings configuration

82.  case class TlsBaseServerConfig(certChainFile: ExistingFile, privateKeyFile: ExistingFile, minimumServerProtocolVersion: Option[String] = Some( TlsServerConfig.defaultMinimumServerProtocol ), ciphers: Option[Seq[String]] = TlsServerConfig.defaultCiphers) extends BaseTlsArguments with Product with Serializable

    A wrapper for TLS server parameters supporting only server side authentication

    A wrapper for TLS server parameters supporting only server side authentication

    Same parameters as the more complete TlsServerConfig

83.  case class TlsClientCertificate(certChainFile: File, privateKeyFile: File) extends Product with Serializable

84.  case class TlsClientConfig(trustCollectionFile: Option[ExistingFile], clientCert: Option[TlsClientCertificate]) extends Product with Serializable

    A wrapper for TLS related client configurations

    A wrapper for TLS related client configurations

    trustCollectionFile

    a file containing certificates of all nodes the client trusts. If none is specified, defaults to the JVM trust store

    clientCert

    the client certificate

85.  case class TlsServerConfig(certChainFile: ExistingFile, privateKeyFile: ExistingFile, trustCollectionFile: Option[ExistingFile] = None, secretsUrl: Option[String] = None, clientAuth: ServerAuthRequirementConfig = ServerAuthRequirementConfig.Optional, minimumServerProtocolVersion: Option[String] = Some( TlsServerConfig.defaultMinimumServerProtocol ), ciphers: Option[Seq[String]] = TlsServerConfig.defaultCiphers, enableCertRevocationChecking: Boolean = false) extends BaseTlsArguments with Product with Serializable

    A wrapper for TLS related server parameters supporting mutual authentication.

    A wrapper for TLS related server parameters supporting mutual authentication.

    Certificates and keys must be provided in the PEM format. It is recommended to create them with OpenSSL. Other formats (such as GPG) may also work, but have not been tested.

    certChainFile

    a file containing a certificate chain, containing the certificate chain from the server to the root CA. The certificate chain is used to authenticate the server. The order of certificates in the chain matters, i.e., it must start with the server certificate and end with the root certificate.

    privateKeyFile

    a file containing the server's private key. The key must not use a password.

    trustCollectionFile

    a file containing certificates of all nodes the server trusts. Used for client authentication. It depends on the enclosing configuration whether client authentication is mandatory, optional or unsupported. If client authentication is enabled and this parameter is absent, the certificates in the JVM trust store will be used instead.

    secretsUrl

    URL of a secrets service that provide parameters needed to decrypt the private key. Required when private key is encrypted (indicated by '.enc' filename suffix).

    clientAuth

    indicates whether server requires, requests, does does not request auth from clients. Normally the ledger api server requires client auth under TLS, but using this setting this requirement can be loosened. See https://github.com/digital-asset/daml/commit/edd73384c427d9afe63bae9d03baa2a26f7b7f54

    minimumServerProtocolVersion

    minimum supported TLS protocol. Set None (or null in config file) to default to JVM settings.

    ciphers

    supported ciphers. Set to None (or null in config file) to default to JVM settings.

    enableCertRevocationChecking

    whether to enable certificate revocation checking per https://tersesystems.com/blog/2014/03/22/fixing-certificate-revocation/ TODO(#4881): implement cert-revocation at the participant and domain admin endpoints Ledger api server reference PR: https://github.com/digital-asset/daml/pull/7965

86.  case class VegasLimit(maxConcurrency: Option[Int], smoothing: Option[Double]) extends LimitConfig with Product with Serializable

    Uses an algorithm inspired by TCP-Vegas to estimate ideal limit.

    Uses an algorithm inspired by TCP-Vegas to estimate ideal limit.

    https://javadoc.io/static/com.netflix.concurrency-limits/concurrency-limits-core/0.3.6/com/netflix/concurrency/limits/limit/VegasLimit.html

87.  case class WindowedLimit(windowSize: Option[Int] = None, delegate: LimitConfig) extends ConcurrencyLimitConfig with Product with Serializable

    Use a deligate concurrency limiter, supplying it data averaged over windows of at least windowSize

    Use a deligate concurrency limiter, supplying it data averaged over windows of at least windowSize

    Corresponds to https://javadoc.io/static/com.netflix.concurrency-limits/concurrency-limits-core/0.3.6/com/netflix/concurrency/limits/limit/WindowedLimit.html