diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 356d4cafaab..e1cb19e8bea 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -127,6 +127,8 @@ + + diff --git a/build.gradle b/build.gradle index a960fb5c55d..16451c70592 100644 --- a/build.gradle +++ b/build.gradle @@ -172,6 +172,7 @@ allprojects { jvmTarget = "1.8" javaParameters = true // Useful for reflection. freeCompilerArgs = ['-Xjvm-default=compatibility'] + allWarningsAsErrors = true } } diff --git a/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt b/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt index ab405af19bd..8f5c1fe4ddb 100644 --- a/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt +++ b/client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt @@ -3,7 +3,6 @@ package net.corda.client.jfx import net.corda.client.jfx.model.NodeMonitorModel import net.corda.client.jfx.model.ProgressTrackingEvent import net.corda.core.context.InvocationOrigin -import net.corda.core.contracts.Amount import net.corda.core.contracts.ContractState import net.corda.core.crypto.isFulfilledBy import net.corda.core.crypto.keys @@ -22,12 +21,9 @@ import net.corda.core.transactions.SignedTransaction import net.corda.core.utilities.OpaqueBytes import net.corda.core.utilities.getOrThrow import net.corda.finance.DOLLARS -import net.corda.finance.USD -import net.corda.finance.flows.CashExitFlow import net.corda.finance.flows.CashIssueFlow import net.corda.finance.flows.CashPaymentFlow -import net.corda.node.services.Permissions.Companion.invokeRpc -import net.corda.node.services.Permissions.Companion.startFlow +import net.corda.node.services.Permissions.Companion.all import net.corda.testing.core.* import net.corda.testing.driver.DriverParameters import net.corda.testing.driver.driver @@ -54,18 +50,7 @@ class NodeMonitorModelTest { private fun setup(runTest: () -> Unit) { driver(DriverParameters(extraCordappPackagesToScan = listOf("net.corda.finance"))) { - val cashUser = User("user1", "test", permissions = setOf( - startFlow(), - startFlow(), - startFlow(), - invokeRpc(CordaRPCOps::notaryIdentities), - invokeRpc("vaultTrackBy"), - invokeRpc("vaultQueryBy"), - invokeRpc(CordaRPCOps::internalVerifiedTransactionsFeed), - invokeRpc(CordaRPCOps::stateMachineRecordedTransactionMappingFeed), - invokeRpc(CordaRPCOps::stateMachinesFeed), - invokeRpc(CordaRPCOps::networkMapFeed)) - ) + val cashUser = User("user1", "test", permissions = setOf(all())) val aliceNodeHandle = startNode(providedName = ALICE_NAME, rpcUsers = listOf(cashUser)).getOrThrow() aliceNode = aliceNodeHandle.nodeInfo newNode = { nodeName -> startNode(providedName = nodeName).getOrThrow().nodeInfo } @@ -114,11 +99,7 @@ class NodeMonitorModelTest { @Test fun `cash issue works end to end`() = setup { - rpc.startFlow(::CashIssueFlow, - Amount(100, USD), - OpaqueBytes(ByteArray(1, { 1 })), - notaryParty - ) + rpc.startFlow(::CashIssueFlow, 100.DOLLARS, OpaqueBytes.of(1), notaryParty) vaultUpdates.expectEvents(isStrict = false) { sequence( diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt index 26d9bf09d50..eb8e78898f3 100644 --- a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt +++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt @@ -101,12 +101,12 @@ class NodeMonitorModel : AutoCloseable { * TODO provide an unsubscribe mechanism */ fun register(nodeHostAndPort: NetworkHostAndPort, username: String, password: String) { - // `retryableStateMachineUpdatesSubject` will change it's upstream subscriber in case of RPC connection failure, this `Observable` should // never produce an error. // `stateMachineUpdatesSubject` will stay firmly subscribed to `retryableStateMachineUpdatesSubject` retryableStateMachineUpdatesSubject.subscribe(stateMachineUpdatesSubject) + @Suppress("DEPRECATION") // Proxy may change during re-connect, ensure that subject wiring accurately reacts to this activity. proxyObservable.addListener { _, _, wrapper -> if (wrapper != null) { diff --git a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/TransactionDataModel.kt b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/TransactionDataModel.kt index 900ed8fd42e..7d208748c8b 100644 --- a/client/jfx/src/main/kotlin/net/corda/client/jfx/model/TransactionDataModel.kt +++ b/client/jfx/src/main/kotlin/net/corda/client/jfx/model/TransactionDataModel.kt @@ -48,7 +48,7 @@ data class PartiallyResolvedTransaction( return PartiallyResolvedTransaction( transaction = transaction, inputs = transaction.inputs.map { stateRef -> - val tx = inputTransactions.get(stateRef) + val tx = inputTransactions[stateRef] if (tx == null) { InputResolution.Unresolved(stateRef) } else { @@ -64,7 +64,7 @@ data class PartiallyResolvedTransaction( val outputCount = transaction.coreTransaction.inputs.size val stateRefs = (0 until outputCount).map { StateRef(transaction.id, it) } stateRefs.map { stateRef -> - val tx = inputTransactions.get(stateRef) + val tx = inputTransactions[stateRef] if (tx == null) { OutputResolution.Unresolved(stateRef) } else { @@ -84,6 +84,7 @@ class TransactionDataModel { private val collectedTransactions = transactions.recordInSequence().distinctBy { it.id } private val rpcProxy by observableValue(NodeMonitorModel::proxyObservable) + @Suppress("DEPRECATION") val partiallyResolvedTransactions = collectedTransactions.map { PartiallyResolvedTransaction.fromSignedTransaction(it, it.inputs.map { stateRef -> diff --git a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/FlowsExecutionModeRpcTest.kt b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/FlowsExecutionModeRpcTest.kt index 98bb3223237..2d9cde9b38e 100644 --- a/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/FlowsExecutionModeRpcTest.kt +++ b/client/rpc/src/integration-test/kotlin/net/corda/client/rpc/FlowsExecutionModeRpcTest.kt @@ -54,14 +54,12 @@ class FlowsExecutionModeTests : NodeBasedTest(listOf("net.corda.finance.contract @Before fun setup() { - node = startNode(ALICE_NAME, rpcUsers = listOf(rpcUser)) - client = CordaRPCClient(node.internals.configuration.rpcOptions.address!!) + client = CordaRPCClient(node.internals.configuration.rpcOptions.address) } @Test fun `flows draining mode can be enabled and queried`() { - asALoggerUser { rpcOps -> val newValue = true rpcOps.setFlowsDrainingModeEnabled(true) @@ -74,7 +72,6 @@ class FlowsExecutionModeTests : NodeBasedTest(listOf("net.corda.finance.contract @Test fun `flows draining mode can be disabled and queried`() { - asALoggerUser { rpcOps -> rpcOps.setFlowsDrainingModeEnabled(true) val newValue = false @@ -88,7 +85,6 @@ class FlowsExecutionModeTests : NodeBasedTest(listOf("net.corda.finance.contract @Test fun `node starts with flows draining mode disabled`() { - asALoggerUser { rpcOps -> val defaultStartingMode = rpcOps.isFlowsDrainingModeEnabled() @@ -97,14 +93,12 @@ class FlowsExecutionModeTests : NodeBasedTest(listOf("net.corda.finance.contract } private fun login(username: String, password: String, externalTrace: Trace? = null, impersonatedActor: Actor? = null): CordaRPCConnection { - return client.start(username, password, externalTrace, impersonatedActor) } private fun asALoggerUser(action: (CordaRPCOps) -> Unit) { - login(rpcUser.username, rpcUser.password).use { action(it.proxy) } } -} \ No newline at end of file +} diff --git a/core/src/main/kotlin/net/corda/core/node/services/KeyManagementService.kt b/core/src/main/kotlin/net/corda/core/node/services/KeyManagementService.kt index 7b4801b1128..14ba9b21c01 100644 --- a/core/src/main/kotlin/net/corda/core/node/services/KeyManagementService.kt +++ b/core/src/main/kotlin/net/corda/core/node/services/KeyManagementService.kt @@ -2,11 +2,15 @@ package net.corda.core.node.services import co.paralleluniverse.fibers.Suspendable import net.corda.core.DoNotImplement +import net.corda.core.crypto.CompositeKey import net.corda.core.crypto.DigitalSignature import net.corda.core.crypto.SignableData import net.corda.core.crypto.TransactionSignature import net.corda.core.identity.PartyAndCertificate +import java.security.KeyPair +import java.security.PrivateKey import java.security.PublicKey +import java.security.cert.X509Certificate /** * The KMS is responsible for storing and using private keys to sign things. An implementation of this may, for example, diff --git a/core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt b/core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt index 6e6e7ea34f7..a4f7391f404 100644 --- a/core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt +++ b/core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt @@ -122,7 +122,7 @@ object MappedSchemaValidator { fieldsFromOtherMappedSchema(schema) + methodsFromOtherMappedSchema(schema) /** Returns true if [javax.persistence] annotation expect [javax.persistence.Transient] is found. */ - private inline fun hasJpaAnnotation(annotations: Array) = + private fun hasJpaAnnotation(annotations: Array) = annotations.any { annotation -> annotation.toString().startsWith("@javax.persistence.") && annotation !is javax.persistence.Transient } class SchemaCrossReferenceReport(private val schema: String, private val entity: String, private val referencedSchema: String, diff --git a/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt index 6f4a63b8988..e3697f9d00a 100644 --- a/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt +++ b/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt @@ -48,7 +48,7 @@ class WireTransaction(componentGroups: List, val privacySalt: Pr @DeleteForDJVM constructor(componentGroups: List) : this(componentGroups, PrivacySalt()) - @Deprecated("Required only in some unit-tests and for backwards compatibility purposes.", ReplaceWith("WireTransaction(val componentGroups: List, override val privacySalt: PrivacySalt)"), DeprecationLevel.WARNING) + @Deprecated("Required only for backwards compatibility purposes.", ReplaceWith("WireTransaction(val componentGroups: List, override val privacySalt: PrivacySalt)"), DeprecationLevel.WARNING) @DeleteForDJVM constructor(inputs: List, attachments: List, diff --git a/core/src/test/kotlin/net/corda/core/contracts/ContractsDSLTests.kt b/core/src/test/kotlin/net/corda/core/contracts/ContractsDSLTests.kt index bfb54e5e78f..57320d7eb9f 100644 --- a/core/src/test/kotlin/net/corda/core/contracts/ContractsDSLTests.kt +++ b/core/src/test/kotlin/net/corda/core/contracts/ContractsDSLTests.kt @@ -31,7 +31,8 @@ class ContractsDSLTests { } @RunWith(Parameterized::class) - class RequireSingleCommandTests(private val testFunction: (Collection>) -> CommandWithParties, description: String) { + class RequireSingleCommandTests(private val testFunction: (Collection>) -> CommandWithParties, + @Suppress("UNUSED_PARAMETER") description: String) { companion object { @JvmStatic @Parameterized.Parameters(name = "{1}") @@ -64,7 +65,8 @@ class ContractsDSLTests { } @RunWith(Parameterized::class) - class SelectWithSingleInputsTests(private val testFunction: (Collection>, PublicKey?, AbstractParty?) -> Iterable>, description: String) { + class SelectWithSingleInputsTests(private val testFunction: (Collection>, PublicKey?, AbstractParty?) -> Iterable>, + @Suppress("UNUSED_PARAMETER") description: String) { companion object { @JvmStatic @Parameterized.Parameters(name = "{1}") @@ -112,7 +114,8 @@ class ContractsDSLTests { } @RunWith(Parameterized::class) - class SelectWithMultipleInputsTests(private val testFunction: (Collection>, Collection?, Collection?) -> Iterable>, description: String) { + class SelectWithMultipleInputsTests(private val testFunction: (Collection>, Collection?, Collection?) -> Iterable>, + @Suppress("UNUSED_PARAMETER") description: String) { companion object { @JvmStatic @Parameterized.Parameters(name = "{1}") diff --git a/core/src/test/kotlin/net/corda/core/crypto/PartialMerkleTreeTest.kt b/core/src/test/kotlin/net/corda/core/crypto/PartialMerkleTreeTest.kt index 3c7275a819f..70648b07be8 100644 --- a/core/src/test/kotlin/net/corda/core/crypto/PartialMerkleTreeTest.kt +++ b/core/src/test/kotlin/net/corda/core/crypto/PartialMerkleTreeTest.kt @@ -20,6 +20,7 @@ import net.corda.testing.dsl.LedgerDSL import net.corda.testing.dsl.TestLedgerDSLInterpreter import net.corda.testing.dsl.TestTransactionDSLInterpreter import net.corda.testing.internal.TEST_TX_TIME +import net.corda.testing.internal.createWireTransaction import net.corda.testing.internal.rigorousMock import net.corda.testing.node.MockServices import net.corda.testing.node.ledger @@ -264,7 +265,7 @@ class PartialMerkleTreeTest { timeWindow: TimeWindow? = null, attachments: List = emptyList() ): WireTransaction { - return WireTransaction( + return createWireTransaction( inputs = testTx.inputs, attachments = attachments, outputs = testTx.outputs, diff --git a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt index 06f3907b215..6029897303f 100644 --- a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt +++ b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt @@ -57,7 +57,7 @@ class AttachmentTests { bobNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java) // Insert an attachment into node zero's store directly. val id = aliceNode.database.transaction { - aliceNode.attachments.importAttachment(fakeAttachment().inputStream()) + aliceNode.attachments.importAttachment(fakeAttachment().inputStream(), "test", null) } // Get node one to run a flow to fetch it and insert it. @@ -110,7 +110,7 @@ class AttachmentTests { val attachment = fakeAttachment() // Insert an attachment into node zero's store directly. val id = aliceNode.database.transaction { - aliceNode.attachments.importAttachment(attachment.inputStream()) + aliceNode.attachments.importAttachment(attachment.inputStream(), "test", null) } // Corrupt its store. diff --git a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt index b6529591562..8172bbc9bea 100644 --- a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt +++ b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt @@ -146,7 +146,7 @@ class ResolveTransactionsFlowTest { } // TODO: this operation should not require an explicit transaction val id = megaCorpNode.transaction { - megaCorpNode.services.attachments.importAttachment(makeJar()) + megaCorpNode.services.attachments.importAttachment(makeJar(), "test", null) } val stx2 = makeTransactions(withAttachment = id).second val p = TestFlow(stx2, megaCorp) @@ -201,6 +201,7 @@ class ResolveTransactionsFlowTest { } } + @Suppress("unused") @InitiatedBy(TestFlow::class) private class TestResponseFlow(val otherSideSession: FlowSession) : FlowLogic() { @Suspendable diff --git a/core/src/test/kotlin/net/corda/core/internal/TopologicalSortTest.kt b/core/src/test/kotlin/net/corda/core/internal/TopologicalSortTest.kt index 1c4f76cad90..6237a1a0194 100644 --- a/core/src/test/kotlin/net/corda/core/internal/TopologicalSortTest.kt +++ b/core/src/test/kotlin/net/corda/core/internal/TopologicalSortTest.kt @@ -21,10 +21,10 @@ import rx.Observable import java.util.* class TopologicalSortTest { - class DummyTransaction( + class DummyTransaction constructor( override val id: SecureHash, override val inputs: List, - val numberOfOutputs: Int, + @Suppress("CanBeParameter") private val numberOfOutputs: Int, override val notary: Party ) : CoreTransaction() { override val outputs: List> = (1..numberOfOutputs).map { @@ -78,7 +78,7 @@ class TopologicalSortTest { } // Swap two random items - transactions.combine(Generator.intRange(0, N - 1), Generator.intRange(0, N - 2)) { txs, i, j -> + transactions.combine(Generator.intRange(0, N - 1), Generator.intRange(0, N - 2)) { txs, i, _ -> val k = 0 // if (i == j) i + 1 else j val tmp = txs[i] txs[i] = txs[k] @@ -94,7 +94,7 @@ class TopologicalSortTest { } } - fun checkTopologicallyOrdered(txs: List) { + private fun checkTopologicallyOrdered(txs: List) { val outputs = HashSet() for (tx in txs) { if (!outputs.containsAll(tx.inputs)) { diff --git a/core/src/test/kotlin/net/corda/core/transactions/TransactionTests.kt b/core/src/test/kotlin/net/corda/core/transactions/TransactionTests.kt index cbda60638f5..3f6f40bf513 100644 --- a/core/src/test/kotlin/net/corda/core/transactions/TransactionTests.kt +++ b/core/src/test/kotlin/net/corda/core/transactions/TransactionTests.kt @@ -8,6 +8,7 @@ import net.corda.core.crypto.CompositeKey import net.corda.core.identity.Party import net.corda.testing.contracts.DummyContract import net.corda.testing.core.* +import net.corda.testing.internal.createWireTransaction import net.corda.testing.internal.rigorousMock import org.junit.Rule import org.junit.Test @@ -53,7 +54,7 @@ class TransactionTests { val cpub = ck.public val c1 = CompositeKey.Builder().addKeys(apub, bpub).build(2) val compKey = CompositeKey.Builder().addKeys(c1, cpub).build(1) - val wtx = WireTransaction( + val wtx = createWireTransaction( inputs = listOf(StateRef(SecureHash.randomSHA256(), 0)), attachments = emptyList(), outputs = emptyList(), @@ -79,7 +80,7 @@ class TransactionTests { @Test fun `signed transaction missing signatures`() { - val wtx = WireTransaction( + val wtx = createWireTransaction( inputs = listOf(StateRef(SecureHash.randomSHA256(), 0)), attachments = emptyList(), outputs = emptyList(), @@ -119,8 +120,8 @@ class TransactionTests { }, DummyContract.PROGRAM_ID)) val id = SecureHash.randomSHA256() val timeWindow: TimeWindow? = null - val privacySalt: PrivacySalt = PrivacySalt() - val transaction: LedgerTransaction = LedgerTransaction( + val privacySalt = PrivacySalt() + val transaction = LedgerTransaction( inputs, outputs, commands, @@ -137,7 +138,7 @@ class TransactionTests { @Test fun `transaction cannot have duplicate inputs`() { val stateRef = StateRef(SecureHash.randomSHA256(), 0) - fun buildTransaction() = WireTransaction( + fun buildTransaction() = createWireTransaction( inputs = listOf(stateRef, stateRef), attachments = emptyList(), outputs = emptyList(), @@ -160,7 +161,7 @@ class TransactionTests { val attachments = emptyList() val id = SecureHash.randomSHA256() val timeWindow: TimeWindow? = null - val privacySalt: PrivacySalt = PrivacySalt() + val privacySalt = PrivacySalt() fun buildTransaction() = LedgerTransaction( inputs, outputs, @@ -178,7 +179,7 @@ class TransactionTests { @Test fun `transactions with identical contents must have different ids`() { val outputState = TransactionState(DummyContract.SingleOwnerState(0, ALICE), DummyContract.PROGRAM_ID, DUMMY_NOTARY) - fun buildTransaction() = WireTransaction( + fun buildTransaction() = createWireTransaction( inputs = emptyList(), attachments = emptyList(), outputs = listOf(outputState), diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt index 8cc5f3ab61b..093b4bc8d0c 100644 --- a/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt +++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt @@ -40,6 +40,7 @@ enum class PrintOrVisualise { Visualise } +@Suppress("DEPRECATION") fun main(args: Array) { require(args.isNotEmpty()) { "Usage: [Print|Visualise]" } val printOrVisualise = PrintOrVisualise.valueOf(args[0]) @@ -99,6 +100,7 @@ fun main(args: Array) { } } // END 5 + Unit } } diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt index 40f74879469..c2b20467246 100644 --- a/docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt +++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt @@ -1,4 +1,4 @@ -@file:Suppress("UNUSED_VARIABLE", "unused") +@file:Suppress("UNUSED_VARIABLE", "unused", "DEPRECATION") package net.corda.docs diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt index e6826fa2136..8e94e82b32f 100644 --- a/docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt +++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt @@ -1,3 +1,5 @@ +@file:Suppress("DEPRECATION") + package net.corda.docs import co.paralleluniverse.fibers.Suspendable diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt index 0635c136f37..d4f67c02a0c 100644 --- a/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt +++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt @@ -1,3 +1,5 @@ +@file:Suppress("UNUSED_VARIABLE") + package net.corda.docs.tutorial.tearoffs import net.corda.core.contracts.Command @@ -42,4 +44,4 @@ fun main(args: Array) { } catch (e: FilteredTransactionVerificationException) { throw MerkleTreeException("Rate Fix Oracle: Couldn't verify partial Merkle tree.") } -} \ No newline at end of file +} diff --git a/experimental/behave/src/scenario/kotlin/net/corda/behave/scenarios/helpers/Substeps.kt b/experimental/behave/src/scenario/kotlin/net/corda/behave/scenarios/helpers/Substeps.kt index 71f3dca79bb..6af97417eb9 100644 --- a/experimental/behave/src/scenario/kotlin/net/corda/behave/scenarios/helpers/Substeps.kt +++ b/experimental/behave/src/scenario/kotlin/net/corda/behave/scenarios/helpers/Substeps.kt @@ -2,22 +2,21 @@ package net.corda.behave.scenarios.helpers import net.corda.behave.scenarios.ScenarioState import net.corda.core.messaging.CordaRPCOps -import net.corda.core.utilities.contextLogger +import org.slf4j.Logger +import org.slf4j.LoggerFactory abstract class Substeps(protected val state: ScenarioState) { + protected val log: Logger = LoggerFactory.getLogger(javaClass) - protected val log = contextLogger() - - protected fun withNetwork(action: ScenarioState.() -> Unit) = - state.withNetwork(action) + protected fun withNetwork(action: ScenarioState.() -> Unit) = state.withNetwork(action) protected fun withClient(nodeName: String, action: ScenarioState.(CordaRPCOps) -> T): T { - return state.withClient(nodeName, { - return@withClient try { + return state.withClient(nodeName) { + try { action(state, it) } catch (ex: Exception) { - state.error(ex.message ?: "Failed to execute RPC call") + state.error(ex.message ?: "Failed to execute RPC call") } - }) + } } -} \ No newline at end of file +} diff --git a/experimental/behave/src/test/kotlin/net/corda/behave/process/CommandTests.kt b/experimental/behave/src/test/kotlin/net/corda/behave/process/CommandTests.kt index 0d560b4b743..747c82cdaed 100644 --- a/experimental/behave/src/test/kotlin/net/corda/behave/process/CommandTests.kt +++ b/experimental/behave/src/test/kotlin/net/corda/behave/process/CommandTests.kt @@ -5,7 +5,6 @@ import org.junit.Test import rx.observers.TestSubscriber class CommandTests { - @Test fun `successful command returns zero`() { val exitCode = Command(listOf("ls", "/")).run() @@ -21,7 +20,7 @@ class CommandTests { @Test fun `output stream for command can be observed`() { val subscriber = TestSubscriber() - val exitCode = Command(listOf("ls", "/")).use(subscriber) { _, output -> + val exitCode = Command(listOf("ls", "/")).use(subscriber) { _, _ -> subscriber.awaitTerminalEvent() subscriber.assertCompleted() subscriber.assertNoErrors() diff --git a/experimental/kryo-hook/build.gradle b/experimental/kryo-hook/build.gradle index 040b2e5f805..ab36a754b62 100644 --- a/experimental/kryo-hook/build.gradle +++ b/experimental/kryo-hook/build.gradle @@ -3,7 +3,6 @@ ext { } apply plugin: 'kotlin' -apply plugin: 'kotlin-kapt' apply plugin: 'idea' description 'A javaagent to allow hooking into Kryo' diff --git a/experimental/quasar-hook/build.gradle b/experimental/quasar-hook/build.gradle index c2387079a83..dfe49fa9703 100644 --- a/experimental/quasar-hook/build.gradle +++ b/experimental/quasar-hook/build.gradle @@ -3,7 +3,6 @@ ext { } apply plugin: 'kotlin' -apply plugin: 'kotlin-kapt' apply plugin: 'idea' description 'A javaagent to allow hooking into the instrumentation by Quasar' diff --git a/experimental/src/main/kotlin/net/corda/finance/contracts/universal/PrettyPrint.kt b/experimental/src/main/kotlin/net/corda/finance/contracts/universal/PrettyPrint.kt index 3632bfa6a72..9c043ffd483 100644 --- a/experimental/src/main/kotlin/net/corda/finance/contracts/universal/PrettyPrint.kt +++ b/experimental/src/main/kotlin/net/corda/finance/contracts/universal/PrettyPrint.kt @@ -2,12 +2,12 @@ package net.corda.finance.contracts.universal import net.corda.core.crypto.toStringShort import net.corda.core.identity.Party +import net.corda.core.internal.uncheckedCast import java.math.BigDecimal import java.security.PublicKey import java.time.Instant private class PrettyPrint(arr : Arrangement) { - val parties = involvedParties(arr) private val sb = StringBuilder() @@ -16,21 +16,21 @@ private class PrettyPrint(arr : Arrangement) { private var atStart = true private fun print(msg: String) { if (atStart) - repeat(indentLevel, { sb.append(' ') }) + repeat(indentLevel) { sb.append(' ') } sb.append(msg) atStart = false } private fun println(message: Any?) { if (atStart) - repeat(indentLevel, { sb.append(' ') }) + repeat(indentLevel) { sb.append(' ') } sb.appendln(message) atStart = true } private fun print(msg: Any?) { if (atStart) - repeat(indentLevel, { sb.append(' ') }) + repeat(indentLevel) { sb.append(' ') } sb.append(msg) atStart = false } @@ -45,8 +45,7 @@ private class PrettyPrint(arr : Arrangement) { val partyMap = mutableMapOf() val usedPartyNames = mutableSetOf() - fun createPartyName(party : Party) : String - { + fun createPartyName(party : Party): String { val parts = party.name.organisation.toLowerCase().split(' ') var camelName = parts.drop(1).fold(parts.first()) { @@ -69,38 +68,38 @@ private class PrettyPrint(arr : Arrangement) { } } - fun prettyPrint(per: Perceivable, x: Boolean? = null) { + fun prettyPrintBoolean(per: Perceivable) { when (per) { is Const -> print("\"${per.value}\"") is PerceivableOr -> { - prettyPrint(per.left) + prettyPrintBoolean(per.left) print(" or ") - prettyPrint(per.right) + prettyPrintBoolean(per.right) } is PerceivableAnd -> { - prettyPrint(per.left) + prettyPrintBoolean(per.left) print(" and ") - prettyPrint(per.right) + prettyPrintBoolean(per.right) } is TimePerceivable -> { when (per.cmp) { Comparison.GT, Comparison.GTE -> { print("after(") - prettyPrint(per.instant) + prettyPrintInstant(per.instant) print(")") } Comparison.LT, Comparison.LTE -> { print("before(") - prettyPrint(per.instant) + prettyPrintInstant(per.instant) print(")") } } } is PerceivableComparison<*> -> { when (per.type) { - BigDecimal::class.java -> prettyPrint(per.left as Perceivable) - Instant::class.java -> prettyPrint(per.left as Perceivable) - Boolean::class.java -> prettyPrint(per.left as Perceivable) + BigDecimal::class.java -> prettyPrintBigDecimal(uncheckedCast(per.left)) + Instant::class.java -> prettyPrintInstant(uncheckedCast(per.left)) + Boolean::class.java -> prettyPrintBoolean(uncheckedCast(per.left)) } when (per.cmp) { Comparison.GT -> print(" > ") @@ -109,9 +108,9 @@ private class PrettyPrint(arr : Arrangement) { Comparison.LTE -> print(" <= ") } when (per.type) { - BigDecimal::class.java -> prettyPrint(per.right as Perceivable) - Instant::class.java -> prettyPrint(per.right as Perceivable) - Boolean::class.java -> prettyPrint(per.right as Perceivable) + BigDecimal::class.java -> prettyPrintBigDecimal(uncheckedCast(per.right)) + Instant::class.java -> prettyPrintInstant(uncheckedCast(per.right)) + Boolean::class.java -> prettyPrintBoolean(uncheckedCast(per.right)) } } is TerminalEvent -> print("TerminalEvent(${partyMap[per.reference.owningKey]}, \"${per.source}\")") @@ -120,7 +119,7 @@ private class PrettyPrint(arr : Arrangement) { } } - fun prettyPrint(per: Perceivable, x: Instant? = null) { + fun prettyPrintInstant(per: Perceivable) { when (per) { is Const -> print("\"${per.value}\"") is StartDate -> print("startDate") @@ -129,34 +128,33 @@ private class PrettyPrint(arr : Arrangement) { } } - fun prettyPrint(per: Perceivable, x: BigDecimal? = null) { + fun prettyPrintBigDecimal(per: Perceivable) { when (per) { is PerceivableOperation -> { - prettyPrint(per.left) + prettyPrintBigDecimal(per.left) when (per.op) { Operation.PLUS -> print(" + ") Operation.MINUS -> print(" - ") Operation.DIV -> print(" / ") Operation.TIMES -> print(" * ") - else -> print(per.op) } - prettyPrint(per.right) + prettyPrintBigDecimal(per.right) } is UnaryPlus -> { print("(") - prettyPrint(per.arg) + prettyPrintBigDecimal(per.arg) print(".).plus()") } is Const -> print(per.value) is Interest -> { print("Interest(") - prettyPrint(per.amount) + prettyPrintBigDecimal(per.amount) print(", \"${per.dayCountConvention}\", ") - prettyPrint(per.amount) + prettyPrintBigDecimal(per.amount) print(", ") - prettyPrint(per.start) + prettyPrintInstant(per.start) print(", ") - prettyPrint(per.end) + prettyPrintInstant(per.end) print(")") } is CurrencyCross -> print("${per.foreign}/${per.domestic}") @@ -165,7 +163,6 @@ private class PrettyPrint(arr : Arrangement) { } fun prettyPrint(arr: Arrangement) { - when (arr) { is Zero -> println("zero") is RollOut -> { @@ -183,7 +180,7 @@ private class PrettyPrint(arr : Arrangement) { is Continuation -> println("next()") is Obligation -> { print("${partyMap[arr.from.owningKey]}.gives( ${partyMap[arr.to.owningKey]}, ") - prettyPrint(arr.amount) + prettyPrintBigDecimal(arr.amount) println(", ${arr.currency})") } is Actions -> { @@ -191,7 +188,7 @@ private class PrettyPrint(arr : Arrangement) { indent { for ((name, condition, arrangement) in arr.actions) { print("\"$name\".givenThat(") - prettyPrint(condition) + prettyPrintBoolean(condition) println(") {") indent { prettyPrint(arrangement) diff --git a/experimental/src/main/kotlin/net/corda/finance/contracts/universal/UniversalContract.kt b/experimental/src/main/kotlin/net/corda/finance/contracts/universal/UniversalContract.kt index ef37f3114b0..f73805b9672 100644 --- a/experimental/src/main/kotlin/net/corda/finance/contracts/universal/UniversalContract.kt +++ b/experimental/src/main/kotlin/net/corda/finance/contracts/universal/UniversalContract.kt @@ -36,46 +36,45 @@ class UniversalContract : Contract { class Split(val ratio: BigDecimal) : Commands } - fun eval(@Suppress("UNUSED_PARAMETER") tx: LedgerTransaction, expr: Perceivable): Instant? = when (expr) { + fun evalInstant(expr: Perceivable): Instant? = when (expr) { is Const -> expr.value is StartDate -> null is EndDate -> null else -> throw Error("Unable to evaluate") } - fun eval(tx: LedgerTransaction, expr: Perceivable): Boolean = when (expr) { - is PerceivableAnd -> eval(tx, expr.left) && eval(tx, expr.right) - is PerceivableOr -> eval(tx, expr.left) || eval(tx, expr.right) + fun evalBoolean(tx: LedgerTransaction, expr: Perceivable): Boolean = when (expr) { + is PerceivableAnd -> evalBoolean(tx, expr.left) && evalBoolean(tx, expr.right) + is PerceivableOr -> evalBoolean(tx, expr.left) || evalBoolean(tx, expr.right) is Const -> expr.value is TimePerceivable -> when (expr.cmp) { - Comparison.LTE -> tx.timeWindow!!.fromTime!! <= eval(tx, expr.instant) - Comparison.GTE -> tx.timeWindow!!.untilTime!! >= eval(tx, expr.instant) + Comparison.LTE -> tx.timeWindow!!.fromTime!! <= evalInstant(expr.instant) + Comparison.GTE -> tx.timeWindow!!.untilTime!! >= evalInstant(expr.instant) else -> throw NotImplementedError("eval special") } is ActorPerceivable -> tx.commands.single().signers.contains(expr.actor.owningKey) else -> throw NotImplementedError("eval - Boolean - " + expr.javaClass.name) } - fun eval(tx: LedgerTransaction, expr: Perceivable): BigDecimal = + fun evalBigDecimal(tx: LedgerTransaction, expr: Perceivable): BigDecimal = when (expr) { is Const -> expr.value is UnaryPlus -> { - val x = eval(tx, expr.arg) + val x = evalBigDecimal(tx, expr.arg) if (x > BigDecimal.ZERO) x else BigDecimal.ZERO } is PerceivableOperation -> { - val l = eval(tx, expr.left) - val r = eval(tx, expr.right) + val l = evalBigDecimal(tx, expr.left) + val r = evalBigDecimal(tx, expr.right) when (expr.op) { Operation.DIV -> l / r Operation.MINUS -> l - r Operation.PLUS -> l + r Operation.TIMES -> l * r - else -> throw NotImplementedError("eval - amount - operation " + expr.op) } } is Fixing -> { @@ -83,8 +82,8 @@ class UniversalContract : Contract { 0.0.bd } is Interest -> { - val a = eval(tx, expr.amount) - val i = eval(tx, expr.interest) + val a = evalBigDecimal(tx, expr.amount) + val i = evalBigDecimal(tx, expr.interest) //TODO @@ -95,7 +94,7 @@ class UniversalContract : Contract { fun validateImmediateTransfers(tx: LedgerTransaction, arrangement: Arrangement): Arrangement = when (arrangement) { is Obligation -> { - val amount = eval(tx, arrangement.amount) + val amount = evalBigDecimal(tx, arrangement.amount) requireThat { "transferred quantity is non-negative" using (amount >= BigDecimal.ZERO) } Obligation(const(amount), arrangement.currency, arrangement.from, arrangement.to) } @@ -210,7 +209,7 @@ class UniversalContract : Contract { "action must have a time-window" using (tx.timeWindow != null) // "action must be authorized" by (cmd.signers.any { action.actors.any { party -> party.owningKey == it } }) // todo perhaps merge these two requirements? - "condition must be met" using (eval(tx, action.condition)) + "condition must be met" using evalBoolean(tx, action.condition) } // verify that any resulting transfers can be resolved @@ -287,7 +286,7 @@ class UniversalContract : Contract { perceivable.dayCountConvention, replaceFixing(tx, perceivable.interest, fixings, unusedFixings), perceivable.start, perceivable.end)) is Fixing -> { - val dt = eval(tx, perceivable.date) + val dt = evalInstant(perceivable.date) if (dt != null && fixings.containsKey(FixOf(perceivable.source, dt.toLocalDate(), perceivable.tenor))) { unusedFixings.remove(FixOf(perceivable.source, dt.toLocalDate(), perceivable.tenor)) uncheckedCast(Const(fixings[FixOf(perceivable.source, dt.toLocalDate(), perceivable.tenor)]!!)) diff --git a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/IRS.kt b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/IRS.kt index 1205a649470..52a85cc5d21 100644 --- a/experimental/src/test/kotlin/net/corda/finance/contracts/universal/IRS.kt +++ b/experimental/src/test/kotlin/net/corda/finance/contracts/universal/IRS.kt @@ -14,13 +14,12 @@ class IRS { @Rule @JvmField val testSerialization = SerializationEnvironmentRule() - val TEST_TX_TIME_1: Instant get() = Instant.parse("2017-09-02T12:00:00.00Z") - val notional = 50.M - val currency = EUR - - val tradeDate: LocalDate = LocalDate.of(2016, 9, 1) + private val testTxTime1: Instant = Instant.parse("2017-09-02T12:00:00.00Z") + private val notional = 50.M + private val currency = EUR + private val tradeDate: LocalDate = LocalDate.of(2016, 9, 1) /* @@ -33,7 +32,7 @@ class IRS { */ - val contractInitial = arrange { + private val contractInitial = arrange { rollOut("2016-09-01".ld, "2018-09-01".ld, Frequency.Quarterly) { actions { (acmeCorp or highStreetBank) may { @@ -52,7 +51,8 @@ class IRS { } } } - val contractAfterFixingFirst = arrange { + + private val contractAfterFixingFirst = arrange { actions { (acmeCorp or highStreetBank) may { val floating = interest(notional, "act/365", 1.0.bd, "2016-09-01", "2016-12-01") @@ -83,15 +83,15 @@ class IRS { rollOut("2016-12-01".ld, "2018-09-01".ld, Frequency.Quarterly) { actions { (acmeCorp or highStreetBank) may { - val floating = interest(notional, "act/365", fix("LIBOR", start, Tenor("3M")), start, end) - val fixed = interest(notional, "act/365", 0.5.bd, start, end) + val nextFloating = interest(notional, "act/365", fix("LIBOR", start, Tenor("3M")), start, end) + val nextFixed = interest(notional, "act/365", 0.5.bd, start, end) "pay floating" anytime { - highStreetBank.owes(acmeCorp, floating - fixed, currency) + highStreetBank.owes(acmeCorp, nextFloating - nextFixed, currency) next() } "pay fixed" anytime { - highStreetBank.owes(acmeCorp, fixed - floating, currency) + highStreetBank.owes(acmeCorp, nextFixed - nextFloating, currency) next() } } @@ -102,7 +102,7 @@ class IRS { } } - val contractAfterExecutionFirst = arrange { + private val contractAfterExecutionFirst = arrange { rollOut("2016-12-01".ld, "2018-09-01".ld, Frequency.Quarterly) { actions { (acmeCorp or highStreetBank) may { @@ -122,19 +122,20 @@ class IRS { } } - val paymentFirst = arrange { highStreetBank.owes(acmeCorp, 250.K, EUR) } + private val paymentFirst = arrange { highStreetBank.owes(acmeCorp, 250.K, EUR) } + + private val stateInitial = UniversalContract.State(listOf(DUMMY_NOTARY), contractInitial) - val stateInitial = UniversalContract.State(listOf(DUMMY_NOTARY), contractInitial) + private val stateAfterFixingFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterFixingFirst) + private val stateAfterExecutionFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterExecutionFirst) - val stateAfterFixingFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterFixingFirst) - val stateAfterExecutionFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterExecutionFirst) + private val statePaymentFirst = UniversalContract.State(listOf(DUMMY_NOTARY), paymentFirst) - val statePaymentFirst = UniversalContract.State(listOf(DUMMY_NOTARY), paymentFirst) @Test fun issue() { transaction { output(UNIVERSAL_PROGRAM_ID, stateInitial) - timeWindow(TEST_TX_TIME_1) + timeWindow(testTxTime1) tweak { command(acmeCorp.owningKey, UniversalContract.Commands.Issue()) @@ -150,7 +151,7 @@ class IRS { transaction { input(UNIVERSAL_PROGRAM_ID, stateInitial) output(UNIVERSAL_PROGRAM_ID, stateAfterFixingFirst) - timeWindow(TEST_TX_TIME_1) + timeWindow(testTxTime1) tweak { command(highStreetBank.owningKey, UniversalContract.Commands.Action("some undefined name")) @@ -190,7 +191,7 @@ class IRS { input(UNIVERSAL_PROGRAM_ID, stateAfterFixingFirst) output(UNIVERSAL_PROGRAM_ID, stateAfterExecutionFirst) output(UNIVERSAL_PROGRAM_ID, statePaymentFirst) - timeWindow(TEST_TX_TIME_1) + timeWindow(testTxTime1) tweak { command(highStreetBank.owningKey, UniversalContract.Commands.Action("some undefined name")) diff --git a/node/src/integration-test/kotlin/net/corda/node/AuthDBTests.kt b/node/src/integration-test/kotlin/net/corda/node/AuthDBTests.kt index 3750d76ef22..7f0972a175b 100644 --- a/node/src/integration-test/kotlin/net/corda/node/AuthDBTests.kt +++ b/node/src/integration-test/kotlin/net/corda/node/AuthDBTests.kt @@ -47,6 +47,7 @@ class AuthDBTests : NodeBasedTest() { fun encFormats() = arrayOf(PasswordEncryption.NONE, PasswordEncryption.SHIRO_1_CRYPT) } + @Suppress("MemberVisibilityCanBePrivate") @Parameterized.Parameter lateinit var passwordEncryption: PasswordEncryption @@ -94,7 +95,7 @@ class AuthDBTests : NodeBasedTest() { ) node = startNode(ALICE_NAME, rpcUsers = emptyList(), configOverrides = securityConfig) - client = CordaRPCClient(node.internals.configuration.rpcOptions.address!!) + client = CordaRPCClient(node.internals.configuration.rpcOptions.address) } @Test @@ -227,9 +228,8 @@ private data class RoleAndPermissions(val role: String, val permissions: List = emptyList(), roleAndPermissions: List = emptyList()) : AutoCloseable { + val jdbcUrl = "jdbc:h2:mem:$name;DB_CLOSE_DELAY=-1" companion object { const val DB_CREATE_SCHEMA = """ @@ -279,11 +279,7 @@ private class UsersDB : AutoCloseable { } } - constructor(name: String, - users: List = emptyList(), - roleAndPermissions: List = emptyList()) { - - jdbcUrl = "jdbc:h2:mem:$name;DB_CLOSE_DELAY=-1" + init { dataSource = DataSourceFactory.createDataSource(Properties().apply { put("dataSourceClassName", "org.h2.jdbcx.JdbcDataSource") put("dataSource.url", jdbcUrl) @@ -291,11 +287,9 @@ private class UsersDB : AutoCloseable { session { it.execute(DB_CREATE_SCHEMA) } - require(users.map { it.username }.toSet().size == users.size) { "Duplicate username in input" } - users.forEach { insert(it) } roleAndPermissions.forEach { insert(it) } } diff --git a/node/src/integration-test/kotlin/net/corda/node/utilities/registration/NodeRegistrationTest.kt b/node/src/integration-test/kotlin/net/corda/node/utilities/registration/NodeRegistrationTest.kt index 1e751a1658e..6f0246660dd 100644 --- a/node/src/integration-test/kotlin/net/corda/node/utilities/registration/NodeRegistrationTest.kt +++ b/node/src/integration-test/kotlin/net/corda/node/utilities/registration/NodeRegistrationTest.kt @@ -20,7 +20,6 @@ import net.corda.testing.core.singleIdentity import net.corda.testing.driver.PortAllocation import net.corda.testing.internal.DEV_ROOT_CA import net.corda.testing.node.NotarySpec -import net.corda.testing.node.internal.CompatibilityZoneParams import net.corda.testing.node.internal.SharedCompatibilityZoneParams import net.corda.testing.node.internal.internalDriver import net.corda.testing.node.internal.network.NetworkMapServer @@ -51,7 +50,6 @@ class NodeRegistrationTest { private val notaryName = CordaX500Name("NotaryService", "Zurich", "CH") private val aliceName = CordaX500Name("Alice", "London", "GB") private val genevieveName = CordaX500Name("Genevieve", "London", "GB") - private val log = contextLogger() } @Rule @@ -69,7 +67,7 @@ class NodeRegistrationTest { pollInterval = 1.seconds, hostAndPort = portAllocation.nextHostAndPort(), myHostNameValue = "localhost", - additionalServices = registrationHandler) + additionalServices = *arrayOf(registrationHandler)) serverHostAndPort = server.start() } diff --git a/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsNodeTest.kt b/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsNodeTest.kt index 8bc80d99b7b..6325ff723e3 100644 --- a/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsNodeTest.kt +++ b/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsNodeTest.kt @@ -68,7 +68,7 @@ class MQSecurityAsNodeTest : P2PMQSecurityTest() { @Test fun `login to a non ssl port as a node user`() { - val attacker = clientTo(alice.internals.configuration.rpcOptions.address!!, sslConfiguration = null) + val attacker = clientTo(alice.internals.configuration.rpcOptions.address, sslConfiguration = null) assertThatExceptionOfType(ActiveMQSecurityException::class.java).isThrownBy { attacker.start(NODE_P2P_USER, NODE_P2P_USER, enableSSL = false) } @@ -76,7 +76,7 @@ class MQSecurityAsNodeTest : P2PMQSecurityTest() { @Test fun `login to a non ssl port as a peer user`() { - val attacker = clientTo(alice.internals.configuration.rpcOptions.address!!, sslConfiguration = null) + val attacker = clientTo(alice.internals.configuration.rpcOptions.address, sslConfiguration = null) assertThatExceptionOfType(ActiveMQSecurityException::class.java).isThrownBy { attacker.start(PEER_USER, PEER_USER, enableSSL = false) // Login as a peer } diff --git a/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsRPCTest.kt b/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsRPCTest.kt index e06d21eee66..9eee5fd05de 100644 --- a/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsRPCTest.kt +++ b/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsRPCTest.kt @@ -8,7 +8,7 @@ import org.junit.Test */ class MQSecurityAsRPCTest : RPCMQSecurityTest() { override fun createAttacker(): SimpleMQClient { - return clientTo(alice.internals.configuration.rpcOptions.address!!) + return clientTo(alice.internals.configuration.rpcOptions.address) } @Test diff --git a/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt b/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt index 44da2d4e7ec..179fe0b7f08 100644 --- a/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt +++ b/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt @@ -29,6 +29,7 @@ import net.corda.testing.node.internal.NodeBasedTest import net.corda.testing.node.internal.startFlow import org.apache.activemq.artemis.api.core.ActiveMQNonExistentQueueException import org.apache.activemq.artemis.api.core.ActiveMQSecurityException +import org.apache.activemq.artemis.api.core.RoutingType import org.apache.activemq.artemis.api.core.SimpleString import org.assertj.core.api.Assertions.assertThatExceptionOfType import org.junit.After @@ -111,9 +112,9 @@ abstract class MQSecurityTest : NodeBasedTest() { } fun loginToRPCAndGetClientQueue(): String { - loginToRPC(alice.internals.configuration.rpcOptions.address!!, rpcUser) + loginToRPC(alice.internals.configuration.rpcOptions.address, rpcUser) val clientQueueQuery = SimpleString("${RPCApi.RPC_CLIENT_QUEUE_NAME_PREFIX}.${rpcUser.username}.*") - val client = clientTo(alice.internals.configuration.rpcOptions.address!!) + val client = clientTo(alice.internals.configuration.rpcOptions.address) client.start(rpcUser.username, rpcUser.password, false) return client.session.addressQuery(clientQueueQuery).queueNames.single().toString() } @@ -126,7 +127,7 @@ abstract class MQSecurityTest : NodeBasedTest() { fun assertTempQueueCreationAttackFails(queue: String) { assertAttackFails(queue, "CREATE_NON_DURABLE_QUEUE") { - attacker.session.createTemporaryQueue(queue, queue) + attacker.session.createTemporaryQueue(queue, RoutingType.MULTICAST, queue) } // Double-check assertThatExceptionOfType(ActiveMQNonExistentQueueException::class.java).isThrownBy { @@ -143,7 +144,7 @@ abstract class MQSecurityTest : NodeBasedTest() { fun assertNonTempQueueCreationAttackFails(queue: String, durable: Boolean) { val permission = if (durable) "CREATE_DURABLE_QUEUE" else "CREATE_NON_DURABLE_QUEUE" assertAttackFails(queue, permission) { - attacker.session.createQueue(queue, queue, durable) + attacker.session.createQueue(queue, RoutingType.MULTICAST, queue, durable) } // Double-check assertThatExceptionOfType(ActiveMQNonExistentQueueException::class.java).isThrownBy { diff --git a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt index 46e889e06f8..b4de9fbea42 100644 --- a/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt +++ b/node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt @@ -4,11 +4,10 @@ import com.typesafe.config.Config import com.typesafe.config.ConfigException import net.corda.core.context.AuthServiceId import net.corda.core.identity.CordaX500Name -import net.corda.core.internal.div +import net.corda.core.internal.TimedFlow import net.corda.core.utilities.NetworkHostAndPort import net.corda.core.utilities.loggerFor import net.corda.core.utilities.seconds -import net.corda.node.internal.artemis.CertificateChainCheckPolicy import net.corda.node.services.config.rpc.NodeRpcOptions import net.corda.nodeapi.BrokerRpcSslOptions import net.corda.nodeapi.internal.config.NodeSSLConfiguration @@ -40,6 +39,7 @@ interface NodeConfiguration : NodeSSLConfiguration { val devModeOptions: DevModeOptions? val compatibilityZoneURL: URL? val networkServices: NetworkServicesConfig? + @Suppress("DEPRECATION") val certificateChainCheckPolicies: List val verifierType: VerifierType val flowTimeout: FlowTimeoutConfiguration @@ -179,6 +179,7 @@ data class NodeConfigurationImpl( override val messagingServerAddress: NetworkHostAndPort?, override val messagingServerExternal: Boolean = (messagingServerAddress != null), override val notary: NotaryConfig?, + @Suppress("DEPRECATION") @Deprecated("Do not configure") override val certificateChainCheckPolicies: List = emptyList(), override val devMode: Boolean = false, @@ -329,6 +330,7 @@ data class NodeConfigurationImpl( require(security == null || rpcUsers.isEmpty()) { "Cannot specify both 'rpcUsers' and 'security' in configuration" } + @Suppress("DEPRECATION") if(certificateChainCheckPolicies.isNotEmpty()) { logger.warn("""You are configuring certificateChainCheckPolicies. This is a setting that is not used, and will be removed in a future version. |Please contact the R3 team on the public slack to discuss your use case. @@ -383,18 +385,7 @@ enum class CertChainPolicyType { } @Deprecated("Do not use") -data class CertChainPolicyConfig(val role: String, private val policy: CertChainPolicyType, private val trustedAliases: Set) { - val certificateChainCheckPolicy: CertificateChainCheckPolicy - get() { - return when (policy) { - CertChainPolicyType.Any -> CertificateChainCheckPolicy.Any - CertChainPolicyType.RootMustMatch -> CertificateChainCheckPolicy.RootMustMatch - CertChainPolicyType.LeafMustMatch -> CertificateChainCheckPolicy.LeafMustMatch - CertChainPolicyType.MustContainOneOf -> CertificateChainCheckPolicy.MustContainOneOf(trustedAliases) - CertChainPolicyType.UsernameMustMatch -> CertificateChainCheckPolicy.UsernameMustMatchCommonName - } - } -} +data class CertChainPolicyConfig(val role: String, private val policy: CertChainPolicyType, private val trustedAliases: Set) // Supported types of authentication/authorization data providers enum class AuthDataSourceType { @@ -431,8 +422,6 @@ data class SecurityConfiguration(val authService: SecurityConfiguration.AuthServ } } - fun copyWithAdditionalUser(user: User) = AuthService(dataSource.copyWithAdditionalUser(user), id, options) - // Optional components: cache data class Options(val cache: Options.Cache?) { @@ -460,12 +449,6 @@ data class SecurityConfiguration(val authService: SecurityConfiguration.AuthServ AuthDataSourceType.DB -> require(users == null && connection != null) } } - - fun copyWithAdditionalUser(user: User): DataSource { - val extendedList = this.users?.toMutableList() ?: mutableListOf() - extendedList.add(user) - return DataSource(this.type, this.passwordEncryption, this.connection, listOf(*extendedList.toTypedArray())) - } } companion object { @@ -485,4 +468,4 @@ data class SecurityConfiguration(val authService: SecurityConfiguration.AuthServ id = AuthServiceId("NODE_CONFIG")) } } -} \ No newline at end of file +} diff --git a/node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt b/node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt index e7ab13fa4c2..adcc86892ad 100644 --- a/node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt +++ b/node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt @@ -24,7 +24,7 @@ import javax.annotation.concurrent.ThreadSafe */ // TODO There is duplicated logic between this and PersistentIdentityService @ThreadSafe -class InMemoryIdentityService(identities: List = emptyList(), +class InMemoryIdentityService(identities: List = emptyList(), override val trustRoot: X509Certificate) : SingletonSerializeAsToken(), IdentityService { companion object { private val log = contextLogger() diff --git a/node/src/main/kotlin/net/corda/node/services/keys/E2ETestKeyManagementService.kt b/node/src/main/kotlin/net/corda/node/services/keys/E2ETestKeyManagementService.kt index 0c0eb617789..d900d2c73b5 100644 --- a/node/src/main/kotlin/net/corda/node/services/keys/E2ETestKeyManagementService.kt +++ b/node/src/main/kotlin/net/corda/node/services/keys/E2ETestKeyManagementService.kt @@ -53,7 +53,7 @@ class E2ETestKeyManagementService(val identityService: IdentityService, } override fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean): PartyAndCertificate { - return freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey), revocationEnabled) + return freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey)) } private fun getSigner(publicKey: PublicKey): ContentSigner = getSigner(getSigningKeyPair(publicKey)) diff --git a/node/src/main/kotlin/net/corda/node/services/keys/KMSUtils.kt b/node/src/main/kotlin/net/corda/node/services/keys/KMSUtils.kt index 5bf1a3d0432..851d0872a2d 100644 --- a/node/src/main/kotlin/net/corda/node/services/keys/KMSUtils.kt +++ b/node/src/main/kotlin/net/corda/node/services/keys/KMSUtils.kt @@ -30,8 +30,7 @@ import java.time.Duration fun freshCertificate(identityService: IdentityService, subjectPublicKey: PublicKey, issuer: PartyAndCertificate, - issuerSigner: ContentSigner, - revocationEnabled: Boolean = false): PartyAndCertificate { + issuerSigner: ContentSigner): PartyAndCertificate { val issuerRole = CertRole.extract(issuer.certificate) require(issuerRole == CertRole.LEGAL_IDENTITY) { "Confidential identities can only be issued from well known identities, provided issuer ${issuer.name} has role $issuerRole" } val issuerCert = issuer.certificate diff --git a/node/src/main/kotlin/net/corda/node/services/keys/PersistentKeyManagementService.kt b/node/src/main/kotlin/net/corda/node/services/keys/PersistentKeyManagementService.kt index e2d7509bb9a..c6d0aaaa86a 100644 --- a/node/src/main/kotlin/net/corda/node/services/keys/PersistentKeyManagementService.kt +++ b/node/src/main/kotlin/net/corda/node/services/keys/PersistentKeyManagementService.kt @@ -87,8 +87,9 @@ class PersistentKeyManagementService(val identityService: IdentityService, return keyPair.public } - override fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean): PartyAndCertificate = - freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey), revocationEnabled) + override fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean): PartyAndCertificate { + return freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey)) + } private fun getSigner(publicKey: PublicKey): ContentSigner = getSigner(getSigningKeyPair(publicKey)) diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/SingleThreadedStateMachineManager.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/SingleThreadedStateMachineManager.kt index 51ad2460c47..40d1c92b99e 100644 --- a/node/src/main/kotlin/net/corda/node/services/statemachine/SingleThreadedStateMachineManager.kt +++ b/node/src/main/kotlin/net/corda/node/services/statemachine/SingleThreadedStateMachineManager.kt @@ -56,10 +56,10 @@ import kotlin.streams.toList @ThreadSafe class SingleThreadedStateMachineManager( val serviceHub: ServiceHubInternal, - val checkpointStorage: CheckpointStorage, + private val checkpointStorage: CheckpointStorage, val executor: ExecutorService, val database: CordaPersistence, - val secureRandom: SecureRandom, + private val secureRandom: SecureRandom, private val unfinishedFibers: ReusableLatch = ReusableLatch(), private val classloader: ClassLoader = SingleThreadedStateMachineManager::class.java.classLoader ) : StateMachineManager, StateMachineManagerInternal { @@ -135,7 +135,7 @@ class SingleThreadedStateMachineManager( } serviceHub.networkMapCache.nodeReady.then { resumeRestoredFlows(fibers) - flowMessaging.start { receivedMessage, deduplicationHandler -> + flowMessaging.start { _, deduplicationHandler -> executor.execute { deliverExternalEvent(deduplicationHandler.externalCause) } @@ -286,10 +286,10 @@ class SingleThreadedStateMachineManager( } private fun checkQuasarJavaAgentPresence() { - check(SuspendableHelper.isJavaAgentActive(), { + check(SuspendableHelper.isJavaAgentActive()) { """Missing the '-javaagent' JVM argument. Make sure you run the tests with the Quasar java agent attached to your JVM. #See https://docs.corda.net/troubleshooting.html - 'Fiber classes not instrumented' for more details.""".trimMargin("#") - }) + } } private fun decrementLiveFibers() { @@ -304,8 +304,7 @@ class SingleThreadedStateMachineManager( return checkpointStorage.getAllCheckpoints().map { (id, serializedCheckpoint) -> // If a flow is added before start() then don't attempt to restore it mutex.locked { if (flows.containsKey(id)) return@map null } - val checkpoint = deserializeCheckpoint(serializedCheckpoint) - if (checkpoint == null) return@map null + val checkpoint = deserializeCheckpoint(serializedCheckpoint) ?: return@map null logger.debug { "Restored $checkpoint" } createFlowFromCheckpoint( id = id, @@ -524,12 +523,6 @@ class SingleThreadedStateMachineManager( isStartIdempotent: Boolean ): CordaFuture> { val flowId = StateMachineRunId.createRandom() - val deduplicationSeed = when (flowStart) { - FlowStart.Explicit -> flowId.uuid.toString() - is FlowStart.Initiated -> - "${flowStart.initiatingMessage.initiatorSessionId.toLong}-" + - "${flowStart.initiatingMessage.initiationEntropy}" - } // Before we construct the state machine state by freezing the FlowLogic we need to make sure that lazy properties // have access to the fiber (and thereby the service hub) @@ -541,7 +534,7 @@ class SingleThreadedStateMachineManager( val flowCorDappVersion = createSubFlowVersion(serviceHub.cordappProvider.getCordappForFlow(flowLogic), serviceHub.myInfo.platformVersion) - val initialCheckpoint = Checkpoint.create(invocationContext, flowStart, flowLogic.javaClass, frozenFlowLogic, ourIdentity, deduplicationSeed, flowCorDappVersion).getOrThrow() + val initialCheckpoint = Checkpoint.create(invocationContext, flowStart, flowLogic.javaClass, frozenFlowLogic, ourIdentity, flowCorDappVersion).getOrThrow() val startedFuture = openFuture() val initialState = StateMachineState( checkpoint = initialCheckpoint, diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/StaffedFlowHospital.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/StaffedFlowHospital.kt index 2779cee9164..75493c1cfb3 100644 --- a/node/src/main/kotlin/net/corda/node/services/statemachine/StaffedFlowHospital.kt +++ b/node/src/main/kotlin/net/corda/node/services/statemachine/StaffedFlowHospital.kt @@ -2,6 +2,7 @@ package net.corda.node.services.statemachine import net.corda.core.flows.StateMachineRunId import net.corda.core.internal.ThreadBox +import net.corda.core.internal.TimedFlow import net.corda.core.internal.bufferUntilSubscribed import net.corda.core.messaging.DataFeed import net.corda.core.utilities.contextLogger @@ -100,12 +101,6 @@ class StaffedFlowHospital { private data class ConsultationReport(val error: Throwable, val diagnosis: Diagnosis, val by: List) - /** - * The flow running in [flowFiber] has cleaned, possibly as a result of a flow hospital resume. - */ - // It's okay for flows to be cleaned... we fix them now! - fun flowCleaned(flowFiber: FlowFiber) = Unit - /** * The flow has been removed from the state machine. */ diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineState.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineState.kt index e4de7f953ab..5684910f440 100644 --- a/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineState.kt +++ b/node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineState.kt @@ -69,7 +69,6 @@ data class Checkpoint( flowLogicClass: Class>, frozenFlowLogic: SerializedBytes>, ourIdentity: Party, - deduplicationSeed: String, subFlowVersion: SubFlowVersion ): Try { return SubFlow.create(flowLogicClass, subFlowVersion).map { topLevelSubFlow -> diff --git a/node/src/main/kotlin/net/corda/node/services/statemachine/interceptors/HospitalisingInterceptor.kt b/node/src/main/kotlin/net/corda/node/services/statemachine/interceptors/HospitalisingInterceptor.kt index db6cbed48b0..93f78f36924 100644 --- a/node/src/main/kotlin/net/corda/node/services/statemachine/interceptors/HospitalisingInterceptor.kt +++ b/node/src/main/kotlin/net/corda/node/services/statemachine/interceptors/HospitalisingInterceptor.kt @@ -45,9 +45,7 @@ class HospitalisingInterceptor( when (nextState.checkpoint.errorState) { is ErrorState.Clean -> { - if (hospitalisedFlows.remove(fiber.id) != null) { - flowHospital.flowCleaned(fiber) - } + hospitalisedFlows.remove(fiber.id) } is ErrorState.Errored -> { val exceptionsToHandle = nextState.checkpoint.errorState.errors.map { it.exception } diff --git a/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt b/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt index 945cc2135a3..19db9ef18dc 100644 --- a/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt +++ b/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt @@ -76,7 +76,7 @@ abstract class AppendOnlyPersistentMapBase( Transactional.Committed(value) } else { // Some database transactions, including us, writing, with readers seeing whatever is in the database and writers seeing the (in memory) value. - Transactional.InFlight(this, key, { loadValue(key) }).apply { alsoWrite(value) } + Transactional.InFlight(this, key, _readerValueLoader = { loadValue(key) }).apply { alsoWrite(value) } } } @@ -146,13 +146,13 @@ abstract class AppendOnlyPersistentMapBase( } // Helpers to know if transaction(s) are currently writing the given key. - protected fun weAreWriting(key: K): Boolean = pendingKeys.get(key)?.contains(contextTransaction) ?: false - protected fun anyoneWriting(key: K): Boolean = pendingKeys.get(key)?.isNotEmpty() ?: false + protected fun weAreWriting(key: K): Boolean = pendingKeys[key]?.contains(contextTransaction) ?: false + protected fun anyoneWriting(key: K): Boolean = pendingKeys[key]?.isNotEmpty() ?: false // Indicate this database transaction is a writer of this key. private fun addPendingKey(key: K, databaseTransaction: DatabaseTransaction): Boolean { var added = true - pendingKeys.compute(key) { k, oldSet -> + pendingKeys.compute(key) { _, oldSet -> if (oldSet == null) { val newSet = HashSet(0) newSet += databaseTransaction @@ -167,7 +167,7 @@ abstract class AppendOnlyPersistentMapBase( // Remove this database transaction as a writer of this key, because the transaction committed or rolled back. private fun removePendingKey(key: K, databaseTransaction: DatabaseTransaction) { - pendingKeys.compute(key) { k, oldSet -> + pendingKeys.compute(key) { _, oldSet -> if (oldSet == null) { oldSet } else { @@ -199,7 +199,7 @@ abstract class AppendOnlyPersistentMapBase( } // No one can see it. - class Missing() : Transactional() { + class Missing : Transactional() { override val value: T get() = throw NoSuchElementException("Not present") override val isPresent: Boolean @@ -228,7 +228,7 @@ abstract class AppendOnlyPersistentMapBase( fun alsoWrite(_value: T) { // Make the lazy loader the writers see actually just return the value that has been set. - writerValueLoader.set({ _value }) + writerValueLoader.set { _value } // We make all these vals so that the lambdas do not need a reference to this, and so the onCommit only has a weak ref to the value. // We want this so that the cache could evict the value (due to memory constraints etc) without the onCommit callback // retaining what could be a large memory footprint object. @@ -242,10 +242,9 @@ abstract class AppendOnlyPersistentMapBase( // and then stop saying the transaction is writing the key. tx.onCommit { if (strongComitted.compareAndSet(false, true)) { - val dereferencedKey = strongKey val dereferencedValue = weakValue.get() if (dereferencedValue != null) { - strongMap.cache.put(dereferencedKey, Committed(dereferencedValue)) + strongMap.cache.put(strongKey, Committed(dereferencedValue)) } } strongMap.removePendingKey(strongKey, tx) @@ -262,7 +261,7 @@ abstract class AppendOnlyPersistentMapBase( private fun loadAsWriter(): T { val _value = writerValueLoader.get()() if (writerValueLoader.get() == _writerValueLoader) { - writerValueLoader.set({ _value }) + writerValueLoader.set { _value } } return _value } @@ -272,7 +271,7 @@ abstract class AppendOnlyPersistentMapBase( private fun loadAsReader(): T? { val _value = readerValueLoader.get()() if (readerValueLoader.get() == _readerValueLoader) { - readerValueLoader.set({ _value }) + readerValueLoader.set { _value } } return _value } @@ -310,7 +309,7 @@ open class AppendOnlyPersistentMap( toPersistentEntity, persistentEntityClass) { //TODO determine cacheBound based on entity class later or with node config allowing tuning, or using some heuristic based on heap size - override val cache = NonInvalidatingCache>( + override val cache = NonInvalidatingCache( bound = cacheBound, loadFunction = { key: K -> // This gets called if a value is read and the cache has no Transactional for this key yet. @@ -321,10 +320,10 @@ open class AppendOnlyPersistentMap( // If someone is writing (but not us) // For those not writing, the value cannot be seen. // For those writing, they need to re-load the value from the database (which their database transaction CAN see). - Transactional.InFlight(this, key, { null }, { loadValue(key)!! }) + Transactional.InFlight(this, key, { null }, { loadValue(key)!! }) } else { // If no one is writing, then the value does not exist. - Transactional.Missing() + Transactional.Missing() } } else { // A value was found @@ -332,10 +331,10 @@ open class AppendOnlyPersistentMap( // If we are writing, it might not be globally visible, and was evicted from the cache. // For those not writing, they need to check the database again. // For those writing, they can see the value found. - Transactional.InFlight(this, key, { loadValue(key) }, { value }) + Transactional.InFlight(this, key, { loadValue(key) }, { value }) } else { // If no one is writing, then make it globally visible. - Transactional.Committed(value) + Transactional.Committed(value) } } }) @@ -354,26 +353,22 @@ class WeightBasedAppendOnlyPersistentMap( fromPersistentEntity, toPersistentEntity, persistentEntityClass) { - override val cache = NonInvalidatingWeightBasedCache>( + override val cache = NonInvalidatingWeightBasedCache( maxWeight = maxWeight, - weigher = object : Weigher> { - override fun weigh(key: K, value: Transactional): Int { - return weighingFunc(key, value) - } - }, + weigher = Weigher { key, value -> weighingFunc(key, value) }, loadFunction = { key: K -> val value: V? = loadValue(key) if (value == null) { if (anyoneWriting(key)) { - Transactional.InFlight(this, key, { null }, { loadValue(key)!! }) + Transactional.InFlight(this, key, { null }, { loadValue(key)!! }) } else { - Transactional.Missing() + Transactional.Missing() } } else { if (weAreWriting(key)) { - Transactional.InFlight(this, key, { loadValue(key) }, { value }) + Transactional.InFlight(this, key, { loadValue(key) }, { value }) } else { - Transactional.Committed(value) + Transactional.Committed(value) } } }) diff --git a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java index 3c9b727313c..359a162c395 100644 --- a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java +++ b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java @@ -35,9 +35,6 @@ import org.junit.Test; import rx.Observable; -import java.io.IOException; -import java.security.InvalidAlgorithmParameterException; -import java.security.cert.CertificateException; import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -69,7 +66,7 @@ public class VaultQueryJavaTests { private CordaPersistence database; @Before - public void setUp() throws CertificateException, InvalidAlgorithmParameterException { + public void setUp() { List cordappPackages = asList("net.corda.testing.internal.vault", "net.corda.finance.contracts.asset", CashSchemaV1.class.getPackage().getName()); IdentityService identitySvc = makeTestIdentityService(MEGA_CORP.getIdentity(), DUMMY_CASH_ISSUER_INFO.getIdentity(), DUMMY_NOTARY.getIdentity()); Pair databaseAndServices = makeTestDatabaseAndMockServices( @@ -85,14 +82,10 @@ public void setUp() throws CertificateException, InvalidAlgorithmParameterExcept } @After - public void cleanUp() throws IOException { + public void cleanUp() { database.close(); } - /** - * Sample Vault Query API tests - */ - /** * Static queryBy() tests */ @@ -103,6 +96,7 @@ public void criteriaWithFieldFromMappedSuperclass() throws NoSuchFieldException FieldInfo currency = getField("currency", SampleCashSchemaV2.PersistentCashState.class); CriteriaExpression.AggregateFunctionExpression expression = sum(quantity, singletonList(currency), Sort.Direction.ASC); + @SuppressWarnings("unchecked") VaultCustomQueryCriteria criteria = new VaultCustomQueryCriteria(expression, Vault.StateStatus.UNCONSUMED, null); database.transaction(tx -> vaultService.queryBy(FungibleAsset.class, criteria)); @@ -115,13 +109,14 @@ public void criteriaWithFieldFromMappedSuperclassOfSuperclass() throws NoSuchFie FieldInfo stateRef = getField("stateRef", SampleCashSchemaV2.PersistentCashState.class); CriteriaExpression.AggregateFunctionExpression expression = sum(quantity, asList(currency, stateRef), Sort.Direction.ASC); + @SuppressWarnings("unchecked") VaultCustomQueryCriteria criteria = new VaultCustomQueryCriteria(expression, Vault.StateStatus.UNCONSUMED, null); database.transaction(tx -> vaultService.queryBy(FungibleAsset.class, criteria)); } @Test - public void unconsumedLinearStates() throws VaultQueryException { + public void unconsumedLinearStates() { database.transaction(tx -> { vaultFiller.fillWithSomeTestLinearStates(3); return tx; @@ -193,7 +188,7 @@ public void consumedCashStates() { } @Test - public void consumedDealStatesPagedSorted() throws VaultQueryException { + public void consumedDealStatesPagedSorted() { List dealIds = asList("123", "456", "789"); @SuppressWarnings("unchecked") Triple, UniqueIdentifier, Vault> ids = @@ -304,7 +299,6 @@ public void trackCashStates() { DataFeed, Vault.Update> results = vaultService.trackBy(ContractState.class, criteria); Vault.Page snapshot = results.getSnapshot(); - Observable> updates = results.getUpdates(); // DOCEND VaultJavaQueryExample4 assertThat(snapshot.getStates()).hasSize(3); @@ -358,7 +352,6 @@ public void trackDealStatesPagedSorted() { @SuppressWarnings("unchecked") public void aggregateFunctionsWithoutGroupClause() { database.transaction(tx -> { - Amount dollars100 = new Amount<>(100, Currency.getInstance("USD")); Amount dollars200 = new Amount<>(200, Currency.getInstance("USD")); Amount dollars300 = new Amount<>(300, Currency.getInstance("USD")); @@ -404,7 +397,6 @@ public void aggregateFunctionsWithoutGroupClause() { @SuppressWarnings("unchecked") public void aggregateFunctionsWithSingleGroupClause() { database.transaction(tx -> { - Amount dollars100 = new Amount<>(100, Currency.getInstance("USD")); Amount dollars200 = new Amount<>(200, Currency.getInstance("USD")); Amount dollars300 = new Amount<>(300, Currency.getInstance("USD")); diff --git a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt index 1297bd97e6e..fe974313089 100644 --- a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt +++ b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt @@ -24,7 +24,6 @@ import net.corda.core.utilities.getOrThrow import net.corda.core.utilities.unwrap import net.corda.finance.DOLLARS import net.corda.finance.GBP -import net.corda.finance.USD import net.corda.finance.contracts.asset.Cash import net.corda.finance.flows.CashIssueFlow import net.corda.finance.flows.CashPaymentFlow @@ -157,6 +156,7 @@ class CordaRPCOpsImplTest { @Test fun `issue and move`() { + @Suppress("DEPRECATION") withPermissions(invokeRpc(CordaRPCOps::stateMachinesFeed), invokeRpc(CordaRPCOps::internalVerifiedTransactionsFeed), invokeRpc("vaultTrackBy"), @@ -168,11 +168,7 @@ class CordaRPCOpsImplTest { vaultTrackCash = rpc.vaultTrackBy().updates } - val result = rpc.startFlow(::CashIssueFlow, - 100.DOLLARS, - OpaqueBytes(ByteArray(1, { 1 })), - notary - ) + val result = rpc.startFlow(::CashIssueFlow, 100.DOLLARS, OpaqueBytes.of(1), notary) mockNet.runNetwork() @@ -247,7 +243,7 @@ class CordaRPCOpsImplTest { fun `cash command by user not permissioned for cash`() { withoutAnyPermissions { assertThatExceptionOfType(PermissionException::class.java).isThrownBy { - rpc.startFlow(::CashIssueFlow, Amount(100, USD), OpaqueBytes(ByteArray(1, { 1 })), notary) + rpc.startFlow(::CashIssueFlow, 100.DOLLARS, OpaqueBytes.of(1), notary) } } } diff --git a/node/src/test/kotlin/net/corda/node/internal/NodeTest.kt b/node/src/test/kotlin/net/corda/node/internal/NodeTest.kt index 76e2d0b7e42..777990b656e 100644 --- a/node/src/test/kotlin/net/corda/node/internal/NodeTest.kt +++ b/node/src/test/kotlin/net/corda/node/internal/NodeTest.kt @@ -60,7 +60,7 @@ class NodeTest { fun `generateAndSaveNodeInfo works`() { val configuration = createConfig(ALICE_NAME) val platformVersion = 789 - configureDatabase(configuration.dataSourceProperties, configuration.database, { null }, { null }).use { database -> + configureDatabase(configuration.dataSourceProperties, configuration.database, { null }, { null }).use { val node = Node(configuration, rigorousMock().also { doReturn(platformVersion).whenever(it).platformVersion }, initialiseSerialization = false) diff --git a/node/src/test/kotlin/net/corda/node/internal/serialization/RoundTripObservableSerializerTests.kt b/node/src/test/kotlin/net/corda/node/internal/serialization/RoundTripObservableSerializerTests.kt index 2a16e8febfa..0620f0f115a 100644 --- a/node/src/test/kotlin/net/corda/node/internal/serialization/RoundTripObservableSerializerTests.kt +++ b/node/src/test/kotlin/net/corda/node/internal/serialization/RoundTripObservableSerializerTests.kt @@ -19,7 +19,6 @@ import org.apache.activemq.artemis.api.core.SimpleString import org.junit.Test import rx.Notification import rx.Observable -import rx.Subscription import rx.subjects.UnicastSubject import java.time.Instant import java.util.* @@ -38,7 +37,7 @@ class RoundTripObservableSerializerTests { .maximumSize(100) .build() - subMap.put(id, ObservableSubscription(mock())) + subMap.put(id, ObservableSubscription(mock())) return subMap } @@ -48,7 +47,7 @@ class RoundTripObservableSerializerTests { }) private fun createRpcObservableMap(): Cache>> { - val onObservableRemove = RemovalListener>> { key, value, cause -> + val onObservableRemove = RemovalListener>> { key, _, _ -> val observableId = key!! observablesToReap.locked { observables.add(observableId) } @@ -85,7 +84,7 @@ class RoundTripObservableSerializerTests { // What we're actually going to serialize then deserialize - val obs = Observable.create({ 12 }) + val obs = Observable.create { Math.random() } val serverSerializationContext = RpcServerObservableSerializer.createContext( serializationContext, serverObservableContext) @@ -95,6 +94,6 @@ class RoundTripObservableSerializerTests { val blob = SerializationOutput(serverSerializer).serialize(obs, serverSerializationContext) - val obs2 = DeserializationInput(clientSerializer).deserialize(blob, clientSerializationContext) + DeserializationInput(clientSerializer).deserialize(blob, clientSerializationContext) } -} \ No newline at end of file +} diff --git a/node/src/test/kotlin/net/corda/node/internal/serialization/RpcServerObservableSerializerTests.kt b/node/src/test/kotlin/net/corda/node/internal/serialization/RpcServerObservableSerializerTests.kt index 8d9e96391b8..720d147eac6 100644 --- a/node/src/test/kotlin/net/corda/node/internal/serialization/RpcServerObservableSerializerTests.kt +++ b/node/src/test/kotlin/net/corda/node/internal/serialization/RpcServerObservableSerializerTests.kt @@ -8,13 +8,12 @@ import net.corda.node.internal.serialization.testutils.TestObservableContext import net.corda.node.internal.serialization.testutils.serializationContext import net.corda.node.serialization.amqp.RpcServerObservableSerializer import net.corda.node.services.messaging.ObservableSubscription +import net.corda.serialization.internal.AllWhitelist import net.corda.serialization.internal.amqp.SerializationOutput import net.corda.serialization.internal.amqp.SerializerFactory -import net.corda.serialization.internal.AllWhitelist import org.apache.activemq.artemis.api.core.SimpleString import org.junit.Test import rx.Observable -import rx.Subscription import java.time.Instant import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.TimeUnit @@ -28,7 +27,7 @@ class RpcServerObservableSerializerTests { .maximumSize(100) .build() - subMap.put(Trace.InvocationId("test1", Instant.now()), ObservableSubscription(mock())) + subMap.put(Trace.InvocationId("test1", Instant.now()), ObservableSubscription(mock())) return subMap } @@ -72,7 +71,7 @@ class RpcServerObservableSerializerTests { register(RpcServerObservableSerializer()) } - val obs = Observable.create({ 12 }) + val obs = Observable.create { Math.random() } val newContext = RpcServerObservableSerializer.createContext(serializationContext, observable) try { diff --git a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt index ce52ebd50f2..76ac89be699 100644 --- a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt @@ -1,21 +1,7 @@ package net.corda.node.services.events -import com.nhaarman.mockito_kotlin.any -import com.nhaarman.mockito_kotlin.argForWhich -import com.nhaarman.mockito_kotlin.doAnswer -import com.nhaarman.mockito_kotlin.doReturn -import com.nhaarman.mockito_kotlin.eq -import com.nhaarman.mockito_kotlin.same -import com.nhaarman.mockito_kotlin.timeout -import com.nhaarman.mockito_kotlin.verify -import com.nhaarman.mockito_kotlin.verifyNoMoreInteractions -import com.nhaarman.mockito_kotlin.whenever -import junit.framework.Assert.fail -import net.corda.core.contracts.SchedulableState -import net.corda.core.contracts.ScheduledActivity -import net.corda.core.contracts.ScheduledStateRef -import net.corda.core.contracts.StateRef -import net.corda.core.contracts.TransactionState +import com.nhaarman.mockito_kotlin.* +import net.corda.core.contracts.* import net.corda.core.crypto.SecureHash import net.corda.core.flows.FlowLogic import net.corda.core.flows.FlowLogicRef @@ -36,11 +22,7 @@ import net.corda.testing.internal.rigorousMock import net.corda.testing.internal.spectator import net.corda.testing.node.MockServices import net.corda.testing.node.TestClock -import org.junit.After -import org.junit.Before -import org.junit.Ignore -import org.junit.Rule -import org.junit.Test +import org.junit.* import org.junit.rules.TestWatcher import org.junit.runner.Description import org.slf4j.Logger @@ -51,6 +33,7 @@ import java.util.* import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.TimeUnit import kotlin.test.assertEquals +import kotlin.test.fail open class NodeSchedulerServiceTestBase { protected class Event(time: Instant) { @@ -87,7 +70,7 @@ open class NodeSchedulerServiceTestBase { doLookup(transactionStates).whenever(it).loadState(any()) } - protected val traces = Collections.synchronizedList(mutableListOf()) + private val traces = Collections.synchronizedList(mutableListOf()) @Before fun resetTraces() { @@ -98,7 +81,7 @@ open class NodeSchedulerServiceTestBase { doReturn(false).whenever(it).isTraceEnabled doAnswer { traces += it.getArgument(1) - }.whenever(it).trace(eq(NodeSchedulerService.schedulingAsNextFormat), any()) + }.whenever(it).trace(eq(NodeSchedulerService.schedulingAsNextFormat), any()) } protected fun assertWaitingFor(ssr: ScheduledStateRef) { @@ -273,7 +256,7 @@ class NodeSchedulerServiceTest : NodeSchedulerServiceTestBase() { class NodeSchedulerPersistenceTest : NodeSchedulerServiceTestBase() { private val databaseConfig: DatabaseConfig = DatabaseConfig() - fun createScheduler(db: CordaPersistence): NodeSchedulerService { + private fun createScheduler(db: CordaPersistence): NodeSchedulerService { return NodeSchedulerService( testClock, db, @@ -285,7 +268,7 @@ class NodeSchedulerPersistenceTest : NodeSchedulerServiceTestBase() { log = log).apply { start() } } - fun transactionStateMock(logicRef: FlowLogicRef, time: Instant): TransactionState<*> { + private fun transactionStateMock(logicRef: FlowLogicRef, time: Instant): TransactionState<*> { return rigorousMock>().also { doReturn(rigorousMock().also { doReturn(ScheduledActivity(logicRef, time)).whenever(it).nextScheduledActivity(any(), any()) diff --git a/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTest.kt b/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTest.kt index 98b066e3431..2a8e7d3e4e1 100644 --- a/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTest.kt @@ -6,9 +6,8 @@ import net.corda.core.crypto.generateKeyPair import net.corda.core.utilities.NetworkHostAndPort import net.corda.core.utilities.seconds import net.corda.node.internal.configureDatabase -import net.corda.node.services.config.CertChainPolicyConfig -import net.corda.node.services.config.NodeConfiguration import net.corda.node.services.config.FlowTimeoutConfiguration +import net.corda.node.services.config.NodeConfiguration import net.corda.node.services.config.configureWithDevSSLCertificate import net.corda.node.services.network.NetworkMapCacheImpl import net.corda.node.services.network.PersistentNetworkMapCache @@ -72,7 +71,6 @@ class ArtemisMessagingTest { doReturn("cordacadevpass").whenever(it).keyStorePassword doReturn(NetworkHostAndPort("0.0.0.0", serverPort)).whenever(it).p2pAddress doReturn(null).whenever(it).jmxMonitoringHttpPort - doReturn(emptyList()).whenever(it).certificateChainCheckPolicies doReturn(FlowTimeoutConfiguration(5.seconds, 3, backoffBase = 1.0)).whenever(it).flowTimeout } LogHelper.setLevel(PersistentUniquenessProvider::class) diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt b/node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt index 903ffa6c01c..bc02aa19f0a 100644 --- a/node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt @@ -190,7 +190,7 @@ class DBCheckpointStorageTests { override fun call() {} } val frozenLogic = logic.serialize(context = SerializationDefaults.CHECKPOINT_CONTEXT) - val checkpoint = Checkpoint.create(InvocationContext.shell(), FlowStart.Explicit, logic.javaClass, frozenLogic, ALICE, "", SubFlowVersion.CoreFlow(version)).getOrThrow() + val checkpoint = Checkpoint.create(InvocationContext.shell(), FlowStart.Explicit, logic.javaClass, frozenLogic, ALICE, SubFlowVersion.CoreFlow(version)).getOrThrow() return id to checkpoint.serialize(context = SerializationDefaults.CHECKPOINT_CONTEXT) } diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt index b14abfcfeea..44703546e25 100644 --- a/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt @@ -7,18 +7,14 @@ import net.corda.core.crypto.SignatureMetadata import net.corda.core.crypto.TransactionSignature import net.corda.core.toFuture import net.corda.core.transactions.SignedTransaction -import net.corda.core.transactions.WireTransaction import net.corda.node.internal.configureDatabase import net.corda.node.services.config.NodeConfiguration import net.corda.node.services.transactions.PersistentUniquenessProvider import net.corda.nodeapi.internal.persistence.CordaPersistence import net.corda.nodeapi.internal.persistence.DatabaseConfig -import net.corda.testing.core.ALICE_NAME -import net.corda.testing.core.DUMMY_NOTARY_NAME -import net.corda.testing.core.SerializationEnvironmentRule -import net.corda.testing.core.TestIdentity -import net.corda.testing.core.dummyCommand +import net.corda.testing.core.* import net.corda.testing.internal.LogHelper +import net.corda.testing.internal.createWireTransaction import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties import org.assertj.core.api.Assertions.assertThat import org.junit.After @@ -166,7 +162,7 @@ class DBTransactionStorageTests { } private fun newTransaction(): SignedTransaction { - val wtx = WireTransaction( + val wtx = createWireTransaction( inputs = listOf(StateRef(SecureHash.randomSHA256(), 0)), attachments = emptyList(), outputs = emptyList(), @@ -174,6 +170,9 @@ class DBTransactionStorageTests { notary = DUMMY_NOTARY, timeWindow = null ) - return SignedTransaction(wtx, listOf(TransactionSignature(ByteArray(1), ALICE_PUBKEY, SignatureMetadata(1, Crypto.findSignatureScheme(ALICE_PUBKEY).schemeNumberID)))) + return SignedTransaction( + wtx, + listOf(TransactionSignature(ByteArray(1), ALICE_PUBKEY, SignatureMetadata(1, Crypto.findSignatureScheme(ALICE_PUBKEY).schemeNumberID))) + ) } } diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt index 6b22d940fcc..5f4264d536d 100644 --- a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt @@ -4,7 +4,6 @@ import com.nhaarman.mockito_kotlin.* import net.corda.core.contracts.Amount import net.corda.core.contracts.StateAndRef import net.corda.core.contracts.StateRef -import net.corda.core.contracts.TransactionState import net.corda.core.crypto.SecureHash import net.corda.core.crypto.generateKeyPair import net.corda.core.identity.AbstractParty @@ -29,23 +28,23 @@ import net.corda.finance.schemas.SampleCashSchemaV2 import net.corda.finance.schemas.SampleCashSchemaV3 import net.corda.finance.utils.sumCash import net.corda.node.internal.configureDatabase +import net.corda.node.services.api.IdentityServiceInternal +import net.corda.node.services.api.WritableTransactionStorage import net.corda.node.services.schema.ContractStateAndRef import net.corda.node.services.schema.HibernateObserver import net.corda.node.services.schema.NodeSchemaService -import net.corda.node.services.vault.VaultSchemaV1 -import net.corda.node.services.api.IdentityServiceInternal -import net.corda.node.services.api.WritableTransactionStorage import net.corda.node.services.vault.NodeVaultService +import net.corda.node.services.vault.VaultSchemaV1 import net.corda.nodeapi.internal.persistence.CordaPersistence import net.corda.nodeapi.internal.persistence.DatabaseConfig import net.corda.nodeapi.internal.persistence.HibernateConfiguration import net.corda.testing.core.* import net.corda.testing.internal.rigorousMock +import net.corda.testing.internal.vault.DummyLinearStateSchemaV1 +import net.corda.testing.internal.vault.DummyLinearStateSchemaV2 import net.corda.testing.internal.vault.VaultFiller import net.corda.testing.node.MockServices import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties -import net.corda.testing.internal.vault.DummyLinearStateSchemaV1 -import net.corda.testing.internal.vault.DummyLinearStateSchemaV2 import org.assertj.core.api.Assertions import org.assertj.core.api.Assertions.assertThat import org.hibernate.SessionFactory @@ -74,18 +73,18 @@ class HibernateConfigurationTest { val testSerialization = SerializationEnvironmentRule() lateinit var services: MockServices private lateinit var vaultFiller: VaultFiller - lateinit var bankServices: MockServices - lateinit var issuerServices: MockServices - lateinit var notaryServices: MockServices + private lateinit var bankServices: MockServices + private lateinit var issuerServices: MockServices + private lateinit var notaryServices: MockServices lateinit var database: CordaPersistence val vault: VaultService get() = services.vaultService // Hibernate configuration objects lateinit var hibernateConfig: HibernateConfiguration - lateinit var hibernatePersister: HibernateObserver - lateinit var sessionFactory: SessionFactory - lateinit var entityManager: EntityManager - lateinit var criteriaBuilder: CriteriaBuilder + private lateinit var hibernatePersister: HibernateObserver + private lateinit var sessionFactory: SessionFactory + private lateinit var entityManager: EntityManager + private lateinit var criteriaBuilder: CriteriaBuilder // Identities used private lateinit var identity: Party @@ -93,7 +92,7 @@ class HibernateConfigurationTest { private lateinit var notary: Party // test States - lateinit var cashStates: List> + private lateinit var cashStates: List> @Before fun setUp() { @@ -690,7 +689,7 @@ class HibernateConfigurationTest { val queryResults = entityManager.createQuery(criteriaQuery).resultList queryResults.forEach { - val cashState = (services.loadState(toStateRef(it.stateRef!!)) as TransactionState).data + val cashState = services.loadState(toStateRef(it.stateRef!!)).data as Cash.State println("${it.stateRef} with owner: ${cashState.owner.owningKey.toBase58String()}") } @@ -774,7 +773,7 @@ class HibernateConfigurationTest { // execute query val queryResults = entityManager.createQuery(criteriaQuery).resultList queryResults.forEach { - val cashState = (services.loadState(toStateRef(it.stateRef!!)) as TransactionState).data + val cashState = services.loadState(toStateRef(it.stateRef!!)).data as Cash.State println("${it.stateRef} with owner ${cashState.owner.owningKey.toBase58String()} and participants ${cashState.participants.map { it.owningKey.toBase58String() }}") } @@ -913,6 +912,6 @@ class HibernateConfigurationTest { } private fun toStateRef(pStateRef: PersistentStateRef): StateRef { - return StateRef(SecureHash.parse(pStateRef.txId!!), pStateRef.index!!) + return StateRef(SecureHash.parse(pStateRef.txId), pStateRef.index) } -} \ No newline at end of file +} diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt index 8fa276c2a73..81796a540cd 100644 --- a/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt @@ -5,11 +5,7 @@ import com.google.common.jimfs.Configuration import com.google.common.jimfs.Jimfs import net.corda.core.crypto.SecureHash import net.corda.core.crypto.sha256 -import net.corda.core.internal.read -import net.corda.core.internal.readAll -import net.corda.core.internal.readFully -import net.corda.core.internal.write -import net.corda.core.internal.writeLines +import net.corda.core.internal.* import net.corda.core.node.services.vault.AttachmentQueryCriteria import net.corda.core.node.services.vault.AttachmentSort import net.corda.core.node.services.vault.Builder @@ -59,7 +55,7 @@ class NodeAttachmentStorageTest { fun `insert and retrieve`() { val (testJar, expectedHash) = makeTestJar() - val id = testJar.read { storage.importAttachment(it) } + val id = testJar.read { storage.importAttachment(it, "test", null) } assertEquals(expectedHash, id) assertNull(storage.openAttachment(SecureHash.randomSHA256())) @@ -84,7 +80,7 @@ class NodeAttachmentStorageTest { val (testJar, expectedHash) = makeTestJar() val (jarB, hashB) = makeTestJar(listOf(Pair("file", "content"))) - val id = testJar.read { storage.importAttachment(it) } + val id = testJar.read { storage.importAttachment(it, "test", null) } assertEquals(expectedHash, id) @@ -99,7 +95,7 @@ class NodeAttachmentStorageTest { stream.close() - val idB = jarB.read { storage.importAttachment(it) } + val idB = jarB.read { storage.importAttachment(it, "test", null) } assertEquals(hashB, idB) storage.openAttachment(id)!!.openAsJAR().use { @@ -119,6 +115,7 @@ class NodeAttachmentStorageTest { val (jarB, hashB) = makeTestJar(listOf(Pair("file", "content"))) val (jarC, hashC) = makeTestJar(listOf(Pair("magic_file", "magic_content_puff"))) + @Suppress("DEPRECATION") jarA.read { storage.importAttachment(it) } jarB.read { storage.importAttachment(it, "uploaderB", "fileB.zip") } jarC.read { storage.importAttachment(it, "uploaderC", "fileC.zip") } @@ -186,11 +183,11 @@ class NodeAttachmentStorageTest { fun `duplicates not allowed`() { val (testJar, _) = makeTestJar() testJar.read { - storage.importAttachment(it) + storage.importAttachment(it, "test", null) } assertFailsWith { testJar.read { - storage.importAttachment(it) + storage.importAttachment(it, "test", null) } } } @@ -199,7 +196,7 @@ class NodeAttachmentStorageTest { fun `corrupt entry throws exception`() { val (testJar, _) = makeTestJar() val id = database.transaction { - val id = testJar.read { storage.importAttachment(it) } + val id = testJar.read { storage.importAttachment(it, "test", null) } // Corrupt the file in the store. val bytes = testJar.readAll() @@ -227,7 +224,7 @@ class NodeAttachmentStorageTest { path.writeLines(listOf("Hey", "there!")) path.read { assertFailsWith("either empty or not a JAR") { - storage.importAttachment(it) + storage.importAttachment(it, "test", null) } } } diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/MaxTransactionSizeTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/MaxTransactionSizeTests.kt index 9195a5d4682..14ff42b13e1 100644 --- a/node/src/test/kotlin/net/corda/node/services/transactions/MaxTransactionSizeTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/transactions/MaxTransactionSizeTests.kt @@ -5,6 +5,7 @@ import net.corda.core.crypto.SecureHash import net.corda.core.flows.* import net.corda.core.identity.Party import net.corda.core.internal.InputStreamAndHash +import net.corda.core.node.services.AttachmentId import net.corda.core.transactions.TransactionBuilder import net.corda.core.utilities.getOrThrow import net.corda.testing.common.internal.testNetworkParameters @@ -21,6 +22,7 @@ import org.assertj.core.api.Assertions.assertThat import org.junit.After import org.junit.Before import org.junit.Test +import java.io.InputStream import kotlin.test.assertEquals import kotlin.test.assertFailsWith @@ -57,10 +59,10 @@ class MaxTransactionSizeTests { val bigFile3 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 2) val bigFile4 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 3) val flow = aliceNode.transaction { - val hash1 = aliceNode.services.attachments.importAttachment(bigFile1.inputStream) - val hash2 = aliceNode.services.attachments.importAttachment(bigFile2.inputStream) - val hash3 = aliceNode.services.attachments.importAttachment(bigFile3.inputStream) - val hash4 = aliceNode.services.attachments.importAttachment(bigFile4.inputStream) + val hash1 = aliceNode.importAttachment(bigFile1.inputStream) + val hash2 = aliceNode.importAttachment(bigFile2.inputStream) + val hash3 = aliceNode.importAttachment(bigFile3.inputStream) + val hash4 = aliceNode.importAttachment(bigFile4.inputStream) assertEquals(hash1, bigFile1.sha256) SendLargeTransactionFlow(notary, bob, hash1, hash2, hash3, hash4) } @@ -80,10 +82,10 @@ class MaxTransactionSizeTests { val bigFile3 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 2) val bigFile4 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 3) val flow = aliceNode.transaction { - val hash1 = aliceNode.services.attachments.importAttachment(bigFile1.inputStream) - val hash2 = aliceNode.services.attachments.importAttachment(bigFile2.inputStream) - val hash3 = aliceNode.services.attachments.importAttachment(bigFile3.inputStream) - val hash4 = aliceNode.services.attachments.importAttachment(bigFile4.inputStream) + val hash1 = aliceNode.importAttachment(bigFile1.inputStream) + val hash2 = aliceNode.importAttachment(bigFile2.inputStream) + val hash3 = aliceNode.importAttachment(bigFile3.inputStream) + val hash4 = aliceNode.importAttachment(bigFile4.inputStream) assertEquals(hash1, bigFile1.sha256) SendLargeTransactionFlow(notary, bob, hash1, hash2, hash3, hash4, verify = false) } @@ -94,6 +96,10 @@ class MaxTransactionSizeTests { } } + private fun StartedMockNode.importAttachment(inputStream: InputStream): AttachmentId { + return services.attachments.importAttachment(inputStream, "test", null) + } + @StartableByRPC @InitiatingFlow class SendLargeTransactionFlow(private val notary: Party, diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt index 60a56287734..54e47d3f08c 100644 --- a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt @@ -41,7 +41,6 @@ import org.junit.Test import org.junit.rules.ExpectedException import org.junit.rules.ExternalResource import java.time.Duration -import java.time.Instant import java.time.LocalDate import java.time.ZoneOffset import java.time.temporal.ChronoUnit @@ -103,7 +102,7 @@ open class VaultQueryTestRule : ExternalResource(), VaultQueryParties { override val bob = TestIdentity(BOB_NAME, 80) override val cashNotary = TestIdentity(CordaX500Name("Cash Notary Service", "Zurich", "CH"), 21) override val charlie = TestIdentity(CHARLIE_NAME, 90) - override val dummyCashIssuer = TestIdentity(CordaX500Name("Snake Oil Issuer", "London", "GB"), 10) + final override val dummyCashIssuer = TestIdentity(CordaX500Name("Snake Oil Issuer", "London", "GB"), 10) override val DUMMY_CASH_ISSUER = dummyCashIssuer.ref(1) override val dummyNotary = TestIdentity(DUMMY_NOTARY_NAME, 20) override val DUMMY_OBLIGATION_ISSUER = TestIdentity(CordaX500Name("Snake Oil Issuer", "London", "GB"), 10).party @@ -133,7 +132,7 @@ open class VaultQueryTestRule : ExternalResource(), VaultQueryParties { cordappPackages, makeTestIdentityService(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, dummyCashIssuer.identity, dummyNotary.identity), megaCorp, - moreKeys = DUMMY_NOTARY_KEY) + moreKeys = *arrayOf(DUMMY_NOTARY_KEY)) database = databaseAndServices.first services = databaseAndServices.second vaultFiller = VaultFiller(services, dummyNotary) @@ -151,7 +150,7 @@ open class VaultQueryTestRule : ExternalResource(), VaultQueryParties { } } -class VaultQueryRollbackRule(val vaultQueryParties: VaultQueryParties) : ExternalResource() { +class VaultQueryRollbackRule(private val vaultQueryParties: VaultQueryParties) : ExternalResource() { lateinit var transaction: DatabaseTransaction diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt index e7e3a50ea29..fe270603b5a 100644 --- a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt @@ -64,7 +64,7 @@ class VaultWithCashTest { private val servicesKey = generateKeyPair() lateinit var services: MockServices private lateinit var vaultFiller: VaultFiller - lateinit var issuerServices: MockServices + private lateinit var issuerServices: MockServices val vaultService: VaultService get() = services.vaultService lateinit var database: CordaPersistence private lateinit var notaryServices: MockServices @@ -77,7 +77,7 @@ class VaultWithCashTest { cordappPackages, makeTestIdentityService(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, dummyCashIssuer.identity, dummyNotary.identity), TestIdentity(MEGA_CORP.name, servicesKey), - moreKeys = dummyNotary.keyPair) + moreKeys = *arrayOf(dummyNotary.keyPair)) database = databaseAndServices.first services = databaseAndServices.second vaultFiller = VaultFiller(services, dummyNotary) @@ -130,7 +130,7 @@ class VaultWithCashTest { database.transaction { // A tx that spends our money. val spendTXBuilder = TransactionBuilder(DUMMY_NOTARY) - Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB) + Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB) val spendPTX = services.signInitialTransaction(spendTXBuilder, freshKey) notaryServices.addSignature(spendPTX) } @@ -178,7 +178,7 @@ class VaultWithCashTest { val first = backgroundExecutor.fork { database.transaction { val txn1Builder = TransactionBuilder(DUMMY_NOTARY) - Cash.generateSpend(services, txn1Builder, 60.DOLLARS, BOB) + Cash.generateSpend(services, txn1Builder, 60.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB) val ptxn1 = notaryServices.signInitialTransaction(txn1Builder) val txn1 = services.addSignature(ptxn1, freshKey) println("txn1: ${txn1.id} spent ${((txn1.tx.outputs[0].data) as Cash.State).amount}") @@ -209,7 +209,7 @@ class VaultWithCashTest { val second = backgroundExecutor.fork { database.transaction { val txn2Builder = TransactionBuilder(DUMMY_NOTARY) - Cash.generateSpend(services, txn2Builder, 80.DOLLARS, BOB) + Cash.generateSpend(services, txn2Builder, 80.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB) val ptxn2 = notaryServices.signInitialTransaction(txn2Builder) val txn2 = services.addSignature(ptxn2, freshKey) println("txn2: ${txn2.id} spent ${((txn2.tx.outputs[0].data) as Cash.State).amount}") @@ -333,7 +333,7 @@ class VaultWithCashTest { database.transaction { // A tx that spends our money. val spendTXBuilder = TransactionBuilder(DUMMY_NOTARY) - Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB) + Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB) val spendPTX = notaryServices.signInitialTransaction(spendTXBuilder) val spendTX = services.addSignature(spendPTX, freshKey) services.recordTransactions(spendTX) diff --git a/node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt b/node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt index 6adbcd890a9..d319c0b1d1d 100644 --- a/node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt +++ b/node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt @@ -13,7 +13,6 @@ import rx.Observable import rx.subjects.PublishSubject import java.io.Closeable import java.util.* -import kotlin.test.fail class ObservablesTests { private fun isInDatabaseTransaction() = contextTransactionOrNull != null @@ -58,7 +57,7 @@ class ObservablesTests { assertThat(secondEvent.get()).isEqualTo(0 to false) } - class TestException : Exception("Synthetic exception for tests") {} + class TestException : Exception("Synthetic exception for tests") @Test fun `bufferUntilDatabaseCommit swallows if transaction rolled back`() { @@ -83,7 +82,6 @@ class ObservablesTests { assertThat(secondEvent.isDone).isFalse() throw TestException() } - fail("Should not have successfully completed transaction") } catch (e: TestException) { } assertThat(secondEvent.isDone).isFalse() @@ -115,7 +113,6 @@ class ObservablesTests { assertThat(secondEvent.isDone).isFalse() throw TestException() } - fail("Should not have successfully completed transaction") } catch (e: TestException) { } assertThat(secondEvent.isDone).isTrue() diff --git a/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt b/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt index 04f157429ce..2d6c8761394 100644 --- a/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt +++ b/samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt @@ -1,10 +1,8 @@ package net.corda.attachmentdemo import net.corda.client.rpc.CordaRPCClient -import net.corda.core.messaging.CordaRPCOps import net.corda.core.utilities.getOrThrow -import net.corda.node.services.Permissions.Companion.invokeRpc -import net.corda.node.services.Permissions.Companion.startFlow +import net.corda.node.services.Permissions.Companion.all import net.corda.testing.core.DUMMY_BANK_A_NAME import net.corda.testing.core.DUMMY_BANK_B_NAME import net.corda.testing.driver.DriverParameters @@ -20,14 +18,7 @@ class AttachmentDemoTest { fun `attachment demo using a 10MB zip file`() { val numOfExpectedBytes = 10_000_000 driver(DriverParameters(isDebug = true, portAllocation = PortAllocation.Incremental(20000))) { - val demoUser = listOf(User("demo", "demo", setOf( - startFlow(), - invokeRpc(CordaRPCOps::attachmentExists), - invokeRpc(CordaRPCOps::uploadAttachment), - invokeRpc(CordaRPCOps::openAttachment), - invokeRpc(CordaRPCOps::wellKnownPartyFromX500Name), - invokeRpc(CordaRPCOps::internalVerifiedTransactionsFeed) - ))) + val demoUser = listOf(User("demo", "demo", setOf(all()))) val (nodeA, nodeB) = listOf( startNode(providedName = DUMMY_BANK_A_NAME, rpcUsers = demoUser, maximumHeapSize = "1g"), startNode(providedName = DUMMY_BANK_B_NAME, rpcUsers = demoUser, maximumHeapSize = "1g") diff --git a/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt b/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt index ebbfdab4b6e..052606583dc 100644 --- a/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt +++ b/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt @@ -86,14 +86,12 @@ fun sender(rpc: CordaRPCOps, numOfClearBytes: Int = 1024) { // default size 1K. } private fun sender(rpc: CordaRPCOps, inputStream: InputStream, hash: SecureHash.SHA256, executor: ScheduledExecutorService) { - // Get the identity key of the other side (the recipient). val notaryFuture: CordaFuture = poll(executor, DUMMY_NOTARY_NAME.toString()) { rpc.wellKnownPartyFromX500Name(DUMMY_NOTARY_NAME) } val otherSideFuture: CordaFuture = poll(executor, DUMMY_BANK_B_NAME.toString()) { rpc.wellKnownPartyFromX500Name(DUMMY_BANK_B_NAME) } // Make sure we have the file in storage if (!rpc.attachmentExists(hash)) { inputStream.use { - val avail = inputStream.available() val id = rpc.uploadAttachment(it) require(hash == id) { "Id was '$id' instead of '$hash'" } } @@ -133,6 +131,7 @@ class AttachmentDemoFlow(private val otherSide: Party, } } +@Suppress("DEPRECATION") // DOCSTART 1 fun recipient(rpc: CordaRPCOps, webPort: Int) { println("Waiting to receive transaction ...") diff --git a/samples/irs-demo/src/integration-test/kotlin/net/corda/test/spring/SpringDriver.kt b/samples/irs-demo/src/integration-test/kotlin/net/corda/test/spring/SpringDriver.kt index 83e438f4fda..a8645bf3418 100644 --- a/samples/irs-demo/src/integration-test/kotlin/net/corda/test/spring/SpringDriver.kt +++ b/samples/irs-demo/src/integration-test/kotlin/net/corda/test/spring/SpringDriver.kt @@ -1,3 +1,5 @@ +@file:Suppress("DEPRECATION") + package net.corda.test.spring import net.corda.core.concurrent.CordaFuture diff --git a/serialization/src/test/java/net/corda/serialization/internal/amqp/JavaGenericsTest.java b/serialization/src/test/java/net/corda/serialization/internal/amqp/JavaGenericsTest.java index d788948b982..40d3f1d311e 100644 --- a/serialization/src/test/java/net/corda/serialization/internal/amqp/JavaGenericsTest.java +++ b/serialization/src/test/java/net/corda/serialization/internal/amqp/JavaGenericsTest.java @@ -13,7 +13,7 @@ private static class Inner { private final Integer v; private Inner(Integer v) { this.v = v; } - public Integer getV() { return v; } + Integer getV() { return v; } } private static class A { @@ -25,7 +25,7 @@ private static class A { @Test public void basicGeneric() throws NotSerializableException { - A a1 = new A(1); + A a1 = new A<>(1); SerializerFactory factory = testDefaultFactory(); @@ -66,7 +66,7 @@ private A forceWildcardDeserializeFactory( @Test public void forceWildcard() throws NotSerializableException { - SerializedBytes bytes = forceWildcardSerialize(new A(new Inner(29))); + SerializedBytes bytes = forceWildcardSerialize(new A<>(new Inner(29))); Inner i = (Inner)forceWildcardDeserialize(bytes).getT(); assertEquals(29, i.getV()); } @@ -75,7 +75,7 @@ public void forceWildcard() throws NotSerializableException { public void forceWildcardSharedFactory() throws NotSerializableException { SerializerFactory factory = testDefaultFactory(); - SerializedBytes bytes = forceWildcardSerializeFactory(new A(new Inner(29)), factory); + SerializedBytes bytes = forceWildcardSerializeFactory(new A<>(new Inner(29)), factory); Inner i = (Inner)forceWildcardDeserializeFactory(bytes, factory).getT(); assertEquals(29, i.getV()); diff --git a/serialization/src/test/java/net/corda/serialization/internal/amqp/JavaPrivatePropertyTests.java b/serialization/src/test/java/net/corda/serialization/internal/amqp/JavaPrivatePropertyTests.java index 72b8395b6be..e96763360d9 100644 --- a/serialization/src/test/java/net/corda/serialization/internal/amqp/JavaPrivatePropertyTests.java +++ b/serialization/src/test/java/net/corda/serialization/internal/amqp/JavaPrivatePropertyTests.java @@ -7,6 +7,7 @@ import java.lang.reflect.Field; import java.util.Map; +import static net.corda.core.internal.InternalUtils.uncheckedCast; import static net.corda.serialization.internal.amqp.testutils.AMQPTestUtilsKt.testDefaultFactory; import static org.junit.Assert.*; @@ -30,6 +31,7 @@ static class B { B(Boolean b) { this.b = b; } + @SuppressWarnings("unused") public Boolean isB() { return this.b; } @@ -38,6 +40,7 @@ public Boolean isB() { static class B2 { private Boolean b; + @SuppressWarnings("unused") public Boolean isB() { return this.b; } @@ -50,6 +53,7 @@ public void setB(Boolean b) { static class B3 { private Boolean b; + @SuppressWarnings("unused") // break the BEAN format explicitly (i.e. it's not isB) public Boolean isb() { return this.b; @@ -67,6 +71,7 @@ public Integer getA() { return this.a; } + @SuppressWarnings("unused") public Boolean isA() { return this.a > 0; } @@ -145,7 +150,7 @@ public void singlePrivateWithConstructor() throws NotSerializableException, NoSu Field f = SerializerFactory.class.getDeclaredField("serializersByDescriptor"); f.setAccessible(true); - Map> serializersByDescriptor = (Map>) f.get(factory); + Map> serializersByDescriptor = uncheckedCast(f.get(factory)); assertEquals(1, serializersByDescriptor.size()); ObjectSerializer cSerializer = ((ObjectSerializer)serializersByDescriptor.values().toArray()[0]); @@ -172,7 +177,7 @@ public void singlePrivateWithConstructorAndGetter() // Field f = SerializerFactory.class.getDeclaredField("serializersByDescriptor"); f.setAccessible(true); - Map> serializersByDescriptor = (Map>) f.get(factory); + Map> serializersByDescriptor = uncheckedCast(f.get(factory)); assertEquals(1, serializersByDescriptor.size()); ObjectSerializer cSerializer = ((ObjectSerializer)serializersByDescriptor.values().toArray()[0]); diff --git a/serialization/src/test/kotlin/net/corda/serialization/internal/ContractAttachmentSerializerTest.kt b/serialization/src/test/kotlin/net/corda/serialization/internal/ContractAttachmentSerializerTest.kt index 9bef17e21c6..a4d17cc52e1 100644 --- a/serialization/src/test/kotlin/net/corda/serialization/internal/ContractAttachmentSerializerTest.kt +++ b/serialization/src/test/kotlin/net/corda/serialization/internal/ContractAttachmentSerializerTest.kt @@ -17,7 +17,6 @@ import org.junit.Test import kotlin.test.assertEquals class ContractAttachmentSerializerTest { - @Rule @JvmField val testSerialization = SerializationEnvironmentRule() @@ -51,7 +50,7 @@ class ContractAttachmentSerializerTest { fun `write contract attachment and read it back using token context`() { val attachment = GeneratedAttachment("test".toByteArray()) - mockServices.attachments.importAttachment(attachment.open()) + mockServices.attachments.importAttachment(attachment.open(), "test", null) val contractAttachment = ContractAttachment(attachment, DummyContract.PROGRAM_ID) val serialized = contractAttachment.serialize(factory, contextWithToken) @@ -68,7 +67,7 @@ class ContractAttachmentSerializerTest { val largeAttachmentSize = 1024 * 1024 val attachment = GeneratedAttachment(ByteArray(largeAttachmentSize)) - mockServices.attachments.importAttachment(attachment.open()) + mockServices.attachments.importAttachment(attachment.open(), "test", null) val contractAttachment = ContractAttachment(attachment, DummyContract.PROGRAM_ID) val serialized = contractAttachment.serialize(factory, contextWithToken) diff --git a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/ErrorMessagesTests.kt b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/ErrorMessagesTests.kt index 0d87de40a84..f1e053cc43b 100644 --- a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/ErrorMessagesTests.kt +++ b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/ErrorMessagesTests.kt @@ -2,10 +2,9 @@ package net.corda.serialization.internal.amqp import net.corda.serialization.internal.amqp.testutils.TestSerializationOutput import net.corda.serialization.internal.amqp.testutils.deserialize -import net.corda.serialization.internal.amqp.testutils.serialize import net.corda.serialization.internal.amqp.testutils.testDefaultFactory import net.corda.serialization.internal.amqp.testutils.testName -import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThatThrownBy import org.junit.Ignore import org.junit.Test import java.io.NotSerializableException @@ -28,7 +27,7 @@ class ErrorMessagesTests { val testname = "${javaClass.name}\$${testName()}" - Assertions.assertThatThrownBy { + assertThatThrownBy { TestSerializationOutput(VERBOSE, sf).serialize(C(1)) }.isInstanceOf(NotSerializableException::class.java).hasMessage(errMsg("a", testname)) } @@ -43,7 +42,7 @@ class ErrorMessagesTests { val testname = "${javaClass.name}\$${testName()}" - Assertions.assertThatThrownBy { + assertThatThrownBy { TestSerializationOutput(VERBOSE, sf).serialize(C(1, 2)) }.isInstanceOf(NotSerializableException::class.java).hasMessage(errMsg("b", testname)) } @@ -55,28 +54,27 @@ class ErrorMessagesTests { // despite b being private, the getter we've added is public and thus allows for the serialisation // of the object data class C(val a: Int, private val b: Int) { - public fun getB() = b + @Suppress("unused") + fun getB() = b } val sf = testDefaultFactory() - val testname = "${javaClass.name}\$${testName()}" - val bytes = TestSerializationOutput(VERBOSE, sf).serialize(C(1, 2)) - val c = DeserializationInput(sf).deserialize(bytes) + DeserializationInput(sf).deserialize(bytes) } // Java allows this to be set at the class level yet Kotlin doesn't for some reason @Ignore("Current behaviour allows for the serialization of objects with private members, this will be disallowed at some point in the future") @Test fun protectedProperty() { - data class C(protected val a: Int) + open class C(@Suppress("unused") protected val a: Int) val sf = testDefaultFactory() val testname = "${javaClass.name}\$${testName()}" - Assertions.assertThatThrownBy { + assertThatThrownBy { TestSerializationOutput(VERBOSE, sf).serialize(C(1)) }.isInstanceOf(NotSerializableException::class.java).hasMessage(errMsg("a", testname)) } diff --git a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/GenericsTests.kt b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/GenericsTests.kt index a99fefd455c..af68f8d669c 100644 --- a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/GenericsTests.kt +++ b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/GenericsTests.kt @@ -277,7 +277,7 @@ class GenericsTests { private fun fingerprintingDiffersStrip(state: Any) { class cl : ClassLoader() - val m = ClassLoader::class.java.getDeclaredMethod("findLoadedClass", *arrayOf>(String::class.java)) + val m = ClassLoader::class.java.getDeclaredMethod("findLoadedClass", String::class.java) m.isAccessible = true val factory1 = testDefaultFactory() @@ -295,16 +295,16 @@ class GenericsTests { // now deserialise those objects val factory3 = testDefaultFactory() factory3.register(net.corda.serialization.internal.amqp.custom.PublicKeySerializer) - val des1 = DeserializationInput(factory3).deserializeAndReturnEnvelope(ser1.obj) + DeserializationInput(factory3).deserializeAndReturnEnvelope(ser1.obj) val factory4 = SerializerFactory(AllWhitelist, cl()) factory4.register(net.corda.serialization.internal.amqp.custom.PublicKeySerializer) - val des2 = DeserializationInput(factory4).deserializeAndReturnEnvelope(ser2.obj) + DeserializationInput(factory4).deserializeAndReturnEnvelope(ser2.obj) } @Test fun fingerprintingDiffers() { - val state = TransactionState ( + val state = TransactionState( TestContractState(listOf(miniCorp.party)), "wibble", miniCorp.party, encumbrance = null, @@ -317,7 +317,7 @@ class GenericsTests { @Test fun fingerprintingDiffersList() { - val state = TransactionState ( + val state = TransactionState( TestContractState(listOf(miniCorp.party)), "wibble", miniCorp.party, encumbrance = null, diff --git a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/PrivatePropertyTests.kt b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/PrivatePropertyTests.kt index ce6a0e9084e..732f8cf313e 100644 --- a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/PrivatePropertyTests.kt +++ b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/PrivatePropertyTests.kt @@ -97,7 +97,7 @@ class PrivatePropertyTests { @ConstructorForDeserialization constructor() : this(0, 0) - fun setA(a: Int, b: Int) { this.a = a } + fun setA(a: Int, @Suppress("UNUSED_PARAMETER") b: Int) { this.a = a } fun getA() = a } diff --git a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/RoundTripTests.kt b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/RoundTripTests.kt index 575794be83b..381032cfbde 100644 --- a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/RoundTripTests.kt +++ b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/RoundTripTests.kt @@ -4,7 +4,8 @@ import net.corda.core.serialization.ConstructorForDeserialization import net.corda.serialization.internal.amqp.testutils.deserialize import net.corda.serialization.internal.amqp.testutils.serialize import net.corda.serialization.internal.amqp.testutils.testDefaultFactoryNoEvolution -import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThat +import org.assertj.core.api.Assertions.assertThatThrownBy import org.junit.Test class RoundTripTests { @@ -16,20 +17,15 @@ class RoundTripTests { val bytes = SerializationOutput(factory).serialize(C(mutableListOf("a", "b", "c"))) val newC = DeserializationInput(factory).deserialize(bytes) - Assertions.assertThatThrownBy { + assertThatThrownBy { newC.l.add("d") }.isInstanceOf(UnsupportedOperationException::class.java) } @Test fun mutableStillMutable() { - class C { - val l: MutableList - - @Suppress("Unused") - constructor (l: MutableList) { - this.l = l.toMutableList() - } + class C(l: MutableList) { + val l: MutableList = l.toMutableList() } val factory = testDefaultFactoryNoEvolution() @@ -37,6 +33,7 @@ class RoundTripTests { val newC = DeserializationInput(factory).deserialize(bytes) newC.l.add("d") + assertThat(newC.l).containsExactly("a", "b", "c", "d") } @Test @@ -52,6 +49,7 @@ class RoundTripTests { val newC = DeserializationInput(factory).deserialize(bytes) newC.l.add("d") + assertThat(newC.l).containsExactly("a", "b", "c", "d") } @Test @@ -61,6 +59,6 @@ class RoundTripTests { val factory = testDefaultFactoryNoEvolution() val bytes = SerializationOutput(factory).serialize(C(listOf("a", "b", "c"))) val newC = DeserializationInput(factory).deserialize(bytes) - val newC2 = newC.copy(l = (newC.l + "d")) + newC.copy(l = (newC.l + "d")) } -} \ No newline at end of file +} diff --git a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/SerializationOutputTests.kt b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/SerializationOutputTests.kt index a4b73fb283e..5a368b83043 100644 --- a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/SerializationOutputTests.kt +++ b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/SerializationOutputTests.kt @@ -888,6 +888,7 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi class GenericSubclass(param: OtherGeneric) : GenericSuperclass(param) { override fun equals(other: Any?): Boolean = other is GenericSubclass // This is a bit lame but we just want to check it doesn't throw exceptions + override fun hashCode(): Int = javaClass.hashCode() } @Test @@ -966,8 +967,10 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi assertSame(objCopy.a, objCopy.b) } - data class Spike private constructor(val a: String) { + class Spike private constructor(val a: String) { constructor() : this("a") + override fun equals(other: Any?): Boolean = other is Spike && other.a == this.a + override fun hashCode(): Int = a.hashCode() } @Test @@ -1028,7 +1031,7 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi serdes(obj, factory, factory2) } - data class ByteArrays(val a: ByteArray, val b: ByteArray) + class ByteArrays(val a: ByteArray, val b: ByteArray) @Test fun `test byte arrays not reference counted`() { @@ -1162,7 +1165,7 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi } // - // Example stacktrace that this test is tryint to reproduce + // Example stacktrace that this test is trying to reproduce // // java.lang.IllegalArgumentException: // net.corda.core.contracts.TransactionState -> @@ -1179,10 +1182,6 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi // @Test fun reproduceWrongNumberOfArguments() { - val field = SerializerFactory::class.java.getDeclaredField("serializersByType").apply { - this.isAccessible = true - } - data class C(val a: Amount) val factory = testDefaultFactoryNoEvolution() @@ -1337,7 +1336,7 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi val bytes = SerializationOutput(testDefaultFactory()).serialize(i) try { - val i2 = DeserializationInput(testDefaultFactory()).deserialize(bytes) + DeserializationInput(testDefaultFactory()).deserialize(bytes) } catch (e: NotSerializableException) { throw Error("Deserializing serialized \$C should not throw") } diff --git a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/SerializationPropertyOrdering.kt b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/SerializationPropertyOrdering.kt index 59f4f8fc1df..0e1f8788f37 100644 --- a/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/SerializationPropertyOrdering.kt +++ b/serialization/src/test/kotlin/net/corda/serialization/internal/amqp/SerializationPropertyOrdering.kt @@ -35,7 +35,7 @@ class SerializationPropertyOrdering { val u = User(l,l) val output = TestSerializationOutput(VERBOSE, sf).serializeAndReturnSchema(u) - val input = DeserializationInput(sf).deserialize(output.obj) + DeserializationInput(sf).deserialize(output.obj) } @Test diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/MockKeyManagementService.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/MockKeyManagementService.kt index fa835a2a49f..53664ea9f15 100644 --- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/MockKeyManagementService.kt +++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/MockKeyManagementService.kt @@ -34,7 +34,7 @@ class MockKeyManagementService(val identityService: IdentityService, override fun filterMyKeys(candidateKeys: Iterable): Iterable = candidateKeys.filter { it in this.keys } override fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean): PartyAndCertificate { - return freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey), revocationEnabled) + return freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey)) } private fun getSigner(publicKey: PublicKey): ContentSigner = net.corda.node.services.keys.getSigner(getSigningKeyPair(publicKey)) diff --git a/testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/NodeBasedTest.kt b/testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/NodeBasedTest.kt index 7fbd49e067c..6eef21a1b31 100644 --- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/NodeBasedTest.kt +++ b/testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/NodeBasedTest.kt @@ -67,10 +67,10 @@ abstract class NodeBasedTest(private val cordappPackages: List = emptyLi // Wait until ports are released val portNotBoundChecks = nodes.flatMap { listOf( - it.internals.configuration.p2pAddress.let { addressMustNotBeBoundFuture(shutdownExecutor, it) }, - it.internals.configuration.rpcOptions.address?.let { addressMustNotBeBoundFuture(shutdownExecutor, it) } + addressMustNotBeBoundFuture(shutdownExecutor, it.internals.configuration.p2pAddress), + addressMustNotBeBoundFuture(shutdownExecutor, it.internals.configuration.rpcOptions.address) ) - }.filterNotNull() + } nodes.clear() portNotBoundChecks.transpose().getOrThrow() } finally { diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/internal/InternalTestUtils.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/internal/InternalTestUtils.kt index 9a2386497ae..5b4555e547d 100644 --- a/testing/test-utils/src/main/kotlin/net/corda/testing/internal/InternalTestUtils.kt +++ b/testing/test-utils/src/main/kotlin/net/corda/testing/internal/InternalTestUtils.kt @@ -1,11 +1,14 @@ package net.corda.testing.internal +import net.corda.core.contracts.* import net.corda.core.crypto.Crypto import net.corda.core.crypto.Crypto.generateKeyPair +import net.corda.core.crypto.SecureHash import net.corda.core.identity.CordaX500Name import net.corda.core.identity.Party import net.corda.core.identity.PartyAndCertificate import net.corda.core.node.NodeInfo +import net.corda.core.transactions.WireTransaction import net.corda.core.utilities.NetworkHostAndPort import net.corda.core.utilities.loggerFor import net.corda.node.services.config.configureDevKeyAndTrustStores @@ -139,3 +142,15 @@ fun createNodeSslConfig(path: Path, name: CordaX500Name = CordaX500Name("MegaCor return sslConfig } + +/** This is the same as the deprecated [WireTransaction] c'tor but avoids the deprecation warning. */ +fun createWireTransaction(inputs: List, + attachments: List, + outputs: List>, + commands: List>, + notary: Party?, + timeWindow: TimeWindow?, + privacySalt: PrivacySalt = PrivacySalt()): WireTransaction { + val componentGroups = WireTransaction.createComponentGroups(inputs, outputs, commands, attachments, notary, timeWindow) + return WireTransaction(componentGroups, privacySalt) +} diff --git a/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt b/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt index abd626159b4..a63943bcc65 100644 --- a/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt +++ b/tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt @@ -186,6 +186,7 @@ class NodeTerminalView : Fragment() { invoke = ::pollCashBalances ) + @Suppress("DEPRECATION") private fun initialise(config: NodeConfigWrapper, ops: CordaRPCOps) { try { val (txInit, txNext) = ops.internalVerifiedTransactionsFeed() diff --git a/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/cli/CommandLineInterface.kt b/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/cli/CommandLineInterface.kt index 1836f5e76a0..8ea71b8a43a 100644 --- a/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/cli/CommandLineInterface.kt +++ b/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/cli/CommandLineInterface.kt @@ -13,7 +13,6 @@ import java.io.File class CommandLineInterface { - fun run(parsedArgs: CliParser) { val baseDir = parsedArgs.baseDirectory val cacheDir = File(baseDir, Constants.BOOTSTRAPPER_DIR_NAME) @@ -37,7 +36,7 @@ class CommandLineInterface { .build().getOrThrow() persistContext(contextFile, objectMapper, context) } else { - val context = setupContextFromExisting(contextFile, objectMapper, networkName) + val context = setupContextFromExisting(contextFile, objectMapper) val (_, instantiator, _) = Backend.fromContext(context, cacheDir) val nodeAdder = NodeAdder(context, NodeInstantiator(instantiator, context)) parsedArgs.nodesToAdd.map { @@ -48,7 +47,7 @@ class CommandLineInterface { } - private fun setupContextFromExisting(contextFile: File, objectMapper: ObjectMapper, networkName: String): Context { + private fun setupContextFromExisting(contextFile: File, objectMapper: ObjectMapper): Context { return contextFile.let { if (it.exists()) { it.inputStream().use { diff --git a/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/context/Context.kt b/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/context/Context.kt index 8b72714c8d6..ab689eb47f5 100644 --- a/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/context/Context.kt +++ b/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/context/Context.kt @@ -23,7 +23,7 @@ class Context(val networkName: String, val backendType: Backend.BackendType, bac var extraParams = ConcurrentHashMap(backendOptions) private fun registerNode(name: String, nodeInstanceRequest: NodeInstanceRequest) { - nodes.computeIfAbsent(name, { _ -> ConcurrentHashSet() }).add(nodeInstanceRequest.toPersistable()) + nodes.computeIfAbsent(name) { ConcurrentHashSet() }.add(nodeInstanceRequest.toPersistable()) } fun registerNode(request: NodeInstanceRequest) { @@ -53,7 +53,7 @@ class Context(val networkName: String, val backendType: Backend.BackendType, bac nodeInstanceRequest.actualX500, nodeInstanceRequest.localImageId, nodeInstanceRequest.remoteImageName, - nodeInstanceRequest.nodeConfig.rpcOptions.address!!.port, + nodeInstanceRequest.nodeConfig.rpcOptions.address.port, nodeInstanceRequest.expectedFqName, "", "" @@ -62,8 +62,7 @@ class Context(val networkName: String, val backendType: Backend.BackendType, bac } } - fun NodeInstanceRequest.toPersistable(): PersistableNodeInstance { + private fun NodeInstanceRequest.toPersistable(): PersistableNodeInstance { return fromInstanceRequest(this) } } - diff --git a/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/nodes/NodeFinder.kt b/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/nodes/NodeFinder.kt index 9c2b75d94bc..4de42a5224e 100644 --- a/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/nodes/NodeFinder.kt +++ b/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/nodes/NodeFinder.kt @@ -2,12 +2,11 @@ package net.corda.bootstrapper.nodes import com.typesafe.config.ConfigFactory import net.corda.bootstrapper.Constants -import org.slf4j.LoggerFactory +import net.corda.core.utilities.contextLogger import java.io.File class NodeFinder(private val scratchDir: File) { - fun findNodes(): List { return scratchDir.walkBottomUp().filter { it.name == "node.conf" && !it.absolutePath.contains(Constants.BOOTSTRAPPER_DIR_NAME) }.map { try { @@ -17,7 +16,7 @@ class NodeFinder(private val scratchDir: File) { } }.filterNotNull() .filter { !it.first.hasPath("notary") } - .map { (nodeConfig, nodeConfigFile) -> + .map { (_, nodeConfigFile) -> LOG.info("We've found a node with name: ${nodeConfigFile.parentFile.name}") FoundNode(nodeConfigFile, nodeConfigFile.parentFile) }.toList() @@ -25,7 +24,7 @@ class NodeFinder(private val scratchDir: File) { } companion object { - val LOG = LoggerFactory.getLogger(NodeFinder::class.java) + val LOG = contextLogger() } } diff --git a/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/nodes/NodeInstantiator.kt b/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/nodes/NodeInstantiator.kt index 1c7f0ac6f6f..9de81220a97 100644 --- a/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/nodes/NodeInstantiator.kt +++ b/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/nodes/NodeInstantiator.kt @@ -39,40 +39,37 @@ class NodeInstantiator(val instantiator: Instantiator, } fun instantiateNodeInstance(request: Context.PersistableNodeInstance): CompletableFuture { - return instantiateNodeInstance(request.remoteImageName, request.rpcPort!!, request.instanceName, request.fqdn, request.instanceX500).thenApplyAsync { + return instantiateNodeInstance(request.remoteImageName, request.instanceName, request.fqdn, request.instanceX500).thenApplyAsync { InstanceInfo(request.groupName, request.instanceName, request.fqdn, it.first, it.second) } } fun instantiateNodeInstance(request: NodeInstanceRequest): CompletableFuture { - return instantiateNodeInstance(request.remoteImageName, request.nodeConfig.rpcOptions.address!!.port, request.nodeInstanceName, request.expectedFqName, request.actualX500) + return instantiateNodeInstance(request.remoteImageName, request.nodeInstanceName, request.expectedFqName, request.actualX500) .thenApplyAsync { (reachableName, portMapping) -> request.toNodeInstance(reachableName, portMapping) } } fun instantiateNotaryInstance(request: NodeInstanceRequest): CompletableFuture { - return instantiateNotaryInstance(request.remoteImageName, request.nodeConfig.rpcOptions.address!!.port, request.nodeInstanceName, request.expectedFqName) + return instantiateNotaryInstance(request.remoteImageName, request.nodeInstanceName, request.expectedFqName) .thenApplyAsync { (reachableName, portMapping) -> request.toNodeInstance(reachableName, portMapping) } } private fun instantiateNotaryInstance(remoteImageName: String, - rpcPort: Int, nodeInstanceName: String, expectedFqName: String): CompletableFuture>> { return instantiator.instantiateContainer( remoteImageName, listOf(Constants.NODE_P2P_PORT, Constants.NODE_RPC_PORT, Constants.NODE_SSHD_PORT), nodeInstanceName, - mapOf("OUR_NAME" to expectedFqName, - "OUR_PORT" to Constants.NODE_P2P_PORT.toString()) + mapOf("OUR_NAME" to expectedFqName, "OUR_PORT" to Constants.NODE_P2P_PORT.toString()) ) } private fun instantiateNodeInstance(remoteImageName: String, - rpcPort: Int, nodeInstanceName: String, expectedFqName: String, actualX500: String): CompletableFuture>> { diff --git a/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/serialization/SerializationHelper.kt b/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/serialization/SerializationHelper.kt index d3d867c461b..8e350c8c149 100644 --- a/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/serialization/SerializationHelper.kt +++ b/tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/serialization/SerializationHelper.kt @@ -7,13 +7,12 @@ import net.corda.serialization.internal.AMQP_P2P_CONTEXT import net.corda.serialization.internal.AMQP_STORAGE_CONTEXT import net.corda.serialization.internal.SerializationFactoryImpl - class SerializationEngine { companion object { fun init() { synchronized(this) { if (nodeSerializationEnv == null) { - val classloader = this.javaClass.classLoader + val classloader = this::class.java.classLoader nodeSerializationEnv = SerializationEnvironmentImpl( SerializationFactoryImpl().apply { registerScheme(AMQPServerSerializationScheme(emptyList())) @@ -27,4 +26,4 @@ class SerializationEngine { } } } -} \ No newline at end of file +}