object domains extends Helpful
- Annotations
- @Summary(s = "Manage domain connections", flag = console.this.Help.Summary.<init>$default$2) @Group(name = "Domains")
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- domains
- Helpful
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def accept_agreement(domainAlias: DomainAlias, agreementId: String): Unit
- Annotations
- @Summary(s = "Accept the service agreement of the given domain alias", flag = console.this.Help.Summary.<init>$default$2)
- def active(reference: DomainAdministration): Boolean
- Annotations
- @Summary(s = "Test whether a participant is connected to and permissioned on a domain reference, both from the perspective of the participant and the domain.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = "Yields false, if the domain has not been initialized, is not connected or is not healthy.")
- def active(domainAlias: DomainAlias): Boolean
- Annotations
- @Summary(s = "Test whether a participant is connected to and permissioned on a domain.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Yields false, if the domain is not connected or not healthy.
|Yields false, if the domain is configured in the Canton configuration and
|the participant is not active from the perspective of the domain.""")
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @IntrinsicCandidate()
- def config(domain: DomainAlias): Option[DomainConnectionConfig]
- Annotations
- @Summary(s = "Returns the current configuration of a given domain", flag = console.this.Help.Summary.<init>$default$2)
- def connect(domainAlias: DomainAlias, connection: String, manualConnect: Boolean = false, domainId: Option[DomainId] = None, certificatesPath: String = "", priority: Int = 0, timeTrackerConfig: DomainTimeTrackerConfig = DomainTimeTrackerConfig(), synchronize: Option[NonNegativeDuration] = Some(
consoleEnvironment.commandTimeouts.bounded
)): DomainConnectionConfig
- Annotations
- @Summary(s = "Macro to connect a participant to a domain given by connection", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """The connect macro performs a series of commands in order to connect this participant to a domain.
|First, `register` will be invoked with the given arguments, but first registered
|with manualConnect = true. If you already set manualConnect = true, then nothing else
|will happen and you will have to do the remaining steps yourselves.
|Otherwise, if the domain requires an agreement, it is fetched and presented to the user for evaluation.
|If the user is fine with it, the agreement is confirmed. If you want to auto-confirm,
|then set the environment variable CANTON_AUTO_APPROVE_AGREEMENTS=yes.
|Finally, the command will invoke `reconnect` to startup the connection.
|If the reconnect succeeded, the registered configuration will be updated
|with manualStart = true. If anything fails, the domain will remain registered with `manualConnect = true` and
|you will have to perform these steps manually.
The arguments are:
domainAlias - The name you will be using to refer to this domain. Can not be changed anymore.
connection - The connection string to connect to this domain. I.e. https://url:port
manualConnect - Whether this connection should be handled manually and also excluded from automatic re-connect.
domainId - Optionally the domainId you expect to see on this domain.
certificatesPath - Path to TLS certificate files to use as a trust anchor.
priority - The priority of the domain. The higher the more likely a domain will be used.
timeTrackerConfig - The configuration for the domain time tracker.
synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
""")
- def connect(config: DomainConnectionConfig): Unit
- Annotations
- @Summary(s = "Macro to connect a participant to a domain given by connection", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This variant of connect expects a domain connection config.
|Otherwise the behaviour is equivalent to the connect command with explicit
|arguments. If the domain is already configured, the domain connection
|will be attempted. If however the domain is offline, the command will fail.
|Generally, this macro should only be used to setup a new domain. However, for
|convenience, we support idempotent invocations where subsequent calls just ensure
|that the participant reconnects to the domain.
|""")
- def connect_ha(domainAlias: DomainAlias, firstConnection: SequencerConnection, additionalConnections: SequencerConnection*): DomainConnectionConfig
- Annotations
- @Summary(s = "Deprecated macro to connect a participant to a domain that supports connecting via many endpoints", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Use the command connect_ha with the updated arguments list""") @Deprecated
- def connect_local(domain: InstanceReferenceWithSequencerConnection, manualConnect: Boolean = false, alias: Option[DomainAlias] = None, maxRetryDelayMillis: Option[Long] = None, priority: Int = 0, synchronize: Option[NonNegativeDuration] = Some(
consoleEnvironment.commandTimeouts.bounded
)): Unit
- Annotations
- @Summary(s = "Macro to connect a participant to a locally configured domain given by reference", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """
The arguments are:
domain - A local domain or sequencer reference
manualConnect - Whether this connection should be handled manually and also excluded from automatic re-connect.
alias - The name you will be using to refer to this domain. Can not be changed anymore.
certificatesPath - Path to TLS certificate files to use as a trust anchor.
priority - The priority of the domain. The higher the more likely a domain will be used.
synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
""")
- def connect_local_bft(domain: NonEmpty[Map[SequencerAlias, InstanceReferenceWithSequencerConnection]], manualConnect: Boolean = false, alias: Option[DomainAlias] = None, maxRetryDelayMillis: Option[Long] = None, priority: Int = 0, synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded ), sequencerTrustThreshold: PositiveInt = PositiveInt.tryCreate(1)): Unit
- def connect_multi(domainAlias: DomainAlias, connections: Seq[SequencerConnection], synchronize: Option[NonNegativeDuration] = Some(
consoleEnvironment.commandTimeouts.bounded
)): DomainConnectionConfig
- Annotations
- @Summary(s = "Macro to connect a participant to a domain that supports connecting via many endpoints", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Domains can provide many endpoints to connect to for availability and performance benefits.
This version of connect allows specifying multiple endpoints for a single domain connection:
connect_multi("mydomain", Seq(sequencer1, sequencer2))
or:
connect_multi("mydomain", Seq("https://host1.mydomain.net", "https://host2.mydomain.net", "https://host3.mydomain.net"))
To create a more advanced connection config use domains.toConfig with a single host,
|then use config.addConnection to add additional connections before connecting:
config = myparticipaint.domains.toConfig("mydomain", "https://host1.mydomain.net", ...otherArguments)
config = config.addConnection("https://host2.mydomain.net", "https://host3.mydomain.net")
myparticipant.domains.connect(config)
The arguments are:
domainAlias - The name you will be using to refer to this domain. Can not be changed anymore.
connections - The sequencer connection definitions (can be an URL) to connect to this domain. I.e. https://url:port
synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
""")
- def connect_single(domainAlias: DomainAlias, sequencerConnection: SequencerConnection, synchronize: Option[NonNegativeDuration] = Some(
consoleEnvironment.commandTimeouts.bounded
)): DomainConnectionConfig
- Annotations
- @Summary(s = "Macro to connect a participant to a domain that supports a single sequencer connection", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Calls a `connect_multi` macro with a single sequencer connection. This is
|particularly useful if we have a reference to a remote sequencer and can easily get
|the respective sequencer connection <sequencer>.sequencerConnection.
The arguments are:
domainAlias - The name you will be using to refer to this domain. Can not be changed anymore.
sequencerConnection - A single sequencer connection to connect to this domain. I.e. https://url:port
synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
""")
- def disconnect(domainAlias: DomainAlias): Unit
- Annotations
- @Summary(s = "Disconnect this participant from the given domain", flag = console.this.Help.Summary.<init>$default$2)
- def disconnect_all(): Unit
- Annotations
- @Summary(s = "Disconnect this participant from all connected domains", flag = console.this.Help.Summary.<init>$default$2)
- def disconnect_local(domain: DomainReference): Unit
- Annotations
- @Summary(s = "Disconnect this participant from the given local domain", flag = console.this.Help.Summary.<init>$default$2)
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
- def get_agreement(domainAlias: DomainAlias): Option[(Agreement, Boolean)]
- Annotations
- @Summary(s = "Get the service agreement of the given domain alias and if it has been accepted already.", flag = console.this.Help.Summary.<init>$default$2)
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
- def help(methodName: String)(implicit consoleEnvironment: ConsoleEnvironment): Unit
- Definition Classes
- Helpful
- Annotations
- @Summary(s = "Help for specific commands (use help() or help(\"method\") for more information)", flag = console.this.Help.Summary.<init>$default$2) @Topic(t = Seq("Top-level Commands"))
- def help()(implicit consoleEnvironment: ConsoleEnvironment): Unit
- Definition Classes
- Helpful
- def id_of(domainAlias: DomainAlias): DomainId
- Annotations
- @Summary(s = "Returns the id of the given domain alias", flag = console.this.Help.Summary.<init>$default$2)
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def is_connected(reference: DomainAdministration): Boolean
- Annotations
- @Summary(s = "Test whether a participant is connected to a domain reference", flag = console.this.Help.Summary.<init>$default$2)
- def is_registered(domain: DomainAlias): Boolean
- Annotations
- @Summary(s = "Returns true if a domain is registered using the given alias", flag = console.this.Help.Summary.<init>$default$2)
- def list_connected(): Seq[ListConnectedDomainsResult]
- Annotations
- @Summary(s = "List the connected domains of this participant", flag = console.this.Help.Summary.<init>$default$2)
- def list_registered(): Seq[(DomainConnectionConfig, Boolean)]
- Annotations
- @Summary(s = "List the configured domains of this participant", flag = console.this.Help.Summary.<init>$default$2)
- def modify(domain: DomainAlias, modifier: (DomainConnectionConfig) => DomainConnectionConfig): Unit
- Annotations
- @Summary(s = "Modify existing domain connection", flag = console.this.Help.Summary.<init>$default$2)
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
- def reconnect(domainAlias: DomainAlias, retry: Boolean = true, synchronize: Option[NonNegativeDuration] = Some(
consoleEnvironment.commandTimeouts.bounded
)): Boolean
- Annotations
- @Summary(s = "Reconnect this participant to the given domain", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Idempotent attempts to re-establish a connection to a certain domain.
|If retry is set to false, the command will throw an exception if unsuccessful.
|If retry is set to true, the command will terminate after the first attempt with the result,
|but the server will keep on retrying to connect to the domain.
|
The arguments are:
domainAlias - The name you will be using to refer to this domain. Can not be changed anymore.
retry - Whether the reconnect should keep on retrying until it succeeded or abort noisly if the connection attempt fails.
synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
""")
- def reconnect_all(ignoreFailures: Boolean = true, synchronize: Option[NonNegativeDuration] = Some(
consoleEnvironment.commandTimeouts.bounded
)): Unit
- Annotations
- @Summary(s = "Reconnect this participant to all domains which are not marked as manual start", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """
The arguments are:
ignoreFailures - If set to true (default), we'll attempt to connect to all, ignoring any failure
synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
""")
- def reconnect_local(ref: DomainReference, retry: Boolean = true, synchronize: Option[NonNegativeDuration] = Some(
consoleEnvironment.commandTimeouts.bounded
)): Boolean
- Annotations
- @Summary(s = "Reconnect this participant to the given local domain", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Idempotent attempts to re-establish a connection to the given local domain.
|Same behaviour as generic reconnect.
The arguments are:
ref - The domain reference to connect to
retry - Whether the reconnect should keep on retrying until it succeeded or abort noisly if the connection attempt fails.
synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
""")
- def register(config: DomainConnectionConfig): Unit
- Annotations
- @Summary(s = "Register new domain connection", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """When connecting to a domain, we need to register the domain connection and eventually
|accept the terms of service of the domain before we can connect. The registration process is therefore
|a subset of the operation. Therefore, register is equivalent to connect if the domain does not require
|a service agreement. However, you would usually call register only in advanced scripts.""")
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])