From 83e66d542d2d2f3c988903fdb566b14ac84a614b Mon Sep 17 00:00:00 2001 From: Shams Asari Date: Mon, 10 Sep 2018 10:43:00 +0100 Subject: [PATCH] Syncing Cordapp info code from ENT so that ENT-1731 is fully ported (#3914) Also, Cordapp.Info has been made internal as it's not used in the public API --- .../kotlin/net/corda/core/cordapp/Cordapp.kt | 18 +---- .../core/internal/cordapp/CordappImpl.kt | 17 +++-- finance/build.gradle | 13 +++- .../main/kotlin/net/corda/node/VersionInfo.kt | 7 +- .../net/corda/node/cordapp/CordappLoader.kt | 3 +- .../kotlin/net/corda/node/internal/Node.kt | 8 ++- .../net/corda/node/internal/NodeStartup.kt | 15 +++- .../internal/cordapp/CordappProviderImpl.kt | 3 +- .../cordapp/CordappProviderInternal.kt | 3 +- .../cordapp/JarScanningCordappLoader.kt | 71 ++++++++++--------- .../node/internal/cordapp/ManifestUtils.kt | 19 ++--- .../net/corda/node/internal/NodeTest.kt | 16 ++--- .../cordapp/JarScanningCordappLoaderTest.kt | 6 +- .../attachmentdemo/AttachmentDemoTest.kt | 2 +- .../testing/internal/MockCordappProvider.kt | 5 +- 15 files changed, 113 insertions(+), 93 deletions(-) diff --git a/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt b/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt index 8e23c5c01b..ddf369b668 100644 --- a/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt +++ b/core/src/main/kotlin/net/corda/core/cordapp/Cordapp.kt @@ -48,20 +48,4 @@ interface Cordapp { val jarPath: URL val cordappClasses: List val jarHash: SecureHash.SHA256 - - /** - * CorDapp's information, including vendor and version. - * - * @property shortName Cordapp's shortName - * @property vendor Cordapp's vendor - * @property version Cordapp's version - */ - @DoNotImplement - interface Info { - val shortName: String - val vendor: String - val version: String - - fun hasUnknownFields(): Boolean - } -} \ No newline at end of file +} diff --git a/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt b/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt index a8021e8663..5a459783e8 100644 --- a/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt +++ b/core/src/main/kotlin/net/corda/core/internal/cordapp/CordappImpl.kt @@ -24,25 +24,28 @@ data class CordappImpl( override val customSchemas: Set, override val allFlows: List>>, override val jarPath: URL, + val info: Info, override val jarHash: SecureHash.SHA256) : Cordapp { - override val name: String = jarPath.toPath().fileName.toString().removeSuffix(".jar") + override val name: String = jarName(jarPath) + + companion object { + fun jarName(url: URL): String = url.toPath().fileName.toString().removeSuffix(".jar") + } /** * An exhaustive list of all classes relevant to the node within this CorDapp * * TODO: Also add [SchedulableFlow] as a Cordapp class */ - override val cordappClasses = ((rpcFlows + initiatedFlows + services + serializationWhitelists.map { javaClass }).map { it.name } + contractClassNames) + override val cordappClasses: List = (rpcFlows + initiatedFlows + services + serializationWhitelists.map { javaClass }).map { it.name } + contractClassNames - data class Info(override val shortName: String, override val vendor: String, override val version: String): Cordapp.Info { + // TODO Why a seperate Info class and not just have the fields directly in CordappImpl? + data class Info(val shortName: String, val vendor: String, val version: String) { companion object { private const val UNKNOWN_VALUE = "Unknown" - val UNKNOWN = Info(UNKNOWN_VALUE, UNKNOWN_VALUE, UNKNOWN_VALUE) } - override fun hasUnknownFields(): Boolean { - return setOf(shortName, vendor, version).any { it == UNKNOWN_VALUE } - } + fun hasUnknownFields(): Boolean = arrayOf(shortName, vendor, version).any { it == UNKNOWN_VALUE } } } diff --git a/finance/build.gradle b/finance/build.gradle index 493b3babfb..b55819f201 100644 --- a/finance/build.gradle +++ b/finance/build.gradle @@ -71,11 +71,22 @@ jar { exclude "META-INF/*.MF" exclude "META-INF/LICENSE" exclude "META-INF/NOTICE" + + manifest { + attributes( + "Manifest-Version": "1.0", + "Specification-Title": description, + "Specification-Version": version, + "Specification-Vendor": "Corda Open Source", + "Implementation-Title": "$group.$baseName", + ) + } } cordapp { info { - vendor "R3" + name "net/corda/finance" + vendor "Corda Open Source" } } diff --git a/node/src/main/kotlin/net/corda/node/VersionInfo.kt b/node/src/main/kotlin/net/corda/node/VersionInfo.kt index c51df32229..eacbb25133 100644 --- a/node/src/main/kotlin/net/corda/node/VersionInfo.kt +++ b/node/src/main/kotlin/net/corda/node/VersionInfo.kt @@ -14,4 +14,9 @@ data class VersionInfo( /** The exact version control commit ID of the node build. */ val revision: String, /** The node vendor */ - val vendor: String) \ No newline at end of file + val vendor: String) { + + companion object { + val UNKNOWN = VersionInfo(1, "Unknown", "Unknown", "Unknown") + } +} diff --git a/node/src/main/kotlin/net/corda/node/cordapp/CordappLoader.kt b/node/src/main/kotlin/net/corda/node/cordapp/CordappLoader.kt index 8f472c8922..8a8feffc2d 100644 --- a/node/src/main/kotlin/net/corda/node/cordapp/CordappLoader.kt +++ b/node/src/main/kotlin/net/corda/node/cordapp/CordappLoader.kt @@ -2,6 +2,7 @@ package net.corda.node.cordapp import net.corda.core.cordapp.Cordapp import net.corda.core.flows.FlowLogic +import net.corda.core.internal.cordapp.CordappImpl import net.corda.core.schemas.MappedSchema /** @@ -12,7 +13,7 @@ interface CordappLoader { /** * Returns all [Cordapp]s found. */ - val cordapps: List + val cordapps: List /** * Returns a [ClassLoader] containing all types from all [Cordapp]s. diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt index 52ab905ae7..d32b399256 100644 --- a/node/src/main/kotlin/net/corda/node/internal/Node.kt +++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt @@ -88,7 +88,7 @@ class NodeWithInfo(val node: Node, val info: NodeInfo) { open class Node(configuration: NodeConfiguration, versionInfo: VersionInfo, private val initialiseSerialization: Boolean = true, - cordappLoader: CordappLoader = makeCordappLoader(configuration) + cordappLoader: CordappLoader = makeCordappLoader(configuration, versionInfo) ) : AbstractNode( configuration, createClock(configuration), @@ -130,9 +130,11 @@ open class Node(configuration: NodeConfiguration, } private val sameVmNodeCounter = AtomicInteger() - private fun makeCordappLoader(configuration: NodeConfiguration): CordappLoader { - return JarScanningCordappLoader.fromDirectories(configuration.cordappDirectories) + + private fun makeCordappLoader(configuration: NodeConfiguration, versionInfo: VersionInfo): CordappLoader { + return JarScanningCordappLoader.fromDirectories(configuration.cordappDirectories, versionInfo) } + // TODO: make this configurable. const val MAX_RPC_MESSAGE_SIZE = 10485760 } diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt index f8d6681e4c..3ccb4792c3 100644 --- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt +++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt @@ -10,6 +10,7 @@ import net.corda.cliutils.ExitCodes import net.corda.core.crypto.Crypto import net.corda.core.internal.* import net.corda.core.internal.concurrent.thenMatch +import net.corda.core.internal.cordapp.CordappImpl import net.corda.core.internal.errors.AddressBindingException import net.corda.core.utilities.Try import net.corda.core.utilities.loggerFor @@ -325,7 +326,8 @@ open class NodeStartup: CordaCliWrapper("corda", "Runs a Corda Node") { } val nodeInfo = node.start() - Node.printBasicNodeInfo("Loaded CorDapps", node.services.cordappProvider.cordapps.joinToString { it.name }) + logLoadedCorDapps(node.services.cordappProvider.cordapps) + node.nodeReadyFuture.thenMatch({ val elapsed = (System.currentTimeMillis() - startTime) / 10 / 100.0 val name = nodeInfo.legalIdentitiesAndCerts.first().name.organisation @@ -407,6 +409,17 @@ open class NodeStartup: CordaCliWrapper("corda", "Runs a Corda Node") { ) } + open protected fun logLoadedCorDapps(corDapps: List) { + fun CordappImpl.Info.description() = "$shortName version $version by $vendor" + + Node.printBasicNodeInfo("Loaded ${corDapps.size} CorDapp(s)", corDapps.map { it.info }.joinToString(", ", transform = CordappImpl.Info::description)) + corDapps.map { it.info }.filter { it.hasUnknownFields() }.let { malformed -> + if (malformed.isNotEmpty()) { + logger.warn("Found ${malformed.size} CorDapp(s) with unknown information. They will be unable to run on Corda in the future.") + } + } + } + private fun enforceSingleNodeIsRunning(baseDirectory: Path) { // Write out our process ID (which may or may not resemble a UNIX process id - to us it's just a string) to a // file that we'll do our best to delete on exit. But if we don't, it'll be overwritten next time. If it already diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt index 4241b6aea2..5ab49c53a0 100644 --- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt +++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderImpl.kt @@ -8,6 +8,7 @@ import net.corda.core.cordapp.CordappContext import net.corda.core.crypto.SecureHash import net.corda.core.flows.FlowLogic import net.corda.core.internal.DEPLOYED_CORDAPP_UPLOADER +import net.corda.core.internal.cordapp.CordappImpl import net.corda.core.internal.createCordappContext import net.corda.core.node.services.AttachmentId import net.corda.core.node.services.AttachmentStorage @@ -34,7 +35,7 @@ open class CordappProviderImpl(private val cordappLoader: CordappLoader, /** * Current known CorDapps loaded on this node */ - override val cordapps get() = cordappLoader.cordapps + override val cordapps: List get() = cordappLoader.cordapps fun start(whitelistedContractImplementations: Map>) { cordappAttachments.putAll(loadContractsIntoAttachmentStore()) diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderInternal.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderInternal.kt index 01b88312e6..fcd6e4d602 100644 --- a/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderInternal.kt +++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/CordappProviderInternal.kt @@ -3,8 +3,9 @@ package net.corda.node.internal.cordapp import net.corda.core.cordapp.Cordapp import net.corda.core.cordapp.CordappProvider import net.corda.core.flows.FlowLogic +import net.corda.core.internal.cordapp.CordappImpl interface CordappProviderInternal : CordappProvider { - val cordapps: List + val cordapps: List fun getCordappForFlow(flowLogic: FlowLogic<*>): Cordapp? } diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/JarScanningCordappLoader.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/JarScanningCordappLoader.kt index 94dc45a0fb..be3c8e4deb 100644 --- a/node/src/main/kotlin/net/corda/node/internal/cordapp/JarScanningCordappLoader.kt +++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/JarScanningCordappLoader.kt @@ -14,6 +14,7 @@ import net.corda.core.serialization.SerializationCustomSerializer import net.corda.core.serialization.SerializationWhitelist import net.corda.core.serialization.SerializeAsToken import net.corda.core.utilities.contextLogger +import net.corda.node.VersionInfo import net.corda.node.cordapp.CordappLoader import net.corda.node.internal.classloading.requireAnnotation import net.corda.nodeapi.internal.coreContractClasses @@ -24,6 +25,7 @@ import java.net.URL import java.net.URLClassLoader import java.nio.file.Path import java.util.* +import java.util.jar.JarInputStream import kotlin.reflect.KClass import kotlin.streams.toList @@ -32,9 +34,10 @@ import kotlin.streams.toList * * @property cordappJarPaths The classpath of cordapp JARs */ -class JarScanningCordappLoader private constructor(private val cordappJarPaths: List) : CordappLoaderTemplate() { +class JarScanningCordappLoader private constructor(private val cordappJarPaths: List, + versionInfo: VersionInfo = VersionInfo.UNKNOWN) : CordappLoaderTemplate() { - override val cordapps: List by lazy { loadCordapps() + coreCordapp } + override val cordapps: List by lazy { loadCordapps() + coreCordapp } override val appClassLoader: ClassLoader = URLClassLoader(cordappJarPaths.stream().map { it.url }.toTypedArray(), javaClass.classLoader) @@ -54,10 +57,9 @@ class JarScanningCordappLoader private constructor(private val cordappJarPaths: * * @param corDappDirectories Directories used to scan for CorDapp JARs. */ - fun fromDirectories(corDappDirectories: Iterable): CordappLoader { - + fun fromDirectories(corDappDirectories: Iterable, versionInfo: VersionInfo = VersionInfo.UNKNOWN): JarScanningCordappLoader { logger.info("Looking for CorDapps in ${corDappDirectories.distinct().joinToString(", ", "[", "]")}") - return JarScanningCordappLoader(corDappDirectories.distinct().flatMap(this::jarUrlsInDirectory).map { it.restricted() }) + return JarScanningCordappLoader(corDappDirectories.distinct().flatMap(this::jarUrlsInDirectory).map { it.restricted() }, versionInfo) } /** @@ -65,7 +67,9 @@ class JarScanningCordappLoader private constructor(private val cordappJarPaths: * * @param scanJars Uses the JAR URLs provided for classpath scanning and Cordapp detection. */ - fun fromJarUrls(scanJars: List) = JarScanningCordappLoader(scanJars.map { it.restricted() }) + fun fromJarUrls(scanJars: List, versionInfo: VersionInfo = VersionInfo.UNKNOWN): JarScanningCordappLoader { + return JarScanningCordappLoader(scanJars.map { it.restricted() }, versionInfo) + } private fun URL.restricted(rootPackageName: String? = null) = RestrictedURL(this, rootPackageName) @@ -86,31 +90,30 @@ class JarScanningCordappLoader private constructor(private val cordappJarPaths: ContractUpgradeFlow.Initiate::class.java, ContractUpgradeFlow.Authorise::class.java, ContractUpgradeFlow.Deauthorise::class.java) - - /** A Cordapp representing the core package which is not scanned automatically. */ - @VisibleForTesting - internal val coreCordapp = CordappImpl( - contractClassNames = listOf(), - initiatedFlows = listOf(), - rpcFlows = coreRPCFlows, - serviceFlows = listOf(), - schedulableFlows = listOf(), - services = listOf(), - serializationWhitelists = listOf(), - serializationCustomSerializers = listOf(), - customSchemas = setOf(), - allFlows = listOf(), - jarPath = ContractUpgradeFlow.javaClass.location, // Core JAR location - jarHash = SecureHash.allOnesHash - ) } - private fun loadCordapps(): List { - return cordappJarPaths.map { scanCordapp(it).toCordapp(it) } - } + /** A Cordapp representing the core package which is not scanned automatically. */ + @VisibleForTesting + internal val coreCordapp = CordappImpl( + contractClassNames = listOf(), + initiatedFlows = listOf(), + rpcFlows = coreRPCFlows, + serviceFlows = listOf(), + schedulableFlows = listOf(), + services = listOf(), + serializationWhitelists = listOf(), + serializationCustomSerializers = listOf(), + customSchemas = setOf(), + info = CordappImpl.Info("corda-core", versionInfo.vendor, versionInfo.releaseVersion), + allFlows = listOf(), + jarPath = ContractUpgradeFlow.javaClass.location, // Core JAR location + jarHash = SecureHash.allOnesHash + ) - private fun RestrictedScanResult.toCordapp(url: RestrictedURL): Cordapp { + private fun loadCordapps(): List = cordappJarPaths.map { scanCordapp(it).toCordapp(it) } + private fun RestrictedScanResult.toCordapp(url: RestrictedURL): CordappImpl { + val info = url.url.openStream().let(::JarInputStream).use { it.manifest }.toCordappInfo(CordappImpl.jarName(url.url)) return CordappImpl( findContractClassNames(this), findInitiatedFlows(this), @@ -123,6 +126,7 @@ class JarScanningCordappLoader private constructor(private val cordappJarPaths: findCustomSchemas(this), findAllFlows(this), url.url, + info, getJarHash(url.url) ) } @@ -268,24 +272,23 @@ class JarScanningCordappLoader private constructor(private val cordappJarPaths: class MultipleCordappsForFlowException(message: String) : Exception(message) abstract class CordappLoaderTemplate : CordappLoader { - override val flowCordappMap: Map>, Cordapp> by lazy { cordapps.flatMap { corDapp -> corDapp.allFlows.map { flow -> flow to corDapp } } .groupBy { it.first } - .mapValues { - if(it.value.size > 1) { throw MultipleCordappsForFlowException("There are multiple CorDapp JARs on the classpath for flow ${it.value.first().first.name}: [ ${it.value.joinToString { it.second.name }} ].") } - it.value.single().second + .mapValues { entry -> + if (entry.value.size > 1) { + throw MultipleCordappsForFlowException("There are multiple CorDapp JARs on the classpath for flow " + + "${entry.value.first().first.name}: [ ${entry.value.joinToString { it.second.name }} ].") + } + entry.value.single().second } } override val cordappSchemas: Set by lazy { - cordapps.flatMap { it.customSchemas }.toSet() } override val appClassLoader: ClassLoader by lazy { - URLClassLoader(cordapps.stream().map { it.jarPath }.toTypedArray(), javaClass.classLoader) } } - diff --git a/node/src/main/kotlin/net/corda/node/internal/cordapp/ManifestUtils.kt b/node/src/main/kotlin/net/corda/node/internal/cordapp/ManifestUtils.kt index 86d6a3168b..08dd924243 100644 --- a/node/src/main/kotlin/net/corda/node/internal/cordapp/ManifestUtils.kt +++ b/node/src/main/kotlin/net/corda/node/internal/cordapp/ManifestUtils.kt @@ -1,13 +1,10 @@ package net.corda.node.internal.cordapp -import net.corda.core.cordapp.Cordapp import net.corda.core.internal.cordapp.CordappImpl -import java.util.* import java.util.jar.Attributes import java.util.jar.Manifest fun createTestManifest(name: String, title: String, version: String, vendor: String): Manifest { - val manifest = Manifest() // Mandatory manifest attribute. If not present, all other entries are silently skipped. @@ -27,21 +24,19 @@ fun createTestManifest(name: String, title: String, version: String, vendor: Str } operator fun Manifest.set(key: String, value: String) { - mainAttributes.putValue(key, value) } -internal fun Manifest?.toCordappInfo(defaultShortName: String): Cordapp.Info { - - var unknown = CordappImpl.Info.UNKNOWN +fun Manifest?.toCordappInfo(defaultShortName: String): CordappImpl.Info { + var info = CordappImpl.Info.UNKNOWN (this?.mainAttributes?.getValue("Name") ?: defaultShortName).let { shortName -> - unknown = unknown.copy(shortName = shortName) + info = info.copy(shortName = shortName) } this?.mainAttributes?.getValue("Implementation-Vendor")?.let { vendor -> - unknown = unknown.copy(vendor = vendor) + info = info.copy(vendor = vendor) } this?.mainAttributes?.getValue("Implementation-Version")?.let { version -> - unknown = unknown.copy(version = version) + info = info.copy(version = version) } - return unknown -} \ No newline at end of file + return info +} 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 f0e9b2b17d..6134aa348f 100644 --- a/node/src/test/kotlin/net/corda/node/internal/NodeTest.kt +++ b/node/src/test/kotlin/net/corda/node/internal/NodeTest.kt @@ -58,12 +58,9 @@ class NodeTest { @Test fun `generateAndSaveNodeInfo works`() { val configuration = createConfig(ALICE_NAME) - val platformVersion = 789 + val info = VersionInfo(789, "3.0", "SNAPSHOT", "R3") configureDatabase(configuration.dataSourceProperties, configuration.database, { null }, { null }).use { - val versionInfo = rigorousMock().also { - doReturn(platformVersion).whenever(it).platformVersion - } - val node = Node(configuration, versionInfo, initialiseSerialization = false) + val node = Node(configuration, info, initialiseSerialization = false) assertEquals(node.generateNodeInfo(), node.generateNodeInfo()) // Node info doesn't change (including the serial) } } @@ -87,9 +84,8 @@ class NodeTest { // Save some NodeInfo session.save(persistentNodeInfo) } - val node = Node(configuration, rigorousMock().also { - doReturn(10).whenever(it).platformVersion - }, initialiseSerialization = false) + val versionInfo = VersionInfo(10, "3.0", "SNAPSHOT", "R3") + val node = Node(configuration, versionInfo, initialiseSerialization = false) assertThat(getAllInfos(it)).isNotEmpty node.clearNetworkMapCache() assertThat(getAllInfos(it)).isEmpty() @@ -97,7 +93,7 @@ class NodeTest { } @Test - fun `Node can start with multiple keypairs for it's identity`() { + fun `Node can start with multiple keypairs for its identity`() { val configuration = createConfig(ALICE_NAME) val (nodeInfo1, _) = createNodeInfoAndSigned(ALICE_NAME) val (nodeInfo2, _) = createNodeInfoAndSigned(ALICE_NAME) @@ -135,6 +131,8 @@ class NodeTest { val node = Node(configuration, rigorousMock().also { doReturn(10).whenever(it).platformVersion + doReturn("test-vendor").whenever(it).vendor + doReturn("1.0").whenever(it).releaseVersion }, initialiseSerialization = false) //this throws an exception with old behaviour diff --git a/node/src/test/kotlin/net/corda/node/internal/cordapp/JarScanningCordappLoaderTest.kt b/node/src/test/kotlin/net/corda/node/internal/cordapp/JarScanningCordappLoaderTest.kt index 1ab3482533..e46cb15278 100644 --- a/node/src/test/kotlin/net/corda/node/internal/cordapp/JarScanningCordappLoaderTest.kt +++ b/node/src/test/kotlin/net/corda/node/internal/cordapp/JarScanningCordappLoaderTest.kt @@ -46,7 +46,7 @@ class JarScanningCordappLoaderTest { fun `test that classes that aren't in cordapps aren't loaded`() { // Basedir will not be a corda node directory so the dummy flow shouldn't be recognised as a part of a cordapp val loader = JarScanningCordappLoader.fromDirectories(listOf(Paths.get("."))) - assertThat(loader.cordapps).containsOnly(JarScanningCordappLoader.coreCordapp) + assertThat(loader.cordapps).containsOnly(loader.coreCordapp) } @Test @@ -57,7 +57,7 @@ class JarScanningCordappLoaderTest { val actual = loader.cordapps.toTypedArray() assertThat(actual).hasSize(2) - val actualCordapp = actual.single { it != JarScanningCordappLoader.coreCordapp } + val actualCordapp = actual.single { it != loader.coreCordapp } assertThat(actualCordapp.contractClassNames).isEqualTo(listOf(isolatedContractId)) assertThat(actualCordapp.initiatedFlows.single().name).isEqualTo("net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Acceptor") assertThat(actualCordapp.rpcFlows).isEmpty() @@ -91,7 +91,7 @@ class JarScanningCordappLoaderTest { @Test fun `sub-packages are ignored`() { - val loader = cordappLoaderForPackages(listOf("net.corda", testScanPackage)) + val loader = cordappLoaderForPackages(listOf("net.corda.core", testScanPackage)) val cordapps = loader.cordapps.filter { LoaderTestFlow::class.java in it.initiatedFlows } assertThat(cordapps).hasSize(1) } 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 e47bc11f0d..5e2d1aa04b 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 @@ -17,7 +17,7 @@ class AttachmentDemoTest { @Test fun `attachment demo using a 10MB zip file`() { val numOfExpectedBytes = 10_000_000 - driver(DriverParameters(portAllocation = PortAllocation.Incremental(20000))) { + driver(DriverParameters(portAllocation = PortAllocation.Incremental(20000), startNodesInProcess = true)) { val demoUser = listOf(User("demo", "demo", setOf(all()))) val (nodeA, nodeB) = listOf( startNode(providedName = DUMMY_BANK_A_NAME, rpcUsers = demoUser, maximumHeapSize = "1g"), diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/internal/MockCordappProvider.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/internal/MockCordappProvider.kt index 508ace7fb4..9874799f6d 100644 --- a/testing/test-utils/src/main/kotlin/net/corda/testing/internal/MockCordappProvider.kt +++ b/testing/test-utils/src/main/kotlin/net/corda/testing/internal/MockCordappProvider.kt @@ -33,6 +33,7 @@ class MockCordappProvider( serializationCustomSerializers = emptyList(), customSchemas = emptySet(), jarPath = Paths.get("").toUri().toURL(), + info = CordappImpl.Info.UNKNOWN, allFlows = emptyList(), jarHash = SecureHash.allOnesHash) if (cordappRegistry.none { it.first.contractClassNames.contains(contractClassName) }) { @@ -40,7 +41,9 @@ class MockCordappProvider( } } - override fun getContractAttachmentID(contractClassName: ContractClassName): AttachmentId? = cordappRegistry.find { it.first.contractClassNames.contains(contractClassName) }?.second ?: super.getContractAttachmentID(contractClassName) + override fun getContractAttachmentID(contractClassName: ContractClassName): AttachmentId? { + return cordappRegistry.find { it.first.contractClassNames.contains(contractClassName) }?.second ?: super.getContractAttachmentID(contractClassName) + } private fun findOrImportAttachment(contractClassNames: List, data: ByteArray, attachments: MockAttachmentStorage): AttachmentId { val existingAttachment = attachments.files.filter {