Apache Pekko 2.0.0-M3+222-b197663b-SNAPSHOT - org.apache.pekko.remote.testconductor.Conductor Apache Pekko2.0.0-M3+222-b197663b-SNAPSHOT < Back  Packages  package root Definition Classesroot  package org Definition Classesroot  package apache Definition Classesorg  package pekko Definition Classesapache  package remote Definition Classespekko  package testconductor Definition Classesremote Conductor Player RoleName TestConductor TestConductorExt TestConductorProtocol t org.apache.pekko.remote.testconductorConductor trait Conductor extends AnyRef The conductor is the one orchestrating the test: it governs the Controller’s port to which all pekko.remote.testconductor.Players connect, it issues commands to their org.apache.pekko.remote.testconductor.NetworkFailureInjector and provides support for barriers using the BarrierCoordinator. All of this is bundled inside the pekko.remote.testconductor.TestConductorExt extension. Self TypeTestConductorExtSourceConductor.scala Linear Supertypes AnyRef, Any Known Subclasses TestConductorExt Type Hierarchy  Ordering Alphabetic By Inheritance Inherited Conductor AnyRef Any Implicitly by any2stringadd by StringFormat by Ensuring by ArrowAssoc Hide All Show All Visibility Public Protected Value Members  final def !=(arg0: Any): Boolean Definition ClassesAnyRef → Any  final def ##: Int Definition ClassesAnyRef → Any  def +(other: String): String ImplicitThis member is added by an implicit conversion from Conductor toany2stringadd[Conductor] performed by method any2stringadd in scala.Predef.Definition Classesany2stringadd  def ->[B](y: B): (Conductor, B) ImplicitThis member is added by an implicit conversion from Conductor toArrowAssoc[Conductor] performed by method ArrowAssoc in scala.Predef.Definition ClassesArrowAssocAnnotations@inline()  final def ==(arg0: Any): Boolean Definition ClassesAnyRef → Any  def abort(node: RoleName, target: RoleName): Future[Done] Tell the remote support to TCP_RESET the connection to the given remote peer. Tell the remote support to TCP_RESET the connection to the given remote peer. It works regardless of whether the recipient was initiator or responder. node is the symbolic name of the node which is to be affectedtarget is the symbolic name of the other node to which connectivity shall be impeded  final def asInstanceOf[T0]: T0 Definition ClassesAny  def blackhole(node: RoleName, target: RoleName, direction: Direction): Future[Done] Switch the Netty pipeline of the remote support into blackhole mode for sending and/or receiving: it will just drop all messages right before submitting them to the Socket or right after receiving them from the Socket. Switch the Netty pipeline of the remote support into blackhole mode for sending and/or receiving: it will just drop all messages right before submitting them to the Socket or right after receiving them from the Socket.Note To use this feature you must activate the failure injector and throttler transport adapters by specifying testTransport(on = true) in your MultiNodeConfig. node is the symbolic name of the node which is to be affectedtarget is the symbolic name of the other node to which connectivity shall be impededdirection can be either Direction.Send, Direction.Receive or Direction.Both  def clone(): AnyRef Attributesprotected[lang] Definition ClassesAnyRefAnnotations@throws(classOf[java.lang.CloneNotSupportedException]) @IntrinsicCandidate() @native()  def disconnect(node: RoleName, target: RoleName): Future[Done] Tell the remote support to shutdown the connection to the given remote peer. Tell the remote support to shutdown the connection to the given remote peer. It works regardless of whether the recipient was initiator or responder. node is the symbolic name of the node which is to be affectedtarget is the symbolic name of the other node to which connectivity shall be impeded  def ensuring(cond: (Conductor) => Boolean, msg: => Any): Conductor ImplicitThis member is added by an implicit conversion from Conductor toEnsuring[Conductor] performed by method Ensuring in scala.Predef.Definition ClassesEnsuring  def ensuring(cond: (Conductor) => Boolean): Conductor ImplicitThis member is added by an implicit conversion from Conductor toEnsuring[Conductor] performed by method Ensuring in scala.Predef.Definition ClassesEnsuring  def ensuring(cond: Boolean, msg: => Any): Conductor ImplicitThis member is added by an implicit conversion from Conductor toEnsuring[Conductor] performed by method Ensuring in scala.Predef.Definition ClassesEnsuring  def ensuring(cond: Boolean): Conductor ImplicitThis member is added by an implicit conversion from Conductor toEnsuring[Conductor] performed by method Ensuring in scala.Predef.Definition ClassesEnsuring  final def eq(arg0: AnyRef): Boolean Definition ClassesAnyRef  def equals(arg0: AnyRef): Boolean Definition ClassesAnyRef → Any  def exit(node: RoleName, exitValue: Int): Future[Done] Tell the remote node to shut itself down using System.exit with the given exitValue. Tell the remote node to shut itself down using System.exit with the given exitValue. The node will also be removed, so that the remaining nodes may still pass subsequent barriers. node is the symbolic name of the node which is to be affectedexitValue is the return code which shall be given to System.exit  final def getClass(): Class[_ <: AnyRef] Definition ClassesAnyRef → AnyAnnotations@IntrinsicCandidate() @native()  def getNodes: Future[Iterable[RoleName]] Obtain the list of remote host names currently registered.  def hashCode(): Int Definition ClassesAnyRef → AnyAnnotations@IntrinsicCandidate() @native()  final def isInstanceOf[T0]: Boolean Definition ClassesAny  final def ne(arg0: AnyRef): Boolean Definition ClassesAnyRef  final def notify(): Unit Definition ClassesAnyRefAnnotations@IntrinsicCandidate() @native()  final def notifyAll(): Unit Definition ClassesAnyRefAnnotations@IntrinsicCandidate() @native()  def passThrough(node: RoleName, target: RoleName, direction: Direction): Future[Done] Switch the Netty pipeline of the remote support into pass through mode for sending and/or receiving. Switch the Netty pipeline of the remote support into pass through mode for sending and/or receiving.Note To use this feature you must activate the failure injector and throttler transport adapters by specifying testTransport(on = true) in your MultiNodeConfig. node is the symbolic name of the node which is to be affectedtarget is the symbolic name of the other node to which connectivity shall be impededdirection can be either Direction.Send, Direction.Receive or Direction.Both  def removeNode(node: RoleName): Future[Done] Remove a remote host from the list, so that the remaining nodes may still pass subsequent barriers. Remove a remote host from the list, so that the remaining nodes may still pass subsequent barriers. This must be done before the client connection breaks down in order to affect an “orderly” removal (i.e. without failing present and future barriers). node is the symbolic name of the node which is to be removed  def shutdown(node: RoleName, abort: Boolean): Future[Done] Tell the actor system at the remote node to shut itself down without awaiting termination of remote-deployed children. Tell the actor system at the remote node to shut itself down without awaiting termination of remote-deployed children. The node will also be removed, so that the remaining nodes may still pass subsequent barriers. node is the symbolic name of the node which is to be affected  def shutdown(node: RoleName): Future[Done] Tell the actor system at the remote node to shut itself down. Tell the actor system at the remote node to shut itself down. The node will also be removed, so that the remaining nodes may still pass subsequent barriers. node is the symbolic name of the node which is to be affected  def sockAddr: Future[InetSocketAddress] Obtain the port to which the controller’s socket is actually bound. Obtain the port to which the controller’s socket is actually bound. This will deviate from the configuration in pekko.testconductor.port in case that was given as zero.  def startController(participants: Int, name: RoleName, controllerPort: InetSocketAddress): Future[InetSocketAddress] Start the Controller, which in turn will bind to a TCP port as specified in the pekko.testconductor.port config property, where 0 denotes automatic allocation. Start the Controller, which in turn will bind to a TCP port as specified in the pekko.testconductor.port config property, where 0 denotes automatic allocation. Since the latter is actually preferred, a Future[Int] is returned which will be completed with the port number actually chosen, so that this can then be communicated to the players for their proper start-up. This method also invokes pekko.remote.testconductor.Player.startClient, since it is expected that the conductor participates in barriers for overall coordination. The returned Future will only be completed once the client’s start-up finishes, which in fact waits for all other players to connect. participants gives the number of participants which shall connect before any of their startClient() operations complete.  final def synchronized[T0](arg0: => T0): T0 Definition ClassesAnyRef  def throttle(node: RoleName, target: RoleName, direction: Direction, rateMBit: Double): Future[Done] Make the remoting pipeline on the node throttle data sent to or received from the given remote peer. Make the remoting pipeline on the node throttle data sent to or received from the given remote peer. Throttling works by delaying packet submission within the netty pipeline until the packet would have been completely sent according to the given rate, the previous packet completion and the current packet length. In case of large packets they are split up if the calculated send pause would exceed pekko.testconductor.packet-split-threshold (roughly). All of this uses the system’s scheduler, which is not terribly precise and will execute tasks later than they are schedule (even on average), but that is countered by using the actual execution time for determining how much to send, leading to the correct output rate, but with increased latency.Note To use this feature you must activate the failure injector and throttler transport adapters by specifying testTransport(on = true) in your MultiNodeConfig. node is the symbolic name of the node which is to be affectedtarget is the symbolic name of the other node to which connectivity shall be throttleddirection can be either Direction.Send, Direction.Receive or Direction.BothrateMBit is the maximum data rate in MBit  def toString(): String Definition ClassesAnyRef → Any  final def wait(arg0: Long, arg1: Int): Unit Definition ClassesAnyRefAnnotations@throws(classOf[java.lang.InterruptedException])  final def wait(arg0: Long): Unit Definition ClassesAnyRefAnnotations@throws(classOf[java.lang.InterruptedException]) @native()  final def wait(): Unit Definition ClassesAnyRefAnnotations@throws(classOf[java.lang.InterruptedException]) Deprecated Value Members  def finalize(): Unit Attributesprotected[lang] Definition ClassesAnyRefAnnotations@throws(classOf[java.lang.Throwable]) @Deprecated Deprecated (Since version 9)  def formatted(fmtstr: String): String ImplicitThis member is added by an implicit conversion from Conductor toStringFormat[Conductor] performed by method StringFormat in scala.Predef.Definition ClassesStringFormatAnnotations@deprecated @inline() Deprecated (Since version 2.12.16) Use formatString.format(value) instead of value.formatted(formatString), or use the f"" string interpolator. In Java 15 and later, formatted resolves to the new method in String which has reversed parameters.  def →[B](y: B): (Conductor, B) ImplicitThis member is added by an implicit conversion from Conductor toArrowAssoc[Conductor] performed by method ArrowAssoc in scala.Predef.Definition ClassesArrowAssocAnnotations@deprecated Deprecated (Since version 2.13.0) Use -> instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code. Inherited from AnyRef Inherited from Any Inherited by implicit conversion any2stringadd fromConductor to any2stringadd[Conductor] Inherited by implicit conversion StringFormat fromConductor to StringFormat[Conductor] Inherited by implicit conversion Ensuring fromConductor to Ensuring[Conductor] Inherited by implicit conversion ArrowAssoc fromConductor to ArrowAssoc[Conductor] Ungrouped