docs/net.corda.testing.node.internal/DriverDSLImpl

DriverDSLImpl

class DriverDSLImpl(val portAllocation: PortAllocation, val debugPortAllocation: PortAllocation, val systemProperties: Map<String, String>, val driverDirectory: Path, val useTestClock: Boolean, val isDebug: Boolean, val startNodesInProcess: Boolean, val waitForAllNodesToFinish: Boolean, val extraCordappPackagesToScan: List<String>, val jmxPolicy: JmxPolicy, val notarySpecs: List<NotarySpec>, val compatibilityZone: CompatibilityZoneParams?, val networkParameters: <Error class: unknown class>, val notaryCustomOverrides: Map<String, Any?>, val inMemoryDB: Boolean, val cordappsForAllNodes: Collection<TestCordappInternal>?, val environmentVariables: Map<String, String>, val enableSNI: Boolean = false, val allowHibernateToManageAppSchema: Boolean = true, val premigrateH2Database: Boolean = true, val notaryHandleTimeout: Duration = Duration.ofMinutes(2)) : InternalDriverDSL

Constructors

DriverDSLImpl

constructor(portAllocation: PortAllocation, debugPortAllocation: PortAllocation, systemProperties: Map<String, String>, driverDirectory: Path, useTestClock: Boolean, isDebug: Boolean, startNodesInProcess: Boolean, waitForAllNodesToFinish: Boolean, extraCordappPackagesToScan: List<String>, jmxPolicy: JmxPolicy, notarySpecs: List<NotarySpec>, compatibilityZone: CompatibilityZoneParams?, networkParameters: <Error class: unknown class>, notaryCustomOverrides: Map<String, Any?>, inMemoryDB: Boolean, cordappsForAllNodes: Collection<TestCordappInternal>?, environmentVariables: Map<String, String>, enableSNI: Boolean = false, allowHibernateToManageAppSchema: Boolean = true, premigrateH2Database: Boolean = true, notaryHandleTimeout: Duration = Duration.ofMinutes(2))

Types

Companion

object Companion

LocalNetworkMap

inner class LocalNetworkMap(notaryInfos: List<<Error class: unknown class>>)

The local version of the network map, which is a bunch of classes that copy the relevant files to the node directories.

State

class State

Waitable

interface Waitable

Properties

allowHibernateToManageAppSchema

val allowHibernateToManageAppSchema: Boolean = true

compatibilityZone

val compatibilityZone: CompatibilityZoneParams?

cordappsClassLoader

open override val cordappsClassLoader: URLClassLoader?

cordappsForAllNodes

val cordappsForAllNodes: Collection<TestCordappInternal>?

debugPortAllocation

val debugPortAllocation: PortAllocation

defaultNotaryHandle

open val defaultNotaryHandle: NotaryHandle

Returns the NotaryHandle for the single notary on the network. Throws if there are none or more than one.

defaultNotaryIdentity

open val defaultNotaryIdentity: <Error class: unknown class>

Returns the identity of the single notary on the network. Throws if there are none or more than one.

defaultNotaryNode

open val defaultNotaryNode: <Error class: unknown class><NodeHandle>

Returns a CordaFuture on the NodeHandle for the single-node notary on the network. Throws if there are no notaries or more than one, or if the notary is a distributed cluster.

driverDirectory

val driverDirectory: Path

enableSNI

val enableSNI: Boolean = false

environmentVariables

val environmentVariables: Map<String, String>

executorService

val executorService: ScheduledExecutorService

extraCordappPackagesToScan

val extraCordappPackagesToScan: List<String>

inMemoryDB

val inMemoryDB: Boolean

isDebug

val isDebug: Boolean

jmxPolicy

val jmxPolicy: JmxPolicy

networkMapAvailability

lateinit var networkMapAvailability: <Error class: unknown class><DriverDSLImpl.LocalNetworkMap?>

Future which completes when the network map infrastructure is available, whether a local one or one from the CZ. This future acts as a gate to prevent nodes from starting too early. The value of the future is a LocalNetworkMap object, which is null if the network map is being provided by the CZ.

networkParameters

val networkParameters: <Error class: unknown class>

networkVisibilityController

val networkVisibilityController: NetworkVisibilityController

notaryCustomOverrides

val notaryCustomOverrides: Map<String, Any?>

notaryHandles

open override val notaryHandles: List<NotaryHandle>

Returns a list of NotaryHandles matching the list of NotarySpecs passed into driver.

notaryHandleTimeout

val notaryHandleTimeout: Duration

notarySpecs

val notarySpecs: List<NotarySpec>

portAllocation

val portAllocation: PortAllocation

premigrateH2Database

val premigrateH2Database: Boolean = true

shutdownManager

open override val shutdownManager: ShutdownManager

startNodesInProcess

val startNodesInProcess: Boolean

systemProperties

val systemProperties: Map<String, String>

useTestClock

val useTestClock: Boolean

waitForAllNodesToFinish

val waitForAllNodesToFinish: Boolean

Functions

assertUncompletedCheckpoints

fun DriverDSL.assertUncompletedCheckpoints(name: <Error class: unknown class>, expected: Long)

baseDirectory

open override fun baseDirectory(nodeName: <Error class: unknown class>): Path

Returns the base directory for a node with the given CordaX500Name. This method is useful if the base directory is needed before the node is started.

nextPort

open fun nextPort(): Int

Returns the next port to use when instantiating test processes that must not conflict on the same machine

pollUntilNonNull

open override fun <A> pollUntilNonNull(pollName: String, pollInterval: Duration, warnCount: Int, check: () -> A?): <Error class: unknown class><A>

Polls a function until it returns a non-null value. Note that there is no timeout on the polling.

pollUntilTrue

open fun pollUntilTrue(pollName: String, pollInterval: Duration = DEFAULT_POLL_INTERVAL, warnCount: Int = DEFAULT_WARN_COUNT, check: () -> Boolean): <Error class: unknown class><Unit>

Polls the given function until it returns true.

shutdown

open override fun shutdown()

start

open override fun start()

startNode

open fun startNode(): <Error class: unknown class><NodeHandle>

Start a node using the default values of NodeParameters.

open fun startNode(defaultParameters: NodeParameters = NodeParameters(), providedName: <Error class: unknown class>? = defaultParameters.providedName, rpcUsers: List<User> = defaultParameters.rpcUsers, verifierType: VerifierType = defaultParameters.verifierType, customOverrides: Map<String, Any?> = defaultParameters.customOverrides, startInSameProcess: Boolean? = defaultParameters.startInSameProcess, maximumHeapSize: String = defaultParameters.maximumHeapSize): <Error class: unknown class><NodeHandle>

Start a node.

open override fun startNode(parameters: NodeParameters): <Error class: unknown class><NodeHandle>

Start a node using the parameter values of the given NodeParameters.

open override fun startNode(parameters: NodeParameters, bytemanPort: Int?): <Error class: unknown class><NodeHandle>

startNode

fun DriverDSL.startNode(providedName: <Error class: unknown class>, devMode: Boolean, parameters: NodeParameters = NodeParameters()): <Error class: unknown class><NodeHandle>

startWebserver

open fun startWebserver(handle: NodeHandle): <Error class: unknown class><WebserverHandle>

Call startWebserver with a default maximumHeapSize.

open override fun startWebserver(handle: NodeHandle, maximumHeapSize: String): <Error class: unknown class><WebserverHandle>

Starts a web server for a node

withDatabaseConnection

fun <T> DriverDSL.withDatabaseConnection(name: <Error class: unknown class>, block: (Connection) -> T): T