Packages

object synchronizers extends Helpful

Annotations
@Summary(s = "Manage synchronizer connections", flag = console.this.Help.Summary.<init>$default$2) @Group(name = "Synchronizers")
Linear Supertypes
Helpful, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. synchronizers
  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 active(synchronizerAlias: SynchronizerAlias): Boolean
    Annotations
    @Summary(s = "Test whether a participant is connected to and permissioned on a synchronizer.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Yields false, if the synchronizer is not connected or not healthy.
    |Yields false, if the synchronizer is configured in the Canton configuration and
    |the participant is not active from the perspective of the synchronizer."""    )
  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @IntrinsicCandidate() @native()
  7. def config(synchronizerAlias: SynchronizerAlias): Option[SynchronizerConnectionConfig]
    Annotations
    @Summary(s = "Returns the current configuration of a given synchronizer", flag = console.this.Help.Summary.<init>$default$2)
  8. def connect(synchronizerAlias: SynchronizerAlias, connection: String, manualConnect: Boolean = false, synchronizerId: Option[SynchronizerId] = None, certificatesPath: String = "", priority: Int = 0, timeTrackerConfig: SynchronizerTimeTrackerConfig = SynchronizerTimeTrackerConfig(), synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded ), validation: SequencerConnectionValidation = SequencerConnectionValidation.All, sequencerAlias: SequencerAlias = SequencerAlias.Default): SynchronizerConnectionConfig
    Annotations
    @Summary(s = "Macro to connect a participant to a synchronizer 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 synchronizer.
    |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.
    |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 synchronizer will remain registered with `manualConnect = true` and
    |you will have to perform these steps manually.
    The arguments are:
    synchronizerAlias - The name you will be using to refer to this synchronizer. Cannot be changed anymore.
    connection - The connection string to connect to this synchronizer. I.e. https://url:port
    manualConnect - Whether this connection should be handled manually and also excluded from automatic re-connect.
    synchronizerId - Optionally the synchronizerId you expect to see on this synchronizer.
    certificatesPath - Path to TLS certificate files to use as a trust anchor.
    priority - The priority of the synchronizer. The higher the more likely a synchronizer will be used.
    timeTrackerConfig - The configuration for the synchronizer time tracker.
    synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
    validation - Whether to validate the connectivity and ids of the given sequencers (default All)
    """    )
  9. def connect(instance: SequencerReference, synchronizerAlias: SynchronizerAlias): Unit
    Annotations
    @Summary(s = "Macro to connect a participant to a synchronizer given by instance", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This variant of connect expects an instance with a sequencer connection.
    |Otherwise the behaviour is equivalent to the connect command with explicit
    |arguments. If the synchronizer is already configured, the synchronizer connection
    |will be attempted. If however the synchronizer is offline, the command will fail.
    |Generally, this macro should only be used for the first connection to a new synchronizer. However, for
    |convenience, we support idempotent invocations where subsequent calls just ensure
    |that the participant reconnects to the synchronizer.
    |"""    )
  10. def connect_bft(connections: Seq[SequencerConnection], synchronizerAlias: SynchronizerAlias, synchronizerId: Option[SynchronizerId] = None, manualConnect: Boolean = false, priority: Int = 0, synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded ), sequencerTrustThreshold: PositiveInt = PositiveInt.one, submissionRequestAmplification: SubmissionRequestAmplification = SubmissionRequestAmplification.NoAmplification, validation: SequencerConnectionValidation = SequencerConnectionValidation.All): Unit
    Annotations
    @Summary(s = "Macro to connect to multiple sequencers of the same synchronizer.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """
    The arguments are:
    synchronizerAlias - The name you will be using to refer to this synchronizer. Cannot be changed anymore.
    connections - The list of sequencer connections, can be defined by urls.
    manualConnect - Whether this connection should be handled manually and also excluded from automatic re-connect.
    synchronizerId - An optional Synchronizer Id to ensure the connection is made to the correct synchronizer.
    priority - The priority of the synchronizer. The higher the more likely a synchronizer will be used.
    synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
    sequencerTrustThreshold - Set the minimum number of sequencers that must agree before a message is considered valid.
    submissionRequestAmplification - Define how often client should try to send a submission request that is eligible for deduplication.
    validation - Whether to validate the connectivity and ids of the given sequencers (default All)
    """    )
  11. def connect_by_config(config: SynchronizerConnectionConfig, validation: SequencerConnectionValidation = SequencerConnectionValidation.All, synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.unbounded )): Unit
    Annotations
    @Summary(s = "Macro to connect a participant to a synchronizer given by connection", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This variant of connect expects a synchronizer connection config.
    |Otherwise the behaviour is equivalent to the connect command with explicit
    |arguments. If the synchronizer is already configured, the synchronizer connection
    |will be attempted. If however the synchronizer is offline, the command will fail.
    |Generally, this macro should only be used for the first connection to a new synchronizer. However, for
    |convenience, we support idempotent invocations where subsequent calls just ensure
    |that the participant reconnects to the synchronizer.

    validation - Whether to validate the connectivity and ids of the given sequencers (default all)
    |"""    )
  12. def connect_local(sequencer: SequencerReference, alias: SynchronizerAlias, manualConnect: Boolean = false, synchronizerId: Option[SynchronizerId] = None, maxRetryDelayMillis: Option[Long] = None, priority: Int = 0, synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded ), validation: SequencerConnectionValidation = SequencerConnectionValidation.All): Unit
    Annotations
    @Summary(s = "Macro to connect a participant to a locally configured synchronizer given by sequencer reference", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """
    The arguments are:
    sequencer - A local sequencer reference
    alias - The name you will be using to refer to this synchronizer. Can not be changed anymore.
    manualConnect - Whether this connection should be handled manually and also excluded from automatic re-connect.
    synchronizerId - An optional Synchronizer Id to ensure the connection is made to the correct synchronizer.
    maxRetryDelayMillis - Maximal amount of time (in milliseconds) between two connection attempts.
    priority - The priority of the synchronizer. The higher the more likely a synchronizer will be used.
    synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
    validation - Whether to validate the connectivity and ids of the given sequencers (default All)
    """    )
  13. def connect_local_bft(sequencers: Seq[SequencerReference], synchronizerAlias: SynchronizerAlias, manualConnect: Boolean = false, synchronizerId: Option[SynchronizerId] = None, maxRetryDelayMillis: Option[Long] = None, priority: Int = 0, synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded ), sequencerTrustThreshold: PositiveInt = PositiveInt.one, submissionRequestAmplification: SubmissionRequestAmplification = SubmissionRequestAmplification.NoAmplification, validation: SequencerConnectionValidation = SequencerConnectionValidation.All): Unit
    Annotations
    @Summary(s = "Macro to connect to multiple local sequencers of the same synchronizer.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """
    The arguments are:
    synchronizerAlias - The name you will be using to refer to this synchronizer. Cannot be changed anymore.
    sequencers - The list of sequencer references to connect to.
    manualConnect - Whether this connection should be handled manually and also excluded from automatic re-connect.
    synchronizerId - An optional Synchronizer Id to ensure the connection is made to the correct synchronizer.
    priority - The priority of the synchronizer. The higher the more likely a synchronizer will be used.
    synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
    sequencerTrustThreshold - Set the minimum number of sequencers that must agree before a message is considered valid.
    submissionRequestAmplification - Define how often client should try to send a submission request that is eligible for deduplication.
    validation - Whether to validate the connectivity and ids of the given sequencers (default All)
    """    )
  14. def connect_multi(synchronizerAlias: SynchronizerAlias, connections: Seq[SequencerConnection], synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded ), validation: SequencerConnectionValidation = SequencerConnectionValidation.All): SynchronizerConnectionConfig
    Annotations
    @Summary(s = "Macro to connect a participant to a synchronizer that supports connecting via many endpoints", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Synchronizers can provide many endpoints to connect to for availability and performance benefits.
    This version of connect allows specifying multiple endpoints for a single synchronizer connection:
    connect_multi("mysynchronizer", Seq(sequencer1, sequencer2))
    or:
    connect_multi("mysynchronizer", Seq("https://host1.mysynchronizer.net", "https://host2.mysynchronizer.net", "https://host3.mysynchronizer.net"))

    To create a more advanced connection config use synchronizers.to_config with a single host,
    |then use config.addConnection to add additional connections before connecting:
    config = myparticipaint.synchronizers.to_config("mysynchronizer", "https://host1.mysynchronizer.net", ...otherArguments)
    config = config.addConnection("https://host2.mysynchronizer.net", "https://host3.mysynchronizer.net")
    myparticipant.synchronizers.connect(config)

    The arguments are:
    synchronizerAlias - The name you will be using to refer to this synchronizer. Cannot be changed anymore.
    connections - The sequencer connection definitions (can be an URL) to connect to this synchronizer. 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.
    validation - Whether to validate the connectivity and ids of the given sequencers (default All)
    """    )
  15. def disconnect(synchronizerAlias: SynchronizerAlias): Unit
    Annotations
    @Summary(s = "Disconnect this participant from the given synchronizer", flag = console.this.Help.Summary.<init>$default$2)
  16. def disconnect_all(): Unit
    Annotations
    @Summary(s = "Disconnect this participant from all connected synchronizers", flag = console.this.Help.Summary.<init>$default$2)
  17. def disconnect_local(synchronizerAlias: SynchronizerAlias): Unit
    Annotations
    @Summary(s = "Disconnect this participant from the given local synchronizer", flag = console.this.Help.Summary.<init>$default$2)
  18. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  19. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  20. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @IntrinsicCandidate() @native()
  21. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @IntrinsicCandidate() @native()
  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(synchronizerAlias: SynchronizerAlias): SynchronizerId
    Annotations
    @Summary(s = "Returns the id of the given synchronizer alias", flag = console.this.Help.Summary.<init>$default$2)
  25. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  26. def is_connected(synchronizerAlias: SynchronizerAlias): Boolean
    Annotations
    @Summary(s = "Test whether a participant is connected to a synchronizer", flag = console.this.Help.Summary.<init>$default$2)
  27. def is_connected(synchronizerId: SynchronizerId): Boolean
    Annotations
    @Summary(s = "Test whether a participant is connected to a synchronizer", flag = console.this.Help.Summary.<init>$default$2)
  28. def is_registered(synchronizerAlias: SynchronizerAlias): Boolean
    Annotations
    @Summary(s = "Returns true if a synchronizer is registered using the given alias", flag = console.this.Help.Summary.<init>$default$2)
  29. def list_connected(): Seq[ListConnectedSynchronizersResult]
    Annotations
    @Summary(s = "List the connected synchronizers of this participant", flag = console.this.Help.Summary.<init>$default$2)
  30. def list_registered(): Seq[(SynchronizerConnectionConfig, Boolean)]
    Annotations
    @Summary(s = "List the configured synchronizer of this participant", flag = console.this.Help.Summary.<init>$default$2) @Description(s = "For each returned synchronizer, the boolean indicates whether the participant is currently connected to the synchronizer.")
  31. def logout(synchronizerAlias: SynchronizerAlias): Unit
    Annotations
    @Summary(s = "Revoke this participant's authentication tokens and close all the sequencer connections in the given synchronizer", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """
    synchronizerAlias: the synchronizer alias from which to logout
    On all the sequencers from the specified synchronizer, all existing authentication tokens for this participant
    will be revoked.
    Note that the participant is not disconnected from the synchronizer; only the connections to the sequencers are closed.
    The participant will automatically reopen connections, perform a challenge-response and obtain new tokens.
    """    )
  32. def modify(synchronizerAlias: SynchronizerAlias, modifier: (SynchronizerConnectionConfig) => SynchronizerConnectionConfig, validation: SequencerConnectionValidation = SequencerConnectionValidation.All): Unit
    Annotations
    @Summary(s = "Modify existing synchronizer connection", flag = console.this.Help.Summary.<init>$default$2)
  33. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  34. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @IntrinsicCandidate() @native()
  35. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @IntrinsicCandidate() @native()
  36. def reconnect(synchronizerAlias: SynchronizerAlias, retry: Boolean = true, synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded )): Boolean
    Annotations
    @Summary(s = "Reconnect this participant to the given synchronizer", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Idempotent attempts to re-establish a connection to a certain synchronizer.
    |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 synchronizer.
    |
    The arguments are:
    synchronizerAlias - The name you will be using to refer to this synchronizer. Cannot be changed anymore.
    retry - Whether the reconnect should keep on retrying until it succeeded or abort noisily 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 reconnect_all(ignoreFailures: Boolean = true, synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded )): Unit
    Annotations
    @Summary(s = "Reconnect this participant to all synchronizer 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.
    """    )
  38. def reconnect_local(synchronizerAlias: SynchronizerAlias, retry: Boolean = true, synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded )): Boolean
    Annotations
    @Summary(s = "Reconnect this participant to the given local synchronizer", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Idempotent attempts to re-establish a connection to the given local synchronizer.
    |Same behaviour as generic reconnect.

    The arguments are:
    synchronizerAlias - The synchronizer alias to connect to
    retry - Whether the reconnect should keep on retrying until it succeeded or abort noisily 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.
    """    )
  39. def reconnect_local(ref: SequencerReference): Boolean
    Annotations
    @Summary(s = "Reconnect this participant to the given local synchronizer", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Idempotent attempts to re-establish a connection to the given local synchronizer.
    |Same behaviour as generic reconnect.

    The arguments are:
    ref - The synchronizer reference to connect to
    retry - Whether the reconnect should keep on retrying until it succeeded or abort noisily 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.
    """    )
  40. def register(sequencer: SequencerReference, alias: SynchronizerAlias, performHandshake: Boolean = true, manualConnect: Boolean = false, synchronizerId: Option[SynchronizerId] = None, maxRetryDelayMillis: Option[Long] = None, priority: Int = 0, synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded ), validation: SequencerConnectionValidation = SequencerConnectionValidation.All): Unit
    Annotations
    @Summary(s = "Macro to register a locally configured synchronizer given by sequencer reference", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """
    The arguments are:
    sequencer - A local sequencer reference
    alias - The name you will be using to refer to this synchronizer. Cannot be changed anymore.
    performHandshake - If true (default), will perform a handshake with the synchronizer. If no, will only store the configuration without any query to the synchronizer.
    manualConnect - Whether this connection should be handled manually and also excluded from automatic re-connect.
    synchronizerId - An optional Synchronizer Id to ensure the connection is made to the correct synchronizer.
    maxRetryDelayMillis - Maximal amount of time (in milliseconds) between two connection attempts.
    priority - The priority of the synchronizer. The higher the more likely a synchronizer will be used.
    synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
    validation - Whether to validate the connectivity and ids of the given sequencers (default All)
    """    )
  41. def register_by_config(config: SynchronizerConnectionConfig, performHandshake: Boolean = true, validation: SequencerConnectionValidation = SequencerConnectionValidation.All, synchronize: Option[NonNegativeDuration] = Some( consoleEnvironment.commandTimeouts.bounded )): Unit
    Annotations
    @Summary(s = "Macro to register a locally configured synchronizer", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """
    The arguments are:
    config - Config for the synchronizer connection
    performHandshake - If true (default), will perform handshake with the synchronizer. If no, will only store configuration without any query to the synchronizer.
    validation - Whether to validate the connectivity and ids of the given sequencers (default All)
    synchronize - A timeout duration indicating how long to wait for all topology changes to have been effected on all local nodes.
    """    )
  42. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  43. def toString(): String
    Definition Classes
    AnyRef → Any
  44. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  45. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  46. 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

    (Since version 9)

Inherited from Helpful

Inherited from AnyRef

Inherited from Any

Ungrouped