ENT-3496 Move dumpCheckpoints to the new InternalCordaRPCOps interface

To prevent making `dumpCheckpoints` part of the public API a new interface, `InternalCordaRPCOps` has been created and the function has been moved there. `InternalCordaRPCOps` inherits from `CordaRPCOps`. `CordaRPCOpsImpl` now implements `InternalCordaRPCOps`. `RunShellCommand` and `StringToMethodCallParser` required additional changes due to issues handling inherited functions. This has only been raised now due to `InternalCordaRPCOps` inheriting from `CordaRPCOps`. Many classes have had references to `CordaRPCOps` changed to `InternalCordaRPCOps`.
2025-06-21 16:49:45 +00:00 · 2019-06-10 16:15:03 +01:00
parent d8395baf62
commit 31a0c077b8
17 changed files with 126 additions and 80 deletions
--- a/tools/shell/src/integration-test/kotlin/net/corda/tools/shell/InteractiveShellIntegrationTest.kt
+++ b/tools/shell/src/integration-test/kotlin/net/corda/tools/shell/InteractiveShellIntegrationTest.kt
@ -1,15 +1,19 @@
 package net.corda.tools.shell

+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.databind.type.TypeFactory
 import com.google.common.io.Files
 import com.jcraft.jsch.ChannelExec
 import com.jcraft.jsch.JSch
 import com.nhaarman.mockito_kotlin.any
 import com.nhaarman.mockito_kotlin.doAnswer
 import com.nhaarman.mockito_kotlin.mock
+import net.corda.client.jackson.JacksonSupport
 import net.corda.client.rpc.RPCException
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.StartableByRPC
 import net.corda.core.internal.div
+import net.corda.core.internal.messaging.InternalCordaRPCOps
 import net.corda.core.messaging.ClientRpcSslOptions
 import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.utilities.ProgressTracker
@ -33,11 +37,13 @@ import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.bouncycastle.util.io.Streams
 import org.crsh.text.RenderPrintWriter
+import org.junit.Before
 import org.junit.Ignore
 import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.TemporaryFolder
 import javax.security.auth.x500.X500Principal
