Packages

object domains extends Helpful

Annotations
@Summary(s = "Manage domain connections", flag = console.this.Help.Summary.<init>$default$2) @Group(name = "Domains")
Linear Supertypes
Helpful, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. domains
  2. Helpful
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. 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)
  5. def active(reference: DomainAdministration): Boolean
    Annotations
    @Summary(s = "Test whether a participant is connected to and permissioned on a domain reference. " +
    "Fails with an exception, if the domain `reference` has not yet been initialized."    , flag = console.this.Help.Summary.<init>$default$2)
  6. def active(domain: DomainAlias): Boolean
    Annotations
    @Summary(s = "Test whether a participant is connected to and permissioned on a domain where we have a healthy subscription.", flag = console.this.Help.Summary.<init>$default$2)
  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  9. 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)
  10. def connect(domainAlias: DomainAlias, connection: String, manualConnect: Boolean = false, domainId: Option[DomainId] = None, certificatesPath: String = "", priority: Int = 0, timeTrackerConfig: DomainTimeTrackerConfig = DomainTimeTrackerConfig(), synchronize: Option[TimeoutDuration] = 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.
    """    )
  11. 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.
    |"""    )
  12. def connect_ha(domainAlias: DomainAlias, connections: Seq[SequencerConnection], synchronize: Option[TimeoutDuration] = 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_ha("mydomain", Seq(sequencer1, sequencer2))
    or:
    connect_ha("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.
    """    )
  13. 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
  14. def connect_local(domain: InstanceReferenceWithSequencerConnection, manualConnect: Boolean = false, alias: Option[DomainAlias] = None, maxRetryDelayMillis: Option[Long] = None, priority: Int = 0, synchronize: Option[TimeoutDuration] = 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.
    """    )
  15. def disconnect(domainAlias: DomainAlias): Unit
    Annotations
    @Summary(s = "Disconnect this participant from the given domain", flag = console.this.Help.Summary.<init>$default$2)
  16. 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)
  17. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  18. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  19. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  20. 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)
  21. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  22. 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"))
  23. def help()(implicit consoleEnvironment: ConsoleEnvironment): Unit
    Definition Classes
    Helpful
  24. 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)
  25. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  26. 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)
  27. 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)
  28. def list_connected(): Seq[ListConnectedDomainsResult]
    Annotations
    @Summary(s = "List the connected domains of this participant", flag = console.this.Help.Summary.<init>$default$2)
  29. def list_registered(): Seq[(DomainConnectionConfig, Boolean)]
    Annotations
    @Summary(s = "List the configured domains of this participant", flag = console.this.Help.Summary.<init>$default$2)
  30. def modify(domain: DomainAlias, modifier: (DomainConnectionConfig) => DomainConnectionConfig): Unit
    Annotations
    @Summary(s = "Modify existing domain connection", flag = console.this.Help.Summary.<init>$default$2)
  31. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  32. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  33. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  34. def reconnect(domainAlias: DomainAlias, retry: Boolean = true, synchronize: Option[TimeoutDuration] = 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.
    """    )
  35. def reconnect_all(ignoreFailures: Boolean = true, synchronize: Option[TimeoutDuration] = 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.
    """    )
  36. def reconnect_local(ref: DomainReference, retry: Boolean = true, synchronize: Option[TimeoutDuration] = 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.
    """    )
  37. 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."""    )
  38. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  39. def toString(): String
    Definition Classes
    AnyRef → Any
  40. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  41. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  42. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

Inherited from Helpful

Inherited from AnyRef

Inherited from Any

Ungrouped