diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 43a1d65c41..6c83ad467d 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -170,6 +170,8 @@ + + diff --git a/build.gradle b/build.gradle index 98b427c6e3..c5ca2ff0f3 100644 --- a/build.gradle +++ b/build.gradle @@ -188,6 +188,7 @@ allprojects { jvmTarget = "1.8" javaParameters = true // Useful for reflection. freeCompilerArgs = ['-Xjvm-default=compatibility'] + allWarningsAsErrors = true } } diff --git a/buildSrc/jarfilter/kotlin-metadata/build.gradle b/buildSrc/jarfilter/kotlin-metadata/build.gradle index b509187551..561cea19a1 100644 --- a/buildSrc/jarfilter/kotlin-metadata/build.gradle +++ b/buildSrc/jarfilter/kotlin-metadata/build.gradle @@ -39,7 +39,6 @@ task metadata(type: ProGuardTask) { keepattributes '*' dontoptimize - printseeds verbose dontwarn 'com.sun.jna.**' @@ -47,6 +46,7 @@ task metadata(type: ProGuardTask) { dontwarn 'org.jetbrains.kotlin.com.intellij.**' dontwarn 'org.jetbrains.kotlin.com.google.j2objc.annotations.**' dontwarn 'org.jetbrains.kotlin.com.google.errorprone.annotations.**' + dontnote keep 'class org.jetbrains.kotlin.load.java.JvmAnnotationNames { *; }' keep 'class org.jetbrains.kotlin.metadata.** { *; }', includedescriptorclasses: true @@ -68,6 +68,7 @@ task validate(type: ProGuardTask) { verbose dontwarn 'org.jetbrains.kotlin.com.google.errorprone.annotations.**' + dontnote keep 'class *' } @@ -77,5 +78,4 @@ artifacts { } defaultTasks "metadata" -assemble.dependsOn metadata metadata.finalizedBy validate diff --git a/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt b/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt index 420be1a61a..29e237df2c 100644 --- a/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt +++ b/client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt @@ -401,6 +401,11 @@ class JacksonSupportTest(@Suppress("unused") private val name: String, factory: testToStringSerialisation(UUID.randomUUID()) } + @Test + fun Instant() { + testToStringSerialisation(Instant.now()) + } + @Test fun `Date is treated as Instant`() { val date = Date() 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 7a772e4022..e0a2bb2ba5 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 @@ -13,7 +13,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 @@ -32,12 +31,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 @@ -75,18 +71,7 @@ class NodeMonitorModelTest : IntegrationTest() { 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 } @@ -135,11 +120,7 @@ class NodeMonitorModelTest : IntegrationTest() { @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 555af2e2f8..e79a718658 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 @@ -111,12 +111,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 5865e7dffd..4f34590880 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 @@ -58,7 +58,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 { @@ -74,7 +74,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 { @@ -94,6 +94,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 1d278ad1e0..87ecd1d0a6 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 @@ -84,14 +84,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) @@ -104,7 +102,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 @@ -118,7 +115,6 @@ class FlowsExecutionModeTests : NodeBasedTest(listOf("net.corda.finance.contract @Test fun `node starts with flows draining mode disabled`() { - asALoggerUser { rpcOps -> val defaultStartingMode = rpcOps.isFlowsDrainingModeEnabled() @@ -127,14 +123,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-deterministic/build.gradle b/core-deterministic/build.gradle index 8f84a5d5ad..c2d2f65f79 100644 --- a/core-deterministic/build.gradle +++ b/core-deterministic/build.gradle @@ -90,6 +90,7 @@ task predeterminise(type: ProGuardTask) { dontpreverify dontobfuscate dontoptimize + dontnote printseeds verbose @@ -133,6 +134,7 @@ task determinise(type: ProGuardTask) { keepattributes '*' keepdirectories dontobfuscate + dontnote printseeds verbose @@ -178,7 +180,6 @@ task checkDeterminism(type: ProGuardTask, dependsOn: jdkTask) { defaultTasks "determinise" determinise.finalizedBy metafix metafix.finalizedBy checkDeterminism -assemble.dependsOn checkDeterminism def deterministicJar = metafix.outputs.files.singleFile artifacts { diff --git a/core/src/main/kotlin/net/corda/core/flows/StateMachineRunId.kt b/core/src/main/kotlin/net/corda/core/flows/StateMachineRunId.kt index db56f7b7a3..13d75d5fe9 100644 --- a/core/src/main/kotlin/net/corda/core/flows/StateMachineRunId.kt +++ b/core/src/main/kotlin/net/corda/core/flows/StateMachineRunId.kt @@ -18,10 +18,10 @@ import java.util.* * A unique identifier for a single state machine run, valid across node restarts. Note that a single run always * has at least one flow, but that flow may also invoke sub-flows: they all share the same run id. */ +@DeleteForDJVM @CordaSerializable data class StateMachineRunId(val uuid: UUID) { companion object { - @DeleteForDJVM fun createRandom(): StateMachineRunId = StateMachineRunId(UUID.randomUUID()) } diff --git a/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt b/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt index d922d4dbf3..f83db058e5 100644 --- a/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt +++ b/core/src/main/kotlin/net/corda/core/internal/FlowStateMachine.kt @@ -11,6 +11,7 @@ package net.corda.core.internal import co.paralleluniverse.fibers.Suspendable +import net.corda.core.DeleteForDJVM import net.corda.core.DoNotImplement import net.corda.core.concurrent.CordaFuture import net.corda.core.context.InvocationContext @@ -20,6 +21,7 @@ import net.corda.core.node.ServiceHub import org.slf4j.Logger /** This is an internal interface that is implemented by code in the node module. You should look at [FlowLogic]. */ +@DeleteForDJVM @DoNotImplement interface FlowStateMachine { @Suspendable 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 b7217a017e..89d62e6cfb 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 @@ -12,11 +12,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 fc4788a213..4d5cf9e683 100644 --- a/core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt +++ b/core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt @@ -140,7 +140,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 202eb21278..e081e42aac 100644 --- a/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt +++ b/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt @@ -58,7 +58,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 05087eb60f..61384a28c8 100644 --- a/core/src/test/kotlin/net/corda/core/contracts/ContractsDSLTests.kt +++ b/core/src/test/kotlin/net/corda/core/contracts/ContractsDSLTests.kt @@ -41,7 +41,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}") @@ -74,7 +75,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}") @@ -122,7 +124,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 0393f7aeab..7ff62ad728 100644 --- a/core/src/test/kotlin/net/corda/core/crypto/PartialMerkleTreeTest.kt +++ b/core/src/test/kotlin/net/corda/core/crypto/PartialMerkleTreeTest.kt @@ -30,6 +30,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 @@ -274,7 +275,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 e7b4895c81..589f16c3be 100644 --- a/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt +++ b/core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt @@ -67,7 +67,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. @@ -120,7 +120,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 25ee774c48..466d51345d 100644 --- a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt +++ b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt @@ -156,7 +156,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) @@ -211,6 +211,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 1c4f76cad9..6237a1a019 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 6f1620daa2..f57303780d 100644 --- a/core/src/test/kotlin/net/corda/core/transactions/TransactionTests.kt +++ b/core/src/test/kotlin/net/corda/core/transactions/TransactionTests.kt @@ -18,6 +18,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 @@ -63,7 +64,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(), @@ -89,7 +90,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(), @@ -129,8 +130,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, @@ -147,7 +148,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(), @@ -170,7 +171,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, @@ -188,7 +189,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 03dc2eb7d4..8a09b9efce 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 @@ -50,6 +50,7 @@ enum class PrintOrVisualise { Visualise } +@Suppress("DEPRECATION") fun main(args: Array) { require(args.isNotEmpty()) { "Usage: [Print|Visualise]" } val printOrVisualise = PrintOrVisualise.valueOf(args[0]) @@ -109,6 +110,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 c50a70841f..a35b8803d8 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 @@ -8,7 +8,7 @@ * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. */ -@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/tutorial/tearoffs/TutorialTearOffs.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt index a33bede8fb..82054737a6 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 @@ -8,6 +8,8 @@ * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. */ +@file:Suppress("UNUSED_VARIABLE") + package net.corda.docs.tutorial.tearoffs import net.corda.core.contracts.Command @@ -52,4 +54,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/docs/source/running-a-node.rst b/docs/source/running-a-node.rst index faef8eb2bf..dbcf66bc2c 100644 --- a/docs/source/running-a-node.rst +++ b/docs/source/running-a-node.rst @@ -43,6 +43,27 @@ Optionally run the node's webserver as well by opening a terminal window in the .. warning:: The node webserver is for testing purposes only and will be removed soon. +Command-line options +~~~~~~~~~~~~~~~~~~~~ +The node can optionally be started with the following command-line options: + +* ``--base-directory``: The node working directory where all the files are kept (default: ``.``) +* ``--bootstrap-raft-cluster``: Bootstraps Raft cluster. The node forms a single node cluster (ignoring otherwise configured peer + addresses), acting as a seed for other nodes to join the cluster +* ``--config-file``: The path to the config file (default: ``node.conf``) +* ``--help`` +* ``--initial-registration``: Start initial node registration with Corda network to obtain certificate from the permissioning + server +* ``--just-generate-node-info``: Perform the node start-up task necessary to generate its nodeInfo, save it to disk, then + quit +* ``--log-to-console``: If set, prints logging to the console as well as to a file +* ``--logging-level <[ERROR,WARN,INFO, DEBUG,TRACE]>``: Enable logging at this level and higher (default: INFO) +* ``--network-root-truststore``: Network root trust store obtained from network operator +* ``--network-root-truststore-password``: Network root trust store password obtained from network operator +* ``--no-local-shell``: Do not start the embedded shell locally +* ``--sshd``: Enables SSHD server for node administration +* ``--version``: Print the version and exit + Enabling remote debugging ~~~~~~~~~~~~~~~~~~~~~~~~~ To enable remote debugging of the node, run the following from the terminal window: @@ -61,8 +82,11 @@ This command line will start the node with JMX metrics accessible via HTTP on po See :ref:`Monitoring your node ` for further details. -Starting all nodes at once from the command line (native) ---------------------------------------------------------- +Starting all nodes at once from the command line +------------------------------------------------ + +Native +~~~~~~ If you created your nodes using ``deployNodes``, a ``runnodes`` shell script (or batch file on Windows) will have been generated to allow you to quickly start up all nodes and their webservers. ``runnodes`` should only be used for testing purposes. @@ -79,8 +103,8 @@ If you receive an ``OutOfMemoryError`` exception when interacting with the nodes Java heap memory available to them, which you can do when running them individually. See :ref:`starting-an-individual-corda-node`. -Starting all nodes at once from the command line (docker-compose) ------------------------------------------------------------------ +docker-compose +~~~~~~~~~~~~~~ If you created your nodes using ``Dockerform``, the ``docker-compose.yml`` file and corresponding ``Dockerfile`` for nodes has been created and configured appropriately. Navigate to ``build/nodes`` directory and run ``docker-compose up`` command. This will startup nodes inside new, internal network. diff --git a/docs/source/tutorial-cordapp.rst b/docs/source/tutorial-cordapp.rst index 961b17c6dd..eba4a85348 100644 --- a/docs/source/tutorial-cordapp.rst +++ b/docs/source/tutorial-cordapp.rst @@ -411,32 +411,38 @@ For more information on the client RPC interface and how to build an RPC client Running nodes across machines ----------------------------- -The nodes can be split across different machines and configured to communicate across the network. +The nodes can be configured to communicate as a network even when distributed across several machines: -After deploying the nodes, navigate to the build folder (``kotlin-source/build/nodes``) and for each node that needs to -be moved to another machine open its config file and change the Artemis messaging address to the IP address of the machine -where the node will run (e.g. ``p2pAddress="10.18.0.166:10007"``). +* Deploy the nodes as usual: -These changes require new node-info files to be distributed amongst the nodes. Use the network bootstrapper tool -(see :doc:`network-bootstrapper` for more information on this and how to built it) to update the files and have -them distributed locally. + * Unix/Mac OSX: ``./gradlew deployNodes`` + * Windows: ``gradlew.bat deployNodes`` -``java -jar network-bootstrapper.jar kotlin-source/build/nodes`` +* Navigate to the build folder (``kotlin-source/build/nodes``) +* For each node, open its ``node.conf`` file and change ``localhost`` in its ``p2pAddress`` to the IP address of the machine + where the node will be run (e.g. ``p2pAddress="10.18.0.166:10007"``) +* These changes require new node-info files to be distributed amongst the nodes. Use the network bootstrapper tool + (see :doc:`network-bootstrapper`) to update the files and have them distributed locally: -Once that's done move the node folders to their designated machines (e.g. using a USB key). It is important that none of the -nodes - including the notary - end up on more than one machine. Each computer should also have a copy of ``runnodes`` -and ``runnodes.bat``. + ``java -jar network-bootstrapper.jar kotlin-source/build/nodes`` -For example, you may end up with the following layout: +* Move the node folders to their individual machines (e.g. using a USB key). It is important that none of the + nodes - including the notary - end up on more than one machine. Each computer should also have a copy of ``runnodes`` + and ``runnodes.bat``. -* Machine 1: ``Notary``, ``PartyA``, ``runnodes``, ``runnodes.bat`` -* Machine 2: ``PartyB``, ``PartyC``, ``runnodes``, ``runnodes.bat`` + For example, you may end up with the following layout: -After starting each node, the nodes will be able to see one another and agree IOUs among themselves. + * Machine 1: ``Notary``, ``PartyA``, ``runnodes``, ``runnodes.bat`` + * Machine 2: ``PartyB``, ``PartyC``, ``runnodes``, ``runnodes.bat`` -.. note:: If you are using H2 and wish to use the same ``h2port`` value for all the nodes, then only assign them that - value after the nodes have been moved to their machines. The initial bootstrapping process requires access to the nodes' - databases and if they share the same H2 port then the process will fail. +* After starting each node, the nodes will be able to see one another and agree IOUs among themselves + +.. warning:: The bootstrapper must be run **after** the ``node.conf`` files have been modified, but **before** the nodes + are distributed across machines. Otherwise, the nodes will not be able to communicate. + +.. note:: If you are using H2 and wish to use the same ``h2port`` value for two or more nodes, you must only assign them that + value after the nodes have been moved to their individual machines. The initial bootstrapping process requires access to the + nodes' databases and if two nodes share the same H2 port, the process will fail. Testing and debugging --------------------- diff --git a/experimental/avalanche/build.gradle b/experimental/avalanche/build.gradle index ea6e2a4632..82cfd5135d 100644 --- a/experimental/avalanche/build.gradle +++ b/experimental/avalanche/build.gradle @@ -1,41 +1,23 @@ buildscript { - ext.kotlin_version = '1.2.40' - repositories { - mavenCentral() jcenter() } dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.3' + classpath "com.github.jengelman.gradle.plugins:shadow:$shadow_version" } } -plugins { - id "org.jetbrains.kotlin.jvm" - id 'com.github.johnrengelman.shadow' version '2.0.3' - id 'java' - id 'application' -} -repositories { - mavenCentral() -} +apply plugin: 'kotlin' +apply plugin: 'application' +apply plugin: 'com.github.johnrengelman.shadow' + dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version" - compile group: 'info.picocli', name: 'picocli', version: '3.0.1' - testCompile group: 'junit', name: 'junit', version: '4.12' -} -compileKotlin { - kotlinOptions { - jvmTarget = "1.8" - } -} -compileTestKotlin { - kotlinOptions { - jvmTarget = "1.8" - } + compile "info.picocli:picocli:3.0.1" + testCompile "junit:junit:$junit_version" } + mainClassName = "net.corda.avalanche.MainKt" shadowJar { baseName = "avalanche" diff --git a/experimental/behave/build.gradle b/experimental/behave/build.gradle index 2aabc64c1e..f72ace5fbb 100644 --- a/experimental/behave/build.gradle +++ b/experimental/behave/build.gradle @@ -8,37 +8,18 @@ * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. */ -buildscript { - ext.commonsio_version = '2.6' - ext.commonslogging_version = '1.2' - ext.cucumber_version = '1.2.5' - ext.crash_version = 'cce5a00f114343c1145c1d7756e1dd6df3ea984e' - ext.docker_client_version = '8.11.0' - - repositories { - maven { - jcenter() - url 'https://jitpack.io' - } - } - - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } +ext { + commonsio_version = '2.6' + cucumber_version = '1.2.5' + crash_version = 'cce5a00f114343c1145c1d7756e1dd6df3ea984e' + docker_client_version = '8.11.0' } group 'net.corda.behave' -apply plugin: 'java' apply plugin: 'kotlin' apply plugin: 'net.corda.plugins.publish-utils' -sourceCompatibility = 1.8 - -repositories { - mavenCentral() -} - sourceSets { behave { kotlin { @@ -89,6 +70,7 @@ dependencies { compile "org.slf4j:log4j-over-slf4j:$slf4j_version" compile "org.slf4j:jul-to-slf4j:$slf4j_version" + compile "org.slf4j:jcl-over-slf4j:$slf4j_version" compile "org.apache.logging.log4j:log4j-slf4j-impl:$log4j_version" compile "org.apache.logging.log4j:log4j-core:$log4j_version" @@ -96,10 +78,9 @@ dependencies { compile "net.sf.jopt-simple:jopt-simple:$jopt_simple_version" // FastClasspathScanner: classpath scanning - compile 'io.github.lukehutch:fast-classpath-scanner:2.12.3' + compile "io.github.lukehutch:fast-classpath-scanner:$fast_classpath_scanner_version" compile "commons-io:commons-io:$commonsio_version" - compile "commons-logging:commons-logging:$commonslogging_version" compile "com.spotify:docker-client:$docker_client_version" compile "io.reactivex:rxjava:$rxjava_version" @@ -122,14 +103,6 @@ dependencies { behaveCompile "info.cukes:cucumber-picocontainer:$cucumber_version" } -compileKotlin { - kotlinOptions.jvmTarget = "1.8" -} - -compileTestKotlin { - kotlinOptions.jvmTarget = "1.8" -} - test { testLogging.showStandardStreams = true } 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 d2168d6f0d..5519ebcce5 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 @@ -13,22 +13,22 @@ package net.corda.behave.scenarios.helpers import net.corda.behave.logging.getLogger import net.corda.behave.scenarios.ScenarioState import net.corda.core.messaging.CordaRPCOps +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 = getLogger() - - 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") } - }) + } } protected fun withClientProxy(nodeName: String, action: ScenarioState.(CordaRPCOps) -> T): T { @@ -40,4 +40,4 @@ abstract class Substeps(protected val state: ScenarioState) { } }) } -} \ 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 88161f4f07..631e288cd0 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 @@ -15,7 +15,6 @@ import org.junit.Test import rx.observers.TestSubscriber class CommandTests { - @Test fun `successful command returns zero`() { val exitCode = Command(listOf("ls", "/")).run() diff --git a/experimental/build.gradle b/experimental/build.gradle index 208626a909..0c7fdae1dd 100644 --- a/experimental/build.gradle +++ b/experimental/build.gradle @@ -34,7 +34,7 @@ dependencies { compile project(':finance') // ObjectWeb Asm: a library for synthesising and working with JVM bytecode. - compile "org.ow2.asm:asm:5.0.4" + compile "org.ow2.asm:asm:$asm_version" compile "com.google.guava:guava:$guava_version" diff --git a/experimental/kryo-hook/build.gradle b/experimental/kryo-hook/build.gradle index b53acdf939..37f343064e 100644 --- a/experimental/kryo-hook/build.gradle +++ b/experimental/kryo-hook/build.gradle @@ -8,33 +8,11 @@ * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. */ -buildscript { - // For sharing constants between builds - Properties constants = new Properties() - file("$projectDir/../../constants.properties").withInputStream { constants.load(it) } - - ext.kotlin_version = constants.getProperty("kotlinVersion") - ext.javaassist_version = "3.12.1.GA" - - repositories { - mavenLocal() - mavenCentral() - jcenter() - } - - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } -} - -repositories { - mavenLocal() - mavenCentral() - jcenter() +ext { + javaassist_version = "3.12.1.GA" } 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 ba297a284e..3c532eabf1 100644 --- a/experimental/quasar-hook/build.gradle +++ b/experimental/quasar-hook/build.gradle @@ -8,33 +8,11 @@ * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. */ -buildscript { - // For sharing constants between builds - Properties constants = new Properties() - file("$projectDir/../../constants.properties").withInputStream { constants.load(it) } - - ext.kotlin_version = constants.getProperty("kotlinVersion") - ext.javaassist_version = "3.12.1.GA" - - repositories { - mavenLocal() - mavenCentral() - jcenter() - } - - dependencies { - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - } -} - -repositories { - mavenLocal() - mavenCentral() - jcenter() +ext { + javaassist_version = "3.12.1.GA" } 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 a23b91e0ce..d1f08ff87e 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 @@ -12,12 +12,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() @@ -26,21 +26,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 } @@ -55,8 +55,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()) { @@ -79,38 +78,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(" > ") @@ -119,9 +118,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}\")") @@ -130,7 +129,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") @@ -139,34 +138,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}") @@ -175,7 +173,6 @@ private class PrettyPrint(arr : Arrangement) { } fun prettyPrint(arr: Arrangement) { - when (arr) { is Zero -> println("zero") is RollOut -> { @@ -193,7 +190,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 -> { @@ -201,7 +198,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 3df91ffc48..af5a1f8acc 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 @@ -46,46 +46,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 -> { @@ -93,8 +92,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 @@ -105,7 +104,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) } @@ -220,7 +219,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 @@ -297,7 +296,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 cbfbca3382..6c47849690 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 @@ -24,13 +24,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) /* @@ -43,7 +42,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 { @@ -62,7 +61,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") @@ -93,15 +93,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() } } @@ -112,7 +112,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 { @@ -132,19 +132,20 @@ class IRS { } } - val paymentFirst = arrange { highStreetBank.owes(acmeCorp, 250.K, EUR) } + private val paymentFirst = arrange { highStreetBank.owes(acmeCorp, 250.K, EUR) } - val stateInitial = UniversalContract.State(listOf(DUMMY_NOTARY), contractInitial) + private val stateInitial = UniversalContract.State(listOf(DUMMY_NOTARY), contractInitial) - val stateAfterFixingFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterFixingFirst) - val stateAfterExecutionFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterExecutionFirst) + private val stateAfterFixingFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterFixingFirst) + private 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()) @@ -160,7 +161,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")) @@ -200,7 +201,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-api/src/main/kotlin/net/corda/nodeapi/internal/config/ConfigUtilities.kt b/node-api/src/main/kotlin/net/corda/nodeapi/internal/config/ConfigUtilities.kt index 8964cb0faa..9591a95907 100644 --- a/node-api/src/main/kotlin/net/corda/nodeapi/internal/config/ConfigUtilities.kt +++ b/node-api/src/main/kotlin/net/corda/nodeapi/internal/config/ConfigUtilities.kt @@ -35,6 +35,8 @@ import java.util.* import kotlin.reflect.KClass import kotlin.reflect.KProperty import kotlin.reflect.KType +import kotlin.reflect.full.createInstance +import kotlin.reflect.full.findAnnotation import kotlin.reflect.full.memberProperties import kotlin.reflect.full.primaryConstructor import kotlin.reflect.jvm.jvmErasure @@ -42,6 +44,17 @@ import kotlin.reflect.jvm.jvmErasure @Target(AnnotationTarget.PROPERTY) annotation class OldConfig(val value: String) +/** + * This annotation can be used to provide ConfigParser for the class, + * the [parseAs] method will use the provided parser instead of data class constructs to parse the object. + */ +@Target(AnnotationTarget.CLASS) +annotation class CustomConfigParser(val parser: KClass>) + +interface ConfigParser { + fun parse(config: Config): T +} + const val CUSTOM_NODE_PROPERTIES_ROOT = "custom" // TODO Move other config parsing to use parseAs and remove this @@ -50,7 +63,10 @@ operator fun Config.getValue(receiver: Any, metadata: KProperty<*>): T } fun Config.parseAs(clazz: KClass, onUnknownKeys: ((Set, logger: Logger) -> Unit) = UnknownConfigKeysPolicy.FAIL::handle, nestedPath: String? = null): T { - require(clazz.isData) { "Only Kotlin data classes can be parsed. Offending: ${clazz.qualifiedName}" } + // Use custom parser if provided, instead of treating the object as data class. + clazz.findAnnotation()?.let { return uncheckedCast(it.parser.createInstance().parse(this)) } + + require(clazz.isData) { "Only Kotlin data classes or class annotated with CustomConfigParser can be parsed. Offending: ${clazz.qualifiedName}" } val constructor = clazz.primaryConstructor!! val parameters = constructor.parameters val parameterNames = parameters.flatMap { param -> diff --git a/node-api/src/test/kotlin/net/corda/nodeapi/internal/config/ConfigParsingTest.kt b/node-api/src/test/kotlin/net/corda/nodeapi/internal/config/ConfigParsingTest.kt index 05e985ab42..130219f706 100644 --- a/node-api/src/test/kotlin/net/corda/nodeapi/internal/config/ConfigParsingTest.kt +++ b/node-api/src/test/kotlin/net/corda/nodeapi/internal/config/ConfigParsingTest.kt @@ -237,6 +237,36 @@ class ConfigParsingTest { } } + @Test + fun `parse with provided parser`() { + val type1Config = mapOf("type" to "1", "value" to "type 1 value") + val type2Config = mapOf("type" to "2", "value" to "type 2 value") + + val configuration = config("values" to listOf(type1Config, type2Config)) + val objects = configuration.parseAs() + + assertThat(objects.values).containsExactly(TestObject.Type1("type 1 value"), TestObject.Type2("type 2 value")) + } + + class TestParser : ConfigParser { + override fun parse(config: Config): TestObject { + val type = config.getInt("type") + return when (type) { + 1 -> config.parseAs(onUnknownKeys = UnknownConfigKeysPolicy.IGNORE::handle) + 2 -> config.parseAs(onUnknownKeys = UnknownConfigKeysPolicy.IGNORE::handle) + else -> throw IllegalArgumentException("Unsupported Object type : '$type'") + } + } + } + + data class TestObjects(val values: List) + + @CustomConfigParser(TestParser::class) + sealed class TestObject { + data class Type1(val value: String) : TestObject() + data class Type2(val value: String) : TestObject() + } + private inline fun , reified L : ListData, V : Any> testPropertyType( value1: V, value2: V, @@ -320,6 +350,7 @@ class ConfigParsingTest { require(positive > 0) { "$positive is not positive" } } } + data class OldData( @OldConfig("oldValue") val newValue: String) 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 b70f5654f2..c8d0f2beb1 100644 --- a/node/src/integration-test/kotlin/net/corda/node/AuthDBTests.kt +++ b/node/src/integration-test/kotlin/net/corda/node/AuthDBTests.kt @@ -63,6 +63,7 @@ class AuthDBTests : NodeBasedTest() { private lateinit var client: CordaRPCClient private lateinit var db: UsersDB + @Suppress("MemberVisibilityCanBePrivate") @Parameterized.Parameter lateinit var passwordEncryption: PasswordEncryption @@ -110,7 +111,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 @@ -243,9 +244,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 = """ @@ -295,11 +295,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) @@ -307,11 +303,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 7235b6d0b3..4f08356c64 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 @@ -32,7 +32,6 @@ import net.corda.testing.internal.DEV_ROOT_CA import net.corda.testing.internal.IntegrationTest import net.corda.testing.internal.IntegrationTestSchemas 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 @@ -64,7 +63,6 @@ class NodeRegistrationTest : IntegrationTest() { 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 @@ -82,7 +80,7 @@ class NodeRegistrationTest : IntegrationTest() { 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 9e802d4342..b88068edde 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 @@ -78,7 +78,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) } @@ -86,7 +86,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 cdbfbed0c8..928591c53a 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 @@ -18,7 +18,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 c415e25208..eb5d18c562 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 @@ -41,6 +41,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.ClassRule @@ -125,9 +126,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() } @@ -140,7 +141,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 { @@ -157,7 +158,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 622976d72a..72d0ac9ef7 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 @@ -14,11 +14,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 @@ -51,6 +50,7 @@ interface NodeConfiguration : NodeSSLConfiguration { val devModeOptions: DevModeOptions? val compatibilityZoneURL: URL? val networkServices: NetworkServicesConfig? + @Suppress("DEPRECATION") val certificateChainCheckPolicies: List val verifierType: VerifierType val flowTimeout: FlowTimeoutConfiguration @@ -237,6 +237,7 @@ data class NodeConfigurationImpl( override val messagingServerExternal: Boolean = (messagingServerAddress != null), override val enterpriseConfiguration: EnterpriseConfiguration, override val notary: NotaryConfig?, + @Suppress("DEPRECATION") @Deprecated("Do not configure") override val certificateChainCheckPolicies: List = emptyList(), override val devMode: Boolean = false, @@ -413,6 +414,7 @@ data class NodeConfigurationImpl( } // Check for usage of deprecated config + @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. @@ -467,18 +469,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 { @@ -515,8 +506,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?) { @@ -544,12 +533,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 { 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 942638dc40..fdff52392a 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 @@ -34,7 +34,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 cea86aac2c..2d86992bf7 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 @@ -63,7 +63,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 8ec7cebf4d..350ad4ee05 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 @@ -40,8 +40,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 a39ff6140b..c569c71f3b 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 @@ -98,8 +98,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 ca4c67da37..cc63a6c809 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 @@ -66,10 +66,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 { @@ -145,7 +145,7 @@ class SingleThreadedStateMachineManager( } serviceHub.networkMapCache.nodeReady.then { resumeRestoredFlows(fibers) - flowMessaging.start { receivedMessage, deduplicationHandler -> + flowMessaging.start { _, deduplicationHandler -> executor.execute { deliverExternalEvent(deduplicationHandler.externalCause) } @@ -296,10 +296,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() { @@ -314,8 +314,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, @@ -534,12 +533,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) @@ -551,7 +544,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 2779cee916..75493c1cfb 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 64337624a6..fa2ebc9285 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 @@ -79,7 +79,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 a94c865440..f2389f1570 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 @@ -55,9 +55,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 58912b3638..e0dff1589b 100644 --- a/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt +++ b/node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt @@ -86,7 +86,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) } } } @@ -156,13 +156,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 @@ -177,7 +177,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 { @@ -209,7 +209,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 @@ -238,7 +238,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. @@ -252,10 +252,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) @@ -272,7 +271,7 @@ abstract class AppendOnlyPersistentMapBase( private fun loadAsWriter(): T { val _value = writerValueLoader.get()() if (writerValueLoader.get() == _writerValueLoader) { - writerValueLoader.set({ _value }) + writerValueLoader.set { _value } } return _value } @@ -282,7 +281,7 @@ abstract class AppendOnlyPersistentMapBase( private fun loadAsReader(): T? { val _value = readerValueLoader.get()() if (readerValueLoader.get() == _readerValueLoader) { - readerValueLoader.set({ _value }) + readerValueLoader.set { _value } } return _value } @@ -320,7 +319,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. @@ -331,10 +330,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 @@ -342,10 +341,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) } } }) @@ -364,26 +363,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 042c935fee..7fa27bdbc3 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 @@ -46,9 +46,6 @@ import org.junit.Rule; 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; @@ -80,7 +77,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", @@ -101,14 +98,10 @@ public class VaultQueryJavaTests { } @After - public void cleanUp() throws IOException { + public void cleanUp() { database.close(); } - /** - * Sample Vault Query API tests - */ - /** * Static queryBy() tests */ @@ -119,6 +112,7 @@ public class VaultQueryJavaTests { 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)); @@ -131,13 +125,14 @@ public class VaultQueryJavaTests { 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; @@ -209,7 +204,7 @@ public class VaultQueryJavaTests { } @Test - public void consumedDealStatesPagedSorted() throws VaultQueryException { + public void consumedDealStatesPagedSorted() { List dealIds = asList("123", "456", "789"); @SuppressWarnings("unchecked") Triple, UniqueIdentifier, Vault> ids = @@ -320,7 +315,6 @@ public class VaultQueryJavaTests { 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); @@ -374,7 +368,6 @@ public class VaultQueryJavaTests { @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")); @@ -420,7 +413,6 @@ public class VaultQueryJavaTests { @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 09281fd0f3..ff39b3d088 100644 --- a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt +++ b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt @@ -34,7 +34,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 @@ -167,6 +166,7 @@ class CordaRPCOpsImplTest { @Test fun `issue and move`() { + @Suppress("DEPRECATION") withPermissions(invokeRpc(CordaRPCOps::stateMachinesFeed), invokeRpc(CordaRPCOps::internalVerifiedTransactionsFeed), invokeRpc("vaultTrackBy"), @@ -178,11 +178,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() @@ -257,7 +253,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 45f7f48f0c..c1b73e71de 100644 --- a/node/src/test/kotlin/net/corda/node/internal/NodeTest.kt +++ b/node/src/test/kotlin/net/corda/node/internal/NodeTest.kt @@ -70,7 +70,7 @@ class NodeTest { fun `generateAndSaveNodeInfo works`() { val configuration = createConfig(ALICE_NAME) val info = VersionInfo(789, "3.0", "SNAPSHOT", "R3") - configureDatabase(configuration.dataSourceProperties, configuration.database, { null }, { null }).use { database -> + configureDatabase(configuration.dataSourceProperties, configuration.database, { null }, { null }).use { val node = Node(configuration, info, initialiseSerialization = false) assertEquals(node.generateNodeInfo(), node.generateNodeInfo()) // Node info doesn't change (including the serial) } 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 2a16e8febf..0620f0f115 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 8d9e96391b..720d147eac 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 f57a5d6acb..32906512f1 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 @@ -10,22 +10,8 @@ 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 @@ -46,11 +32,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 @@ -61,6 +43,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) { @@ -97,7 +80,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() { @@ -108,7 +91,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) { @@ -283,7 +266,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, @@ -295,7 +278,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 d187aa42a7..f530cb8067 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 @@ -81,7 +81,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(EnterpriseConfiguration(MutualExclusionConfiguration(false, "", 20000, 40000))).whenever(it).enterpriseConfiguration doReturn(FlowTimeoutConfiguration(5.seconds, 3, backoffBase = 1.0)).whenever(it).flowTimeout } 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 bd8ffd3a85..97f48be078 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 @@ -200,7 +200,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 3d83853133..c548a065e2 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 @@ -17,18 +17,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 @@ -176,7 +172,7 @@ class DBTransactionStorageTests { } private fun newTransaction(): SignedTransaction { - val wtx = WireTransaction( + val wtx = createWireTransaction( inputs = listOf(StateRef(SecureHash.randomSHA256(), 0)), attachments = emptyList(), outputs = emptyList(), @@ -184,6 +180,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 80ba084244..fb9f7191dd 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 @@ -14,7 +14,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 @@ -39,13 +38,13 @@ import net.corda.finance.schemas.SampleCashSchemaV3 import net.corda.finance.schemas.CashSchemaV1 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 @@ -85,18 +84,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 @@ -104,7 +103,7 @@ class HibernateConfigurationTest { private lateinit var notary: Party // test States - lateinit var cashStates: List> + private lateinit var cashStates: List> @Before fun setUp() { @@ -701,7 +700,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()}") } @@ -785,7 +784,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() }}") } @@ -924,6 +923,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 6bb7517973..ceeb77dc52 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 @@ -15,11 +15,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 @@ -69,7 +65,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())) @@ -94,7 +90,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) @@ -109,7 +105,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 { @@ -129,6 +125,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") } @@ -196,11 +193,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) } } } @@ -209,7 +206,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() @@ -237,7 +234,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 554a947e08..bd37a829d1 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 @@ -15,6 +15,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 @@ -31,6 +32,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 @@ -67,10 +69,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) } @@ -90,10 +92,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) } @@ -104,6 +106,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 860eb50d7f..04889c3ab9 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 @@ -51,7 +51,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 @@ -113,7 +112,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 @@ -143,7 +142,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) @@ -161,7 +160,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 f431e36a7a..6973ffc6b3 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 @@ -75,7 +75,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 @@ -88,7 +88,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) @@ -141,7 +141,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) } @@ -189,7 +189,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}") @@ -220,7 +220,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}") @@ -344,7 +344,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 1e470c2576..bd09e94e36 100644 --- a/node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt +++ b/node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt @@ -23,7 +23,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 @@ -68,7 +67,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`() { @@ -93,7 +92,6 @@ class ObservablesTests { assertThat(secondEvent.isDone).isFalse() throw TestException() } - fail("Should not have successfully completed transaction") } catch (e: TestException) { } assertThat(secondEvent.isDone).isFalse() @@ -125,7 +123,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 86a9ae4af7..f0c195e3a0 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 @@ -11,10 +11,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.core.DUMMY_NOTARY_NAME @@ -42,14 +40,7 @@ class AttachmentDemoTest : IntegrationTest() { fun `attachment demo using a 10MB zip file`() { val numOfExpectedBytes = 10_000_000 driver(DriverParameters(isDebug = true, portAllocation = PortAllocation.Incremental(20000), startNodesInProcess = true)) { - 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 080619edd3..2c5dd0240d 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 @@ -96,14 +96,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'" } } @@ -143,6 +141,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/build.gradle b/samples/irs-demo/build.gradle index 36d31a3b70..25233fad2c 100644 --- a/samples/irs-demo/build.gradle +++ b/samples/irs-demo/build.gradle @@ -68,9 +68,7 @@ repositories { maven { url 'https://dl.bintray.com/palantir/releases' // docker-compose-rule is published on bintray } - repositories { - maven { url 'https://jitpack.io' } - } + maven { url 'https://jitpack.io' } } dependencies { 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 68e472fb6b..8c0411d0a9 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 @@ -8,6 +8,8 @@ * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. */ +@file:Suppress("DEPRECATION") + package net.corda.test.spring import net.corda.core.concurrent.CordaFuture diff --git a/samples/network-verifier/build.gradle b/samples/network-verifier/build.gradle new file mode 100644 index 0000000000..f64efcc692 --- /dev/null +++ b/samples/network-verifier/build.gradle @@ -0,0 +1,49 @@ +apply plugin: 'kotlin' +apply plugin: 'java' +apply plugin: 'net.corda.plugins.cordapp' +apply plugin: 'net.corda.plugins.cordformation' + +dependencies { + cordaCompile project(":core") + cordaCompile project(":node-api") + cordaCompile project(path: ":node:capsule", configuration: 'runtimeArtifacts') + + testCompile project(":test-utils") + testCompile "junit:junit:$junit_version" +} + +task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) { + ext.rpcUsers = [['username': "default", 'password': "default", 'permissions': [ 'ALL' ]]] + + directory "./build/nodes" + node { + name "O=Notary Service,L=Zurich,C=CH" + notary = [validating : false] + p2pPort 10002 + rpcSettings { + port 10003 + adminPort 10004 + } + h2Port 20004 + } + node { + name "O=Bank A,L=London,C=GB" + p2pPort 10005 + cordapps = [] + rpcUsers = ext.rpcUsers + rpcSettings { + port 10007 + adminPort 10008 + } + } + node { + name "O=Bank B,L=New York,C=US" + p2pPort 10009 + cordapps = [] + rpcUsers = ext.rpcUsers + rpcSettings { + port 10011 + adminPort 10012 + } + } +} \ No newline at end of file diff --git a/samples/network-verifier/src/main/kotlin/net/corda/verification/TestCommsFlow.kt b/samples/network-verifier/src/main/kotlin/net/corda/verification/TestCommsFlow.kt new file mode 100644 index 0000000000..3437cce254 --- /dev/null +++ b/samples/network-verifier/src/main/kotlin/net/corda/verification/TestCommsFlow.kt @@ -0,0 +1,81 @@ +package net.corda.verification + +import co.paralleluniverse.fibers.Suspendable +import net.corda.core.contracts.CommandData +import net.corda.core.contracts.Contract +import net.corda.core.contracts.ContractState +import net.corda.core.flows.* +import net.corda.core.identity.AbstractParty +import net.corda.core.identity.CordaX500Name +import net.corda.core.identity.Party +import net.corda.core.serialization.CordaSerializable +import net.corda.core.transactions.LedgerTransaction +import net.corda.core.transactions.TransactionBuilder +import net.corda.core.utilities.ProgressTracker +import net.corda.core.utilities.unwrap + + +@StartableByRPC +@InitiatingFlow +class TestCommsFlowInitiator(val x500Name: CordaX500Name? = null) : FlowLogic>() { + + object SENDING : ProgressTracker.Step("SENDING") + object RECIEVED_ALL : ProgressTracker.Step("RECIEVED_ALL") + object FINALIZING : ProgressTracker.Step("FINALIZING") + + override val progressTracker: ProgressTracker = ProgressTracker(SENDING, RECIEVED_ALL, FINALIZING) + + @Suspendable + override fun call(): List { + progressTracker.currentStep = SENDING + val responses = serviceHub.networkMapCache.allNodes.map { + it.legalIdentities.first() + }.filterNot { + it in serviceHub.myInfo.legalIdentities + }.filterNot { + it in serviceHub.networkMapCache.notaryIdentities + }.filter(::matchesX500) + .map { + val initiateFlow = initiateFlow(it) + initiateFlow.receive().unwrap { it } + }.toList().also { + progressTracker.currentStep = RECIEVED_ALL + } + val tx = TransactionBuilder(notary = serviceHub.networkMapCache.notaryIdentities.first()) + tx.addOutputState(CommsTestState(responses, serviceHub.myInfo.legalIdentities.first()), CommsTestContract::class.qualifiedName!!) + tx.addCommand(CommsTestCommand, serviceHub.myInfo.legalIdentities.first().owningKey) + val signedTx = serviceHub.signInitialTransaction(tx) + subFlow(FinalityFlow(signedTx)) + return responses + } + + fun matchesX500(it: Party): Boolean { + return x500Name?.equals(it.name) ?: true + } +} + +@InitiatedBy(TestCommsFlowInitiator::class) +class TestCommsFlowResponder(val otherSideSession: FlowSession) : FlowLogic() { + @Suspendable + override fun call() { + otherSideSession.send("Hello from: " + serviceHub.myInfo.legalIdentities.first().name.toString()) + } + +} + +@CordaSerializable +data class CommsTestState(val responses: List, val issuer: AbstractParty) : ContractState { + override val participants: List + get() = listOf(issuer) + +} + + +@CordaSerializable +object CommsTestCommand : CommandData + + +class CommsTestContract : Contract { + override fun verify(tx: LedgerTransaction) { + } +} \ No newline at end of file diff --git a/samples/network-verifier/src/main/kotlin/net/corda/verification/TestNotaryFlow.kt b/samples/network-verifier/src/main/kotlin/net/corda/verification/TestNotaryFlow.kt new file mode 100644 index 0000000000..91b8d4bbec --- /dev/null +++ b/samples/network-verifier/src/main/kotlin/net/corda/verification/TestNotaryFlow.kt @@ -0,0 +1,65 @@ +package net.corda.verification + +import net.corda.core.contracts.CommandData +import net.corda.core.contracts.Contract +import net.corda.core.contracts.ContractState +import net.corda.core.flows.FinalityFlow +import net.corda.core.flows.FlowLogic +import net.corda.core.flows.StartableByRPC +import net.corda.core.identity.AbstractParty +import net.corda.core.serialization.CordaSerializable +import net.corda.core.transactions.LedgerTransaction +import net.corda.core.transactions.TransactionBuilder +import net.corda.core.utilities.ProgressTracker + + +@StartableByRPC +class TestNotaryFlow : FlowLogic() { + + object ISSUING : ProgressTracker.Step("ISSUING") + object ISSUED : ProgressTracker.Step("ISSUED") + object DESTROYING : ProgressTracker.Step("DESTROYING") + object FINALIZED : ProgressTracker.Step("FINALIZED") + + override val progressTracker: ProgressTracker = ProgressTracker(ISSUING, ISSUED, DESTROYING, FINALIZED) + + + override fun call(): String { + val issueBuilder = TransactionBuilder() + val notary = serviceHub.networkMapCache.notaryIdentities.first() + issueBuilder.notary = notary; + val myIdentity = serviceHub.myInfo.legalIdentities.first() + issueBuilder.addOutputState(NotaryTestState(notary.name.toString(), myIdentity), NotaryTestContract::class.qualifiedName!!) + issueBuilder.addCommand(NotaryTestCommand, myIdentity.owningKey) + val signedTx = serviceHub.signInitialTransaction(issueBuilder) + val issueResult = subFlow(FinalityFlow(signedTx)) + progressTracker.currentStep = ISSUED + val destroyBuilder = TransactionBuilder() + destroyBuilder.notary = notary; + destroyBuilder.addInputState(issueResult.tx.outRefsOfType().first()) + destroyBuilder.addCommand(NotaryTestCommand, myIdentity.owningKey) + val signedDestroyT = serviceHub.signInitialTransaction(destroyBuilder) + val result = subFlow(FinalityFlow(signedDestroyT)) + progressTracker.currentStep = DESTROYING + progressTracker.currentStep = FINALIZED + return "notarised: " + result.notary.toString() + "::" + result.tx.id + } +} + + +@CordaSerializable +data class NotaryTestState(val id: String, val issuer: AbstractParty) : ContractState { + override val participants: List + get() = listOf(issuer) + +} + + +@CordaSerializable +object NotaryTestCommand : CommandData + + +class NotaryTestContract : Contract { + override fun verify(tx: LedgerTransaction) { + } +} \ No newline at end of file diff --git a/samples/network-verifier/src/test/kotlin/net/corda/configsample/TestCommsFlowInitiatorTest.kt b/samples/network-verifier/src/test/kotlin/net/corda/configsample/TestCommsFlowInitiatorTest.kt new file mode 100644 index 0000000000..d0974f0eba --- /dev/null +++ b/samples/network-verifier/src/test/kotlin/net/corda/configsample/TestCommsFlowInitiatorTest.kt @@ -0,0 +1,34 @@ +package net.corda.configsample + +import net.corda.testing.core.ALICE_NAME +import net.corda.testing.core.DUMMY_BANK_A_NAME +import net.corda.testing.core.DUMMY_NOTARY_NAME +import net.corda.testing.core.TestIdentity +import net.corda.verification.TestCommsFlowInitiator +import org.junit.Assert +import org.junit.Test + +class TestCommsFlowInitiatorTest { + + val ALICE = TestIdentity(ALICE_NAME, 70) + val NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 12) + val DUMMY_BANK_A = TestIdentity(DUMMY_BANK_A_NAME, 3) + + @Test + fun `should allow all node infos through if no x500 is passed`() { + val testCommsFlowInitiator = TestCommsFlowInitiator() + + Assert.assertTrue(testCommsFlowInitiator.matchesX500(ALICE.party)) + Assert.assertTrue(testCommsFlowInitiator.matchesX500(NOTARY.party)) + Assert.assertTrue(testCommsFlowInitiator.matchesX500(DUMMY_BANK_A.party)) + } + + @Test + fun `should allow only specified x500 if no x500 is passed`() { + val testCommsFlowInitiator = TestCommsFlowInitiator(ALICE_NAME) + + Assert.assertTrue(testCommsFlowInitiator.matchesX500(ALICE.party)) + Assert.assertFalse(testCommsFlowInitiator.matchesX500(NOTARY.party)) + Assert.assertFalse(testCommsFlowInitiator.matchesX500(DUMMY_BANK_A.party)) + } +} \ No newline at end of file diff --git a/serialization-deterministic/build.gradle b/serialization-deterministic/build.gradle index 14e29d2eae..fb023fd2f0 100644 --- a/serialization-deterministic/build.gradle +++ b/serialization-deterministic/build.gradle @@ -83,6 +83,7 @@ task predeterminise(type: ProGuardTask, dependsOn: project(':core-deterministic' dontpreverify dontobfuscate dontoptimize + dontnote printseeds verbose @@ -123,6 +124,7 @@ task determinise(type: ProGuardTask) { keepattributes '*' keepdirectories dontobfuscate + dontnote printseeds verbose @@ -161,7 +163,6 @@ task checkDeterminism(type: ProGuardTask, dependsOn: jdkTask) { defaultTasks "determinise" determinise.finalizedBy metafix metafix.finalizedBy checkDeterminism -assemble.dependsOn checkDeterminism def deterministicJar = metafix.outputs.files.singleFile artifacts { diff --git a/serialization/src/main/kotlin/net/corda/serialization/internal/OrdinalIO.kt b/serialization/src/main/kotlin/net/corda/serialization/internal/OrdinalIO.kt index c582784e28..b763a70580 100644 --- a/serialization/src/main/kotlin/net/corda/serialization/internal/OrdinalIO.kt +++ b/serialization/src/main/kotlin/net/corda/serialization/internal/OrdinalIO.kt @@ -18,6 +18,7 @@ import java.nio.ByteBuffer @KeepForDJVM class OrdinalBits(private val ordinal: Int) { + @KeepForDJVM interface OrdinalWriter { val bits: OrdinalBits @JvmDefault val encodedSize get() = 1 diff --git a/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/CustomSerializer.kt b/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/CustomSerializer.kt index 020d655f31..0674c3756e 100644 --- a/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/CustomSerializer.kt +++ b/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/CustomSerializer.kt @@ -10,6 +10,7 @@ package net.corda.serialization.internal.amqp +import net.corda.core.KeepForDJVM import net.corda.core.internal.uncheckedCast import net.corda.core.serialization.SerializationContext import net.corda.serialization.internal.amqp.SerializerFactory.Companion.nameForType @@ -68,6 +69,7 @@ abstract class CustomSerializer : AMQPSerializer, SerializerFor { * subclass in the schema, so that we can distinguish between subclasses. */ // TODO: should this be a custom serializer at all, or should it just be a plain AMQPSerializer? + @KeepForDJVM class SubClass(private val clazz: Class<*>, private val superClassSerializer: CustomSerializer) : CustomSerializer() { // TODO: should this be empty or contain the schema of the super? override val schemaForDocumentation = Schema(emptyList()) diff --git a/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/TransformTypes.kt b/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/TransformTypes.kt index ba26017919..15e81ac623 100644 --- a/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/TransformTypes.kt +++ b/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/TransformTypes.kt @@ -80,6 +80,7 @@ enum class TransformTypes(val build: (Annotation) -> Transform) : DescribedType * @param constants The list of enum constants on the type the transforms are being applied to */ override fun validate(list: List, constants: Map) { + @KeepForDJVM data class Node(val transform: RenameSchemaTransform, var next: Node?, var prev: Node?, var visitedBy: Node? = null) { fun visit(visitedBy: Node) { this.visitedBy = visitedBy diff --git a/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/TransformsSchema.kt b/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/TransformsSchema.kt index 4bd90d94b1..f20fb5fe34 100644 --- a/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/TransformsSchema.kt +++ b/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/TransformsSchema.kt @@ -164,6 +164,7 @@ class EnumDefaultSchemaTransform(val old: String, val new: String) : Transform() * @property from the name of the property or constant prior to being changed, i.e. what it was * @property to the new name of the property or constant after the change has been made, i.e. what it is now */ +@KeepForDJVM class RenameSchemaTransform(val from: String, val to: String) : Transform() { companion object : DescribedTypeConstructor { /** 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 3736683a0c..1c789ec0e2 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 @@ -23,7 +23,7 @@ public class JavaGenericsTest { private final Integer v; private Inner(Integer v) { this.v = v; } - public Integer getV() { return v; } + Integer getV() { return v; } } private static class A { @@ -35,7 +35,7 @@ public class JavaGenericsTest { @Test public void basicGeneric() throws NotSerializableException { - A a1 = new A(1); + A a1 = new A<>(1); SerializerFactory factory = testDefaultFactory(); @@ -76,7 +76,7 @@ public class JavaGenericsTest { @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()); } @@ -85,7 +85,7 @@ public class JavaGenericsTest { 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 99e9ba2b7c..a1f41b808a 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 @@ -17,6 +17,7 @@ import java.io.NotSerializableException; 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.*; @@ -40,6 +41,7 @@ public class JavaPrivatePropertyTests { B(Boolean b) { this.b = b; } + @SuppressWarnings("unused") public Boolean isB() { return this.b; } @@ -48,6 +50,7 @@ public class JavaPrivatePropertyTests { static class B2 { private Boolean b; + @SuppressWarnings("unused") public Boolean isB() { return this.b; } @@ -60,6 +63,7 @@ public class JavaPrivatePropertyTests { 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; @@ -77,6 +81,7 @@ public class JavaPrivatePropertyTests { return this.a; } + @SuppressWarnings("unused") public Boolean isA() { return this.a > 0; } @@ -155,7 +160,7 @@ public class JavaPrivatePropertyTests { 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]); @@ -182,7 +187,7 @@ public class JavaPrivatePropertyTests { // 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 844cf2444e..067f6de548 100644 --- a/serialization/src/test/kotlin/net/corda/serialization/internal/ContractAttachmentSerializerTest.kt +++ b/serialization/src/test/kotlin/net/corda/serialization/internal/ContractAttachmentSerializerTest.kt @@ -27,7 +27,6 @@ import org.junit.Test import kotlin.test.assertEquals class ContractAttachmentSerializerTest { - @Rule @JvmField val testSerialization = SerializationEnvironmentRule() @@ -61,7 +60,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) @@ -78,7 +77,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 59c84d6387..35a10c2632 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 @@ -12,10 +12,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 @@ -38,7 +37,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)) } @@ -53,7 +52,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)) } @@ -65,28 +64,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 40edbd5b83..1085a3c113 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 @@ -287,7 +287,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() @@ -305,16 +305,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, @@ -327,7 +327,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 c71dd0330f..d2a332f679 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 @@ -107,7 +107,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 575794be83..381032cfbd 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 ab26f595c2..f39ef6264a 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 @@ -898,6 +898,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 @@ -976,8 +977,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 @@ -1038,7 +1041,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`() { @@ -1172,7 +1175,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 -> @@ -1189,10 +1192,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() @@ -1347,7 +1346,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 379f0ccd25..54eb6658f2 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 @@ -45,7 +45,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/settings.gradle b/settings.gradle index 8683f007f8..67574b7e89 100644 --- a/settings.gradle +++ b/settings.gradle @@ -79,6 +79,7 @@ include 'samples:notary-demo' include 'samples:bank-of-corda-demo' include 'samples:business-network-demo' include 'samples:cordapp-configuration' +include 'samples:network-verifier' include 'serialization' include 'serialization-deterministic' include 'cordform-common' 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 b0fb23b3e3..08bad2961d 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 @@ -45,7 +45,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 = 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 c5b63d484e..d94de85e38 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 @@ -79,10 +79,10 @@ abstract class NodeBasedTest(private val cordappPackages: List = emptyLi // Wait until ports are released val portNotBoundChecks = startedNodes.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() + } startedNodes.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 43375904e5..3d7d743f21 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 @@ -10,12 +10,15 @@ 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 @@ -149,3 +152,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 1f4dd8fb5d..a1620c03c7 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 @@ -196,6 +196,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/build.gradle b/tools/network-bootstrapper/build.gradle index b49b5e87bc..ef2eab205d 100644 --- a/tools/network-bootstrapper/build.gradle +++ b/tools/network-bootstrapper/build.gradle @@ -11,19 +11,10 @@ buildscript { } dependencies { - classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version" - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" - classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.1' + classpath "com.github.jengelman.gradle.plugins:shadow:$shadow_version" } } -repositories { - mavenLocal() - mavenCentral() - jcenter() -} - - apply plugin: 'kotlin' apply plugin: 'idea' apply plugin: 'java' 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 1836f5e76a..8ea71b8a43 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 8b72714c8d..ab689eb47f 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 9c2b75d94b..4de42a5224 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 1c7f0ac6f6..9de81220a9 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 d3d867c461..8e350c8c14 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 +}