+import kotlin.test.assertNotEquals
 import kotlin.test.assertTrue

 class InteractiveShellIntegrationTest {
@ -47,6 +53,13 @@ class InteractiveShellIntegrationTest {

    private val testName = X500Principal("CN=Test,O=R3 Ltd,L=London,C=GB")

+    private lateinit var inputObjectMapper: ObjectMapper
+
+    @Before
+    fun setup() {
+        inputObjectMapper = objectMapperWithClassLoader(InteractiveShell.getCordappsClassloader())
+    }
+
    @Test
    fun `shell should not log in with invalid credentials`() {
        val user = User("u", "p", setOf())
@ -277,6 +290,30 @@ class InteractiveShellIntegrationTest {
        assertThat(successful).isTrue()
    }

+    @Test
+    fun `can run dumpCheckpoints`() {
+        val user = User("u", "p", setOf(all()))
+        driver(DriverParameters(notarySpecs = emptyList())) {
+            val nodeFuture = startNode(providedName = ALICE_NAME, rpcUsers = listOf(user), startInSameProcess = true)
+            val node = nodeFuture.getOrThrow()
+
+            val conf = ShellConfiguration(commandsDirectory = Files.createTempDir().toPath(),
+                    user = user.username, password = user.password,
+                    hostAndPort = node.rpcAddress)
+            InteractiveShell.startShell(conf)
+            // setup and configure some mocks required by InteractiveShell.runFlowByNameFragment()
+            val output = mock<RenderPrintWriter> {
+                on { println(any<String>()) } doAnswer {
+                    val line = it.arguments[0]
+                    assertNotEquals("Please try 'man run' to learn what syntax is acceptable", line)
+                }
+            }
+            // can call without causing any errors, no output to easily check
+            InteractiveShell.runRPCFromString(
+                    listOf("dumpCheckpoints"), output, mock(), node.rpc as InternalCordaRPCOps, inputObjectMapper)
+        }
+    }
+
    @Test
    fun `shell should start flow with unique un-qualified class name`() {
        val user = User("u", "p", setOf(all()))
@ -372,6 +409,14 @@ class InteractiveShellIntegrationTest {
        }
        assertThat(successful).isTrue()
    }
+
+    private fun objectMapperWithClassLoader(classLoader: ClassLoader?): ObjectMapper {
+        val objectMapper = JacksonSupport.createNonRpcMapper()
+        val tf = TypeFactory.defaultInstance().withClassLoader(classLoader)
+        objectMapper.typeFactory = tf
+
+        return objectMapper
+    }
 }

@Suppress("UNUSED")
--- a/tools/shell/src/main/java/net/corda/tools/shell/RunShellCommand.java
+++ b/tools/shell/src/main/java/net/corda/tools/shell/RunShellCommand.java
@ -3,6 +3,7 @@ package net.corda.tools.shell;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import net.corda.client.jackson.StringToMethodCallParser;
+import net.corda.core.internal.messaging.InternalCordaRPCOps;
 import net.corda.core.messaging.CordaRPCOps;
 import org.crsh.cli.Argument;
 import org.crsh.cli.Command;
@ -13,10 +14,7 @@ import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;

 import static java.util.Comparator.comparing;

@ -38,21 +36,31 @@ public class RunShellCommand extends InteractiveShellCommand {
    public Object main(InvocationContext<Map> context,
                       @Usage("The command to run") @Argument(unquote = false) List<String> command) {
        logger.info("Executing command \"run {}\",", (command != null) ? String.join(" ", command) : "<no arguments>");
-        StringToMethodCallParser<CordaRPCOps> parser = new StringToMethodCallParser<>(CordaRPCOps.class, objectMapper(InteractiveShell.getCordappsClassloader()));

        if (command == null) {
-            emitHelp(context, parser);
+            emitHelp(context);
            return null;
        }

        return InteractiveShell.runRPCFromString(command, out, context, ops(), objectMapper(InteractiveShell.getCordappsClassloader()));
    }

-    private void emitHelp(InvocationContext<Map> context, StringToMethodCallParser<CordaRPCOps> parser) {
-        // Sends data down the pipeline about what commands are available. CRaSH will render it nicely.
-        // Each element we emit is a map of column -> content.
-        Set<Map.Entry<String, String>> entries = parser.getAvailableCommands().entrySet();
-        List<Map.Entry<String, String>> entryList = new ArrayList<>(entries);
+  private void emitHelp(InvocationContext<Map> context) {
+    // to handle the lack of working inheritance in [StringToMethodCallParser] two parsers are used
+    StringToMethodCallParser<CordaRPCOps> cordaRpcOpsParser =
+        new StringToMethodCallParser<>(
+            CordaRPCOps.class, objectMapper(InteractiveShell.getCordappsClassloader()));
+    StringToMethodCallParser<InternalCordaRPCOps> internalCordaRpcOpsParser =
+        new StringToMethodCallParser<>(
+            InternalCordaRPCOps.class, objectMapper(InteractiveShell.getCordappsClassloader()));
+
+    // Sends data down the pipeline about what commands are available. CRaSH will render it nicely.
+    // Each element we emit is a map of column -> content.
+    Set<Map.Entry<String, String>> entries = cordaRpcOpsParser.getAvailableCommands().entrySet();
+    Set<Map.Entry<String, String>> internalEntries = internalCordaRpcOpsParser.getAvailableCommands().entrySet();
+    Set<Map.Entry<String, String>> entrySet = new HashSet<>(entries);
+    entrySet.addAll(internalEntries);
+    List<Map.Entry<String, String>> entryList = new ArrayList<>(entrySet);
        entryList.sort(comparing(Map.Entry::getKey));
        for (Map.Entry<String, String> entry : entryList) {
            // Skip these entries as they aren't really interesting for the user.
--- a/tools/shell/src/main/kotlin/net/corda/tools/shell/CordaAuthenticationPlugin.kt
+++ b/tools/shell/src/main/kotlin/net/corda/tools/shell/CordaAuthenticationPlugin.kt
@ -1,13 +1,13 @@
 package net.corda.tools.shell

-import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.internal.messaging.InternalCordaRPCOps
 import net.corda.core.utilities.loggerFor
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
 import org.crsh.auth.AuthInfo
 import org.crsh.auth.AuthenticationPlugin
 import org.crsh.plugin.CRaSHPlugin

-class CordaAuthenticationPlugin(private val rpcOps: (username: String, credential: String) -> CordaRPCOps) : CRaSHPlugin<AuthenticationPlugin<String>>(), AuthenticationPlugin<String> {
+class CordaAuthenticationPlugin(private val rpcOps: (username: String, credential: String) -> InternalCordaRPCOps) : CRaSHPlugin<AuthenticationPlugin<String>>(), AuthenticationPlugin<String> {

    companion object {
        private val logger = loggerFor<CordaAuthenticationPlugin>()
--- a/tools/shell/src/main/kotlin/net/corda/tools/shell/CordaSSHAuthInfo.kt
+++ b/tools/shell/src/main/kotlin/net/corda/tools/shell/CordaSSHAuthInfo.kt
@ -1,12 +1,12 @@
 package net.corda.tools.shell

 import com.fasterxml.jackson.databind.ObjectMapper
-import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.internal.messaging.InternalCordaRPCOps
 import net.corda.tools.shell.InteractiveShell.createYamlInputMapper
 import net.corda.tools.shell.utlities.ANSIProgressRenderer
 import org.crsh.auth.AuthInfo

-class CordaSSHAuthInfo(val successful: Boolean, val rpcOps: CordaRPCOps, val ansiProgressRenderer: ANSIProgressRenderer? = null, val isSsh: Boolean = false) : AuthInfo {
+class CordaSSHAuthInfo(val successful: Boolean, val rpcOps: InternalCordaRPCOps, val ansiProgressRenderer: ANSIProgressRenderer? = null, val isSsh: Boolean = false) : AuthInfo {
    override fun isSuccessful(): Boolean = successful

    val yamlInputMapper: ObjectMapper by lazy {
--- a/tools/shell/src/main/kotlin/net/corda/tools/shell/InteractiveShell.kt
+++ b/tools/shell/src/main/kotlin/net/corda/tools/shell/InteractiveShell.kt
@ -23,6 +23,7 @@ import net.corda.core.flows.StateMachineRunId
 import net.corda.core.internal.*
 import net.corda.core.internal.concurrent.doneFuture
 import net.corda.core.internal.concurrent.openFuture
+import net.corda.core.internal.messaging.InternalCordaRPCOps
 import net.corda.core.messaging.*
 import net.corda.tools.shell.utlities.ANSIProgressRenderer
 import net.corda.tools.shell.utlities.StdoutANSIProgressRenderer
@ -73,8 +74,8 @@ import kotlin.concurrent.thread

 object InteractiveShell {
    private val log = LoggerFactory.getLogger(javaClass)
-    private lateinit var rpcOps: (username: String, password: String) -> CordaRPCOps
-    private lateinit var ops: CordaRPCOps
+    private lateinit var rpcOps: (username: String, password: String) -> InternalCordaRPCOps
+    private lateinit var ops: InternalCordaRPCOps
    private lateinit var rpcConn: AutoCloseable
    private var shell: Shell? = null
    private var classLoader: ClassLoader? = null
@ -104,7 +105,7 @@ object InteractiveShell {
                        classLoader = classLoader)
                val connection = client.start(username, password)
                rpcConn = connection
-                connection.proxy
+                connection.proxy as InternalCordaRPCOps
            }
        }
        _startShell(configuration, classLoader)
@ -488,7 +489,7 @@ object InteractiveShell {
    }

    @JvmStatic
-    fun runRPCFromString(input: List<String>, out: RenderPrintWriter, context: InvocationContext<out Any>, cordaRPCOps: CordaRPCOps,
+    fun runRPCFromString(input: List<String>, out: RenderPrintWriter, context: InvocationContext<out Any>, cordaRPCOps: InternalCordaRPCOps,
                         inputObjectMapper: ObjectMapper): Any? {
        val cmd = input.joinToString(" ").trim { it <= ' ' }
        if (cmd.startsWith("startflow", ignoreCase = true)) {
@ -504,7 +505,7 @@ object InteractiveShell {
        var result: Any? = null
        try {
            InputStreamSerializer.invokeContext = context
-            val parser = StringToMethodCallParser(CordaRPCOps::class.java, inputObjectMapper)
+            val parser = StringToMethodCallParser(InternalCordaRPCOps::class.java, inputObjectMapper)
            val call = parser.parse(cordaRPCOps, cmd)
            result = call.call()
            if (result != null && result !== kotlin.Unit && result !is Void) {
--- a/tools/shell/src/main/kotlin/net/corda/tools/shell/RPCOpsWithContext.kt
+++ b/tools/shell/src/main/kotlin/net/corda/tools/shell/RPCOpsWithContext.kt
@ -1,20 +1,20 @@
 package net.corda.tools.shell

-import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.internal.messaging.InternalCordaRPCOps
 import java.lang.reflect.InvocationTargetException
 import java.lang.reflect.Proxy

-fun makeRPCOps(getCordaRPCOps: (username: String, credential: String) -> CordaRPCOps, username: String, credential: String): CordaRPCOps {
-    val cordaRPCOps: CordaRPCOps by lazy {
+fun makeRPCOps(getCordaRPCOps: (username: String, credential: String) -> InternalCordaRPCOps, username: String, credential: String): InternalCordaRPCOps {
+    val cordaRPCOps: InternalCordaRPCOps by lazy {
        getCordaRPCOps(username, credential)
    }

-    return Proxy.newProxyInstance(CordaRPCOps::class.java.classLoader, arrayOf(CordaRPCOps::class.java), { _, method, args ->
+    return Proxy.newProxyInstance(InternalCordaRPCOps::class.java.classLoader, arrayOf(InternalCordaRPCOps::class.java)) { _, method, args ->
        try {
            method.invoke(cordaRPCOps, *(args ?: arrayOf()))
        } catch (e: InvocationTargetException) {
            // Unpack exception.
            throw e.targetException
        }
-    }) as CordaRPCOps
+    } as InternalCordaRPCOps
 }
--- a/tools/shell/src/test/kotlin/net/corda/tools/shell/InteractiveShellTest.kt
+++ b/tools/shell/src/test/kotlin/net/corda/tools/shell/InteractiveShellTest.kt
@ -18,7 +18,7 @@ import net.corda.core.flows.StateMachineRunId
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.internal.concurrent.openFuture
-import net.corda.core.messaging.CordaRPCOps
+import net.corda.core.internal.messaging.InternalCordaRPCOps
 import net.corda.core.messaging.FlowProgressHandleImpl
 import net.corda.core.node.NodeInfo
 import net.corda.core.utilities.NetworkHostAndPort
@ -41,7 +41,7 @@ import kotlin.test.assertFailsWith

 class InteractiveShellTest {
    lateinit var inputObjectMapper: ObjectMapper
-    lateinit var cordaRpcOps: CordaRPCOps
+    lateinit var cordaRpcOps: InternalCordaRPCOps
    lateinit var invocationContext: InvocationContext<Map<Any, Any>>
    lateinit var printWriter: RenderPrintWriter