ENT-11263: Remove TooGenericExceptionCaught detekt rule

Author: shamsasari

client/rpc/src/main/kotlin/net/corda/client/rpc/internal/RPCClientProxyHandler.kt

@@ -150,7 +150,6 @@ internal class RPCClientProxyHandler(
             }
         }
 
-        @Suppress("TooGenericExceptionCaught")
         private fun closeObservable(observable: UnicastSubject<Notification<*>>) {
             // Notify listeners of the observables that the connection is being terminated.
             try {
@@ -589,7 +588,6 @@ internal class RPCClientProxyHandler(
         }
         if (observableIds != null) {
             log.debug { "Reaping ${observableIds.size} observables" }
-            @Suppress("TooGenericExceptionCaught")
             try {
                 sendMessage(RPCApi.ClientToServer.ObservablesClosed(observableIds))
             } catch(ex: Exception) {

core-tests/src/test/kotlin/net/corda/coretests/flows/FlowExternalAsyncOperationTest.kt

@@ -253,7 +253,6 @@ class FlowExternalAsyncOperationTest : AbstractFlowExternalOperationTest() {
     @StartableByRPC
     class FlowWithExternalAsyncOperationThatDirectlyAccessesServiceHubFailsRetry(party: Party) : FlowWithExternalProcess(party) {
 
-        @Suppress("TooGenericExceptionCaught")
         @Suspendable
         override fun testCode(): Any {
             return await(ExternalAsyncOperation(serviceHub) { _, _ ->

core-tests/src/test/kotlin/net/corda/coretests/flows/FlowExternalOperationTest.kt

@@ -293,7 +293,6 @@ class FlowExternalOperationTest : AbstractFlowExternalOperationTest() {
     @StartableByRPC
     class FlowWithExternalOperationThatDirectlyAccessesServiceHubFailsRetry(party: Party) : FlowWithExternalProcess(party) {
 
-        @Suppress("TooGenericExceptionCaught")
         @Suspendable
         override fun testCode(): Any {
             try {

core/src/main/kotlin/net/corda/core/crypto/internal/PlatformSecureRandom.kt

@@ -14,6 +14,7 @@ import java.io.InputStream
 import java.security.Provider
 import java.security.SecureRandom
 import java.security.SecureRandomSpi
+import kotlin.system.exitProcess
 
 /**
  * This has been migrated into a separate class so that it
@@ -29,23 +30,22 @@ val platformSecureRandom: () -> SecureRandom = when {
 }
 
 class PlatformSecureRandomService(provider: Provider)
-    : Provider.Service(provider, "SecureRandom", algorithm, PlatformSecureRandomSpi::javaClass.name, null, null) {
+    : Provider.Service(provider, "SecureRandom", ALGORITHM, PlatformSecureRandomSpi::javaClass.name, null, null) {
 
     companion object {
-        const val algorithm = "CordaPRNG"
+        const val ALGORITHM = "CordaPRNG"
+
         private val logger = loggerFor<PlatformSecureRandomService>()
     }
 
     private val instance: SecureRandomSpi = if (SystemUtils.IS_OS_LINUX) tryAndUseLinuxSecureRandomSpi() else PlatformSecureRandomSpi()
 
-    @Suppress("TooGenericExceptionCaught", "TooGenericExceptionThrown")
     private fun tryAndUseLinuxSecureRandomSpi(): SecureRandomSpi = try {
         LinuxSecureRandomSpi()
     } catch (e: Exception) {
         logger.error("Unable to initialise LinuxSecureRandomSpi. The exception logged with this message might assist with diagnosis." +
                 "  The process will now exit.", e)
-        System.exit(1)
-        throw RuntimeException("Never reached, but calms the compiler.")
+        exitProcess(1)
     }
 
     override fun newInstance(constructorParameter: Any?) = instance
@@ -63,7 +63,7 @@ private class PlatformSecureRandomSpi : SecureRandomSpi() {
     override fun engineGenerateSeed(numBytes: Int): ByteArray = secureRandom.generateSeed(numBytes)
 }
 
-@Suppress("TooGenericExceptionCaught", "TooGenericExceptionThrown")
+@Suppress("TooGenericExceptionThrown")
 private class LinuxSecureRandomSpi : SecureRandomSpi() {
     private fun openURandom(): InputStream {
         try {
@@ -91,5 +91,5 @@ private class LinuxSecureRandomSpi : SecureRandomSpi() {
 
 // This is safe to share because of the underlying implementation of SecureRandomSpi
 private val sharedSecureRandom: SecureRandom by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    SecureRandom.getInstance(PlatformSecureRandomService.algorithm)
+    SecureRandom.getInstance(PlatformSecureRandomService.ALGORITHM)
 }

core/src/main/kotlin/net/corda/core/internal/concurrent/CordaFutureImpl.kt

@@ -84,7 +84,6 @@ fun <ELEMENT> CordaFuture<out ELEMENT>.mapError(transform: (Throwable) -> Throwa
  * But if this future or the transform fails, the returned future's outcome is the same throwable.
  * In the case where this future fails, the transform is not invoked.
  */
-@Suppress("TooGenericExceptionCaught")
 fun <V, W> CordaFuture<out V>.flatMap(transform: (V) -> CordaFuture<out W>): CordaFuture<W> = CordaFutureImpl<W>().also { result ->
     thenMatch(success@ {
         result.captureLater(try {
@@ -146,7 +145,6 @@ interface ValueOrException<in V> {
     fun captureLater(f: CordaFuture<out V>) = f.then { capture { f.getOrThrow() } }
 
     /** Run the given block (in the foreground) and set this future to its outcome. */
-    @Suppress("TooGenericExceptionCaught")
     fun capture(block: () -> V): Boolean {
         return set(try {
             block()
@@ -174,7 +172,6 @@ class CordaFutureImpl<V>(private val impl: CompletableFuture<V> = CompletableFut
     override fun setException(t: Throwable) = impl.completeExceptionally(t)
     override fun <W> then(callback: (CordaFuture<V>) -> W) = thenImpl(defaultLog, callback)
     /** For testing only. */
-    @Suppress("TooGenericExceptionCaught")
     fun <W> thenImpl(log: Logger, callback: (CordaFuture<V>) -> W) {
         impl.whenComplete { _, _ ->
             try {

core/src/main/kotlin/net/corda/core/internal/telemetry/TelemetryServiceImpl.kt

@@ -178,7 +178,6 @@ class TelemetryServiceImpl : SingletonSerializeAsToken(), TelemetryService {
         }
     }
 
-    @Suppress("TooGenericExceptionCaught")
     inline fun <R> span(name: String, attributes: Map<String, String> = emptyMap(), flowLogic: FlowLogic<*>? = null, block: () -> R): R {
         val telemetryId = startSpan(name, attributes, flowLogic)
         try {
@@ -195,7 +194,7 @@ class TelemetryServiceImpl : SingletonSerializeAsToken(), TelemetryService {
     }
 
     @CordaInternal
-    @Suppress("LongParameterList", "TooGenericExceptionCaught")
+    @Suppress("LongParameterList")
     inline fun <R> spanForFlow(name: String, attributes: Map<String, String>, flowLogic: FlowLogic<*>? = null, remoteSerializedTelemetry: SerializedTelemetry? = null, block: () -> R): R {
         val telemetryId = startSpanForFlow(name, attributes, flowLogic, remoteSerializedTelemetry)
         try {

core/src/main/kotlin/net/corda/core/internal/verification/Verifier.kt

@@ -440,7 +440,6 @@ private class Validator(private val ltx: LedgerTransaction, private val transact
  * Verify the given [LedgerTransaction]. This includes validating
  * its contents, as well as executing all of its smart contracts.
  */
-@Suppress("TooGenericExceptionCaught")
 class TransactionVerifier(private val transactionClassLoader: ClassLoader) : Function<Supplier<LedgerTransaction>, Unit> {
     // Loads the contract class from the transactionClassLoader.
     private fun createContractClass(id: SecureHash, contractClassName: ContractClassName): Class<out Contract> {

core/src/main/kotlin/net/corda/core/observable/internal/ResilientSubscriber.kt

@@ -33,7 +33,6 @@ class ResilientSubscriber<T>(actual: Subscriber<in T>) : SafeSubscriber<T>(actua
      * It only delegates to [SafeSubscriber.onError] if it wraps an [ActionSubscriber] which is
      * a leaf in an Subscribers' tree structure.
      */
-    @Suppress("TooGenericExceptionCaught")
     override fun onNext(t: T) {
         try {
             actual.onNext(t)
@@ -62,7 +61,6 @@ class ResilientSubscriber<T>(actual: Subscriber<in T>) : SafeSubscriber<T>(actua
     /**
      * Duplicate of [SafeSubscriber._onError]. However, it will not call [Subscriber.unsubscribe].
      */
-    @Suppress("TooGenericExceptionCaught")
     override fun _onError(e: Throwable) {
         @Suppress("DEPRECATION")
         RxJavaPlugins.getInstance().errorHandler.handleError(e)

core/src/main/kotlin/net/corda/core/serialization/internal/AttachmentsClassLoader.kt

@@ -8,8 +8,8 @@ import net.corda.core.contracts.TransactionVerificationException
 import net.corda.core.contracts.TransactionVerificationException.OverlappingAttachmentsException
 import net.corda.core.contracts.TransactionVerificationException.PackageOwnershipException
 import net.corda.core.crypto.SecureHash
-import net.corda.core.internal.JAVA_1_2_CLASS_FILE_FORMAT_MAJOR_VERSION
 import net.corda.core.internal.JAVA_17_CLASS_FILE_FORMAT_MAJOR_VERSION
+import net.corda.core.internal.JAVA_1_2_CLASS_FILE_FORMAT_MAJOR_VERSION
 import net.corda.core.internal.JarSignatureCollector
 import net.corda.core.internal.NamedCacheFactory
 import net.corda.core.internal.PlatformVersionSwitches
@@ -118,16 +118,11 @@ class AttachmentsClassLoader(attachments: List<Attachment>,
                     // Reset the value to prevent Error due to a factory already defined
                     factoryField.set(null, null)
                     // Set our custom factory and wrap the current one into it
-                    URL.setURLStreamHandlerFactory(
-                            // Set the factory to a decorator
-                            object : URLStreamHandlerFactory {
-                                // route between our own and the pre-existing factory
-                                override fun createURLStreamHandler(protocol: String): URLStreamHandler? {
-                                    return AttachmentURLStreamHandlerFactory.createURLStreamHandler(protocol)
-                                            ?: existingFactory.createURLStreamHandler(protocol)
-                                }
-                            }
-                    )
+                    URL.setURLStreamHandlerFactory { protocol ->
+                        // route between our own and the pre-existing factory
+                        AttachmentURLStreamHandlerFactory.createURLStreamHandler(protocol)
+                                ?: existingFactory.createURLStreamHandler(protocol)
+                    }
                 }
             }
         }
@@ -158,9 +153,7 @@ class AttachmentsClassLoader(attachments: List<Attachment>,
         checkAttachments(attachments)
     }
 
-    private class AttachmentHashContext(
-            val txId: SecureHash,
-            val buffer: ByteArray = ByteArray(DEFAULT_BUFFER_SIZE))
+    private class AttachmentHashContext(val buffer: ByteArray = ByteArray(DEFAULT_BUFFER_SIZE))
 
     private fun hash(inputStream : InputStream, ctx : AttachmentHashContext) : SecureHash.SHA256 {
         val md = MessageDigest.getInstance(SecureHash.SHA2_256)
@@ -189,7 +182,7 @@ class AttachmentsClassLoader(attachments: List<Attachment>,
     // This function attempts to strike a balance between security and usability when it comes to the no-overlap rule.
     // TODO - investigate potential exploits.
     private fun shouldCheckForNoOverlap(path: String, targetPlatformVersion: Int): Boolean {
-        require(path.toLowerCase() == path)
+        require(path.lowercase() == path)
         require(!path.contains('\\'))
 
         return when {
@@ -234,7 +227,7 @@ class AttachmentsClassLoader(attachments: List<Attachment>,
         // claim their parts of the Java package namespace via registration with the zone operator.
 
         val classLoaderEntries = mutableMapOf<String, SecureHash>()
-        val ctx = AttachmentHashContext(sampleTxId)
+        val ctx = AttachmentHashContext()
         for (attachment in attachments) {
             // We may have been given an attachment loaded from the database in which case, important info like
             // signers is already calculated.
@@ -270,7 +263,7 @@ class AttachmentsClassLoader(attachments: List<Attachment>,
                     // filesystem tries to be case insensitive. This may break developers who attempt to use ProGuard.
                     //
                     // Also convert to Unix path separators as all resource/class lookups will expect this.
-                    val path = entry.name.toLowerCase(Locale.US).replace('\\', '/')
+                    val path = entry.name.lowercase(Locale.US).replace('\\', '/')
 
                     // Namespace ownership. We only check class files: resources are loaded relative to a JAR anyway.
                     if (path.endsWith(".class")) {
@@ -285,7 +278,7 @@ class AttachmentsClassLoader(attachments: List<Attachment>,
                         for ((namespace, pubkey) in params.packageOwnership) {
                             // Note that due to the toLowerCase() call above, we'll be comparing against a lowercased
                             // version of the ownership claim.
-                            val ns = namespace.toLowerCase(Locale.US)
+                            val ns = namespace.lowercase(Locale.US)
                             // We need an additional . to avoid matching com.foo.Widget against com.foobar.Zap
                             if (pkgName == ns || pkgName.startsWith("$ns.")) {
                                 if (pubkey !in signers)
@@ -358,7 +351,7 @@ object AttachmentsClassLoaderBuilder {
         val attachmentIds = attachments.mapTo(LinkedHashSet(), Attachment::id)
 
         val cache = attachmentsClassLoaderCache ?: fallBackCache
-        val cachedSerializationContext = cache.computeIfAbsent(AttachmentsClassLoaderKey(attachmentIds, params), Function { key ->
+        val cachedSerializationContext = cache.computeIfAbsent(AttachmentsClassLoaderKey(attachmentIds, params)) { key ->
             // Create classloader and load serializers, whitelisted classes
             val transactionClassLoader = AttachmentsClassLoader(attachments, key.params, txId, isAttachmentTrusted, parent)
             val serializers = try {
@@ -380,9 +373,9 @@ object AttachmentsClassLoaderBuilder {
                     .withWhitelist(whitelistedClasses)
                     .withCustomSerializers(serializers)
                     .withoutCarpenter()
-        })
+        }
 
-        val serializationContext = cachedSerializationContext.withProperties(mapOf<Any, Any>(
+        val serializationContext = cachedSerializationContext.withProperties(mapOf(
                 // Duplicate the SerializationContext from the cache and give
                 // it these extra properties, just for this transaction.
                 // However, keep a strong reference to the cached SerializationContext so we can
@@ -489,7 +482,6 @@ class AttachmentsClassLoaderCacheImpl(cacheFactory: NamedCacheFactory) : Singlet
     private val toBeClosed = ConcurrentHashMap.newKeySet<ToBeClosed>()
     private val expiryQueue = ReferenceQueue<SerializationContext>()
 
-    @Suppress("TooGenericExceptionCaught")
     private fun purgeExpiryQueue() {
         // Close the AttachmentsClassLoader for every SerializationContext
         // that has already been garbage-collected.

core/src/main/kotlin/net/corda/core/transactions/ContractUpgradeTransactions.kt

@@ -290,7 +290,6 @@ private constructor(
         //  upgraded attachments
         @CordaInternal
         @JvmSynthetic
-        @Suppress("TooGenericExceptionCaught")
         internal fun loadUpgradedContract(className: ContractClassName, id: SecureHash, classLoader: ClassLoader): UpgradedContract<ContractState, *> {
             return try {
                 loadClassOfType<UpgradedContract<ContractState, *>>(className, false, classLoader)

core/src/test/kotlin/net/corda/core/crypto/CryptoUtilsTest.kt

@@ -943,17 +943,17 @@ class CryptoUtilsTest {
         Security.removeProvider(CordaSecurityProvider.PROVIDER_NAME)
         // Try after removing CordaSecurityProvider.
         val secureRandomNotRegisteredCordaProvider = SecureRandom()
-        assertNotEquals(PlatformSecureRandomService.algorithm, secureRandomNotRegisteredCordaProvider.algorithm)
+        assertNotEquals(PlatformSecureRandomService.ALGORITHM, secureRandomNotRegisteredCordaProvider.algorithm)
 
         // Now register CordaSecurityProvider as last Provider.
         Security.addProvider(CordaSecurityProvider())
         val secureRandomRegisteredLastCordaProvider = SecureRandom()
-        assertNotEquals(PlatformSecureRandomService.algorithm, secureRandomRegisteredLastCordaProvider.algorithm)
+        assertNotEquals(PlatformSecureRandomService.ALGORITHM, secureRandomRegisteredLastCordaProvider.algorithm)
 
         // Remove Corda Provider again and add it as the first Provider entry.
         Security.removeProvider(CordaSecurityProvider.PROVIDER_NAME)
         Security.insertProviderAt(CordaSecurityProvider(), 1) // This is base-1.
         val secureRandomRegisteredFirstCordaProvider = SecureRandom()
-        assertEquals(PlatformSecureRandomService.algorithm, secureRandomRegisteredFirstCordaProvider.algorithm)
+        assertEquals(PlatformSecureRandomService.ALGORITHM, secureRandomRegisteredFirstCordaProvider.algorithm)
     }
 }