From e8a35d6a326765bbdaeb565936ee2c4a8ecc01d1 Mon Sep 17 00:00:00 2001 From: Razvan Codreanu <52859362+Schife@users.noreply.github.com> Date: Tue, 24 Sep 2019 11:20:04 +0100 Subject: [PATCH] TM-32 backporting detekt config changes to OS 4.1 and rebaselining (#5507) --- detekt-baseline.xml | 5118 ------------------------------------------- detekt-config.yml | 12 +- 2 files changed, 6 insertions(+), 5124 deletions(-) diff --git a/detekt-baseline.xml b/detekt-baseline.xml index f7489fd381..311b33dc42 100644 --- a/detekt-baseline.xml +++ b/detekt-baseline.xml @@ -88,8 +88,6 @@ ComplexMethod:AMQPBridgeTest.kt$AMQPBridgeTest$@Test fun `test acked and nacked messages`() ComplexMethod:AMQPChannelHandler.kt$AMQPChannelHandler$override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) ComplexMethod:AMQPTypeIdentifierParser.kt$AMQPTypeIdentifierParser$// Make sure our inputs aren't designed to blow things up. private fun validate(typeString: String) - ComplexMethod:AMQPTypeIdentifierParser.kt$AMQPTypeIdentifierParser.ParseState.ParsingRawType$override fun accept(c: Char) - ComplexMethod:AMQPTypeIdentifiers.kt$AMQPTypeIdentifiers$fun nameForType(typeIdentifier: TypeIdentifier): String ComplexMethod:ANSIProgressRenderer.kt$ANSIProgressRenderer$// Returns number of lines rendered. private fun renderLevel(ansi: Ansi, error: Boolean): Int ComplexMethod:ANSIProgressRenderer.kt$ANSIProgressRenderer$@Synchronized protected fun draw(moveUp: Boolean, error: Throwable? = null) ComplexMethod:AbstractNode.kt$AbstractNode$private fun installCordaServices() @@ -105,8 +103,6 @@ ComplexMethod:CashSelectionPostgreSQLImpl.kt$CashSelectionPostgreSQLImpl$// This is using PostgreSQL window functions for selecting a minimum set of rows that match a request amount of coins: // 1) This may also be possible with user-defined functions (e.g. using PL/pgSQL) // 2) The window function accumulated column (`total`) does not include the current row (starts from 0) and cannot // appear in the WHERE clause, hence restricting row selection and adjusting the returned total in the outer query. // 3) Currently (version 9.6), FOR UPDATE cannot be specified with window functions override fun executeQuery(connection: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, withResultSet: (ResultSet) -> Boolean): Boolean ComplexMethod:ClassCarpenter.kt$ClassCarpenterImpl$ private fun validateSchema(schema: Schema) ComplexMethod:ClassModule.kt$ClassModule$ fun getTypes(abbreviatedSignature: String): List<String> - ComplexMethod:ClassModule.kt$ClassModule$ fun normalizeClassName(name: String): String - ComplexMethod:CommandBase.kt$CommandBase$protected fun printException(exception: Throwable) ComplexMethod:CommandBase.kt$CommandBase$protected fun printMessages(messages: MessageCollection, origins: Map<String, Set<EntityReference>> = emptyMap()) ComplexMethod:CommandBase.kt$CommandBase$protected fun whitelistFromPath(whitelist: Path?): Whitelist ComplexMethod:CompatibleTransactionTests.kt$CompatibleTransactionTests$@Test fun `Command visibility tests`() @@ -124,7 +120,6 @@ ComplexMethod:CordaCliWrapper.kt$fun CordaCliWrapper.start(args: Array<String>) ComplexMethod:CordaPersistence.kt$CordaPersistence$private fun <T> inTopLevelTransaction(isolationLevel: TransactionIsolationLevel, recoverableFailureTolerance: Int, recoverAnyNestedSQLException: Boolean, statement: DatabaseTransaction.() -> T): T ComplexMethod:CordaRPCClient.kt$CordaRPCClientConfiguration$override fun equals(other: Any?): Boolean - ComplexMethod:DJVM.kt$@Throws(ClassNotFoundException::class) fun Any.sandbox(): Any ComplexMethod:DeserializationInput.kt$DeserializationInput$internal fun readObject(obj: Any, schemas: SerializationSchemas, type: Type, context: SerializationContext): Any ComplexMethod:DriverDSLImpl.kt$DriverDSLImpl$override fun start() ComplexMethod:DriverDSLImpl.kt$DriverDSLImpl$private fun startNodeInternal(config: NodeConfig, webAddress: NetworkHostAndPort, localNetworkMap: LocalNetworkMap?, parameters: NodeParameters): CordaFuture<NodeHandle> @@ -160,7 +155,6 @@ ComplexMethod:MappedList.kt$MappedList$override fun sourceChanged(change: ListChangeListener.Change<out A>) ComplexMethod:MemberModule.kt$MemberModule$ fun numberOfArguments(signature: String): Int ComplexMethod:MerkleTransaction.kt$FilteredTransaction.Companion$ private fun filterWithFun(wtx: WireTransaction, filtering: Predicate<Any>): List<FilteredComponentGroup> - ComplexMethod:MigrationNamedCacheFactory.kt$MigrationNamedCacheFactory$private fun <K, V> configuredForNamed(caffeine: Caffeine<K, V>, name: String): Caffeine<K, V> ComplexMethod:NetworkBootstrapper.kt$NetworkBootstrapper$private fun bootstrap( directory: Path, cordappJars: List<Path>, copyCordapps: CopyCordapps, fromCordform: Boolean, networkParametersOverrides: NetworkParametersOverrides = NetworkParametersOverrides() ) ComplexMethod:NetworkBootstrapper.kt$NetworkBootstrapper$private fun createNodeDirectoriesIfNeeded(directory: Path, fromCordform: Boolean): Boolean ComplexMethod:NetworkMapUpdater.kt$NetworkMapUpdater$fun updateNetworkMapCache(): Duration @@ -174,9 +168,6 @@ ComplexMethod:NodeVaultService.kt$NodeVaultService$private fun makeUpdates(batch: Iterable<CoreTransaction>, statesToRecord: StatesToRecord): List<Vault.Update<ContractState>> ComplexMethod:ObjectDiffer.kt$ObjectDiffer$fun diff(a: Any?, b: Any?): DiffTree? ComplexMethod:Obligation.kt$Obligation$override fun verify(tx: LedgerTransaction) - ComplexMethod:PrettyPrint.kt$PrettyPrint$fun prettyPrint(arr: Arrangement) - ComplexMethod:PrettyPrint.kt$PrettyPrint$fun prettyPrintBigDecimal(per: Perceivable<BigDecimal>) - ComplexMethod:PrettyPrint.kt$PrettyPrint$fun prettyPrintBoolean(per: Perceivable<Boolean>) ComplexMethod:QuasarInstrumentationHook.kt$QuasarInstrumentationHookAgent.Companion$@JvmStatic fun premain(argumentsString: String?, instrumentation: Instrumentation) ComplexMethod:RPCClientProxyHandler.kt$RPCClientProxyHandler$// The handler for Artemis messages. private fun artemisMessageHandler(message: ClientMessage) ComplexMethod:RPCClientProxyHandler.kt$RPCClientProxyHandler$// This is the general function that transforms a client side RPC to internal Artemis messages. override fun invoke(proxy: Any, method: Method, arguments: Array<out Any?>?): Any? @@ -200,27 +191,18 @@ ComplexMethod:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$override fun retryFlowFromSafePoint(currentState: StateMachineState) ComplexMethod:SourceLocation.kt$SourceLocation$ fun format(): String ComplexMethod:StartedFlowTransition.kt$StartedFlowTransition$override fun transition(): TransitionResult - ComplexMethod:StartedFlowTransition.kt$StartedFlowTransition$private fun collectRelevantErrorsToThrow(flowIORequest: FlowIORequest<*>, checkpoint: Checkpoint): List<Throwable> ComplexMethod:StatusTransitions.kt$StatusTransitions$ fun verify(tx: LedgerTransaction) ComplexMethod:StringToMethodCallParser.kt$StringToMethodCallParser$ @Throws(UnparseableCallException::class) fun parse(target: T?, command: String): ParsedMethodCall - ComplexMethod:SwapData.kt$SwapData$private fun getSwapConvention(name: String): FixedIborSwapConvention ComplexMethod:TestBase.kt$TestBase$ fun sandbox( vararg options: Any, pinnedClasses: Set<java.lang.Class<*>> = emptySet(), minimumSeverityLevel: Severity = Severity.WARNING, enableTracing: Boolean = true, action: SandboxRuntimeContext.() -> Unit ) - ComplexMethod:TopLevelTransition.kt$TopLevelTransition$override fun transition(): TransitionResult ComplexMethod:TraceAllocations.kt$TraceAllocations$override fun emit(context: EmitterContext, instruction: Instruction) ComplexMethod:TransactionBuilder.kt$TransactionBuilder$ fun withItems(vararg items: Any) ComplexMethod:TransactionBuilder.kt$TransactionBuilder$ private fun addMissingDependency(services: ServicesForResolution, wireTx: WireTransaction): Boolean - ComplexMethod:TransactionBuilder.kt$TransactionBuilder$ private fun attachmentConstraintsTransition(constraints: Set<AttachmentConstraint>, attachmentToUse: ContractAttachment): AttachmentConstraint ComplexMethod:TransactionBuilder.kt$TransactionBuilder$ private fun handleContract( contractClassName: ContractClassName, inputStates: List<TransactionState<ContractState>>?, inputStateRefs: Set<StateRef>?, outputStates: List<TransactionState<ContractState>>?, explicitContractAttachment: AttachmentId?, services: ServicesForResolution ): Pair<AttachmentId, List<TransactionState<ContractState>>?> ComplexMethod:TransactionUtils.kt$ fun createComponentGroups(inputs: List<StateRef>, outputs: List<TransactionState<ContractState>>, commands: List<Command<*>>, attachments: List<SecureHash>, notary: Party?, timeWindow: TimeWindow?, references: List<StateRef>, networkParametersHash: SecureHash?): List<ComponentGroup> - ComplexMethod:TypeIdentifier.kt$TypeIdentifier.Companion$ fun forGenericType(type: Type, resolutionContext: Type = type): TypeIdentifier ComplexMethod:TypeModellingFingerPrinter.kt$FingerPrintingState$// For a type we haven't seen before, determine the correct path depending on the type of type it is. private fun fingerprintNewType(type: LocalTypeInformation) - ComplexMethod:UniversalContract.kt$UniversalContract$fun <T> replaceStartEnd(p: Perceivable<T>, start: Instant, end: Instant): Perceivable<T> - ComplexMethod:UniversalContract.kt$UniversalContract$fun evalBigDecimal(tx: LedgerTransaction, expr: Perceivable<BigDecimal>): BigDecimal - ComplexMethod:UniversalContract.kt$UniversalContract$fun evalBoolean(tx: LedgerTransaction, expr: Perceivable<Boolean>): Boolean ComplexMethod:UniversalContract.kt$UniversalContract$override fun verify(tx: LedgerTransaction) ComplexMethod:Util.kt$fun <T> debugCompare(perLeft: Perceivable<T>, perRight: Perceivable<T>) ComplexMethod:Util.kt$fun debugCompare(arrLeft: Arrangement, arrRight: Arrangement) - ComplexMethod:Util.kt$fun replaceParty(arrangement: Arrangement, from: Party, to: Party): Arrangement ComplexMethod:WebServer.kt$fun main(args: Array<String>) EmptyCatchBlock:ClockUtilsTest.kt$ClockUtilsTest${ } EmptyCatchBlock:NodeTerminalView.kt$NodeTerminalView${} @@ -241,55 +223,6 @@ EmptyDefaultConstructor:FlowRetryTest.kt$RetryFlow$() EmptyDefaultConstructor:FlowRetryTest.kt$ThrowingFlow$() EmptyElseBlock:CordaCliWrapper.kt${ } - EmptyFunctionBlock:AMQPPrimitiveSerializer.kt$AMQPPrimitiveSerializer${ } - EmptyFunctionBlock:AbstractNode.kt$FlowStarterImpl.<no name provided>${} - EmptyFunctionBlock:AttachmentVersionNumberMigration.kt$AttachmentVersionNumberMigration${ } - EmptyFunctionBlock:AzureContainerPusher.kt$AzureContainerPusher.<no name provided>${ } - EmptyFunctionBlock:BFTSmartNotaryService.kt$BFTSmartNotaryService${ } - EmptyFunctionBlock:ClassAndMemberVisitorTest.kt$ClassAndMemberVisitorTest.TestClassWithMemberAnnotations${ } - EmptyFunctionBlock:ClassMutatorTest.kt$ClassMutatorTest.TestClassWithMembers${} - EmptyFunctionBlock:ClientRPCInfrastructureTests.kt$ClientRPCInfrastructureTests.TestOpsImpl${} - EmptyFunctionBlock:CommsContracts.kt$CommsTestContract${ } - EmptyFunctionBlock:ComposableTypePropertySerializer.kt$AMQPCharPropertyWriteStategy${} - EmptyFunctionBlock:ComposableTypePropertySerializer.kt$AMQPPropertyWriteStrategy${} - EmptyFunctionBlock:ConnectionManager.kt$<no name provided>.<no name provided>${} - EmptyFunctionBlock:ContractUpgradeFlowTest.kt$ContractUpgradeFlowTest.CashV2${} - EmptyFunctionBlock:CorDappCustomSerializer.kt$CorDappCustomSerializer${} - EmptyFunctionBlock:CordaClassResolverTests.kt$CustomSerializable${ } - EmptyFunctionBlock:CordaClassResolverTests.kt$DefaultSerializableSerializer${ } - EmptyFunctionBlock:CordaMigration.kt$CordaMigration${ } - EmptyFunctionBlock:CordaPersistence.kt$NoOpSubscriber${} - EmptyFunctionBlock:CustomSerializer.kt$CustomSerializer.CustomSerializerImp${} - EmptyFunctionBlock:DBCheckpointStorageTests.kt$DBCheckpointStorageTests.<no name provided>${} - EmptyFunctionBlock:DummyDealContract.kt$DummyDealContract${} - EmptyFunctionBlock:DummyStates.kt$DoNothingContract${} - EmptyFunctionBlock:EmitterModuleTest.kt$EmitterModuleTest.TestClass${} - EmptyFunctionBlock:Empty.kt$Empty${} - EmptyFunctionBlock:InMemoryTransactionVerifierService.kt$InMemoryTransactionVerifierService${} - EmptyFunctionBlock:IrsDemoWebApplicationTests.kt$IrsDemoWebApplicationTests${ } - EmptyFunctionBlock:LaunchSpaceshipFlow.kt$LaunchSpaceshipFlow${ } - EmptyFunctionBlock:LaunchSpaceshipFlow.kt$LaunchSpaceshipFlowCorrect${ } - EmptyFunctionBlock:LocalTypeModelTests.kt$LocalTypeModelTests.<no name provided>${} - EmptyFunctionBlock:MyCustomNotaryService.kt$MyCustomValidatingNotaryService${} - EmptyFunctionBlock:NodePerformanceTests.kt$NodePerformanceTests.EmptyFlow${ } - EmptyFunctionBlock:NotaryTestContracts.kt$NotaryTestContract${ } - EmptyFunctionBlock:ObjectBuilder.kt$ConstructorBasedObjectBuilder${} - EmptyFunctionBlock:SerializationOutputTests.kt$SerializationOutputTests.<no name provided>${ } - EmptyFunctionBlock:SerializationOutputTests.kt$SerializationOutputTests.FooContract${ } - EmptyFunctionBlock:SimpleNotaryService.kt$SimpleNotaryService${} - EmptyFunctionBlock:StepsProviderTests.kt$StepsProviderTests.DummyStepsBlock${ } - EmptyFunctionBlock:TestObservableContext.kt$TestObservableContext${ } - EmptyFunctionBlock:TimedFlowTests.kt$TimedFlowTests.TestNotaryService${} - EmptyFunctionBlock:TransactionSerializationTests.kt$TransactionSerializationTests.TestCash${ } - EmptyFunctionBlock:TransitionExecutorImpl.kt$TransitionExecutorImpl${} - EmptyFunctionBlock:UniqueDummyFungibleContract.kt$UniqueDummyFungibleContract${} - EmptyFunctionBlock:UniqueDummyLinearContract.kt$UniqueDummyLinearContract${} - EmptyFunctionBlock:UniquenessProviderTests.kt$UniquenessProviderFactory${} - EmptyFunctionBlock:Utils.kt$<no name provided>${} - EmptyFunctionBlock:VaultQueryTests.kt$VaultQueryTestsBase.MyContractClass${} - EmptyFunctionBlock:VaultSoftLockManagerTest.kt$VaultSoftLockManagerTest.ContractImpl${} - EmptyFunctionBlock:VaultUpdateTests.kt$VaultUpdateTests.DummyContract${ } - EmptyFunctionBlock:WebServerPluginRegistry.kt$WebServerPluginRegistry${} EmptyKtFile:KryoHook.kt$.KryoHook.kt EmptyKtFile:ValidatingNotaryService.kt$.ValidatingNotaryService.kt EnumNaming:LoginView.kt$LoginView.LoginStatus$exception @@ -846,1038 +779,10 @@ LargeClass:WireTransaction.kt$WireTransaction : TraversableTransaction LargeClass:X509Utilities.kt$X509Utilities LargeClass:X509UtilitiesTest.kt$X509UtilitiesTest - LongMethod:AMQPBridgeManager.kt$AMQPBridgeManager.AMQPBridge$private fun clientArtemisMessageHandler(artemisMessage: ClientMessage) - LongMethod:AMQPBridgeManager.kt$AMQPBridgeManager.AMQPBridge$private fun onSocketConnected(connected: Boolean) - LongMethod:AMQPBridgeTest.kt$AMQPBridgeTest$@Test fun `test acked and nacked messages`() - LongMethod:AMQPBridgeTest.kt$AMQPBridgeTest$private fun createAMQPServer(maxMessageSize: Int = MAX_MESSAGE_SIZE): AMQPServer - LongMethod:AMQPBridgeTest.kt$AMQPBridgeTest$private fun createArtemis(sourceQueueName: String?, crlCheckSoftFail: Boolean = true): Triple<ArtemisMessagingServer, ArtemisMessagingClient, BridgeManager> - LongMethod:AMQPChannelHandler.kt$AMQPChannelHandler$override fun userEventTriggered(ctx: ChannelHandlerContext, evt: Any) - LongMethod:AMQPChannelHandler.kt$AMQPChannelHandler$override fun write(ctx: ChannelHandlerContext, msg: Any, promise: ChannelPromise) - LongMethod:AMQPClient.kt$AMQPClient.ClientChannelInitializer$override fun initChannel(ch: SocketChannel) - LongMethod:AMQPExceptionsTests.kt$AMQPExceptionsTests$// However, if its a shiny new AMQPNotSerializable one, we have cool new toys, so // lets make sure those are set @Test fun catchAMQPNotSerializable() - LongMethod:AMQPRemoteTypeModel.kt$AMQPRemoteTypeModel$ fun interpret(serializationSchemas: SerializationSchemas): Map<TypeDescriptor, RemoteTypeInformation> - LongMethod:AMQPRemoteTypeModelTests.kt$AMQPRemoteTypeModelTests$@Test fun `round-trip some types through AMQP serialisations`() - LongMethod:AMQPSerializationScheme.kt$AbstractAMQPSerializationScheme$private fun registerCustomSerializers(context: SerializationContext, factory: SerializerFactory) - LongMethod:AMQPServer.kt$AMQPServer.ServerChannelInitializer$override fun initChannel(ch: SocketChannel) - LongMethod:AMQPTypeIdentifierParser.kt$AMQPTypeIdentifierParser$// Make sure our inputs aren't designed to blow things up. private fun validate(typeString: String) - LongMethod:ANSIProgressRenderer.kt$ANSIProgressRenderer$// Create a new tree of steps that also holds a reference to the parent of each step. This is required to uniquely identify each step // (assuming that each step label is unique at a given level). private fun transformTree(inputTree: List<InputTreeStep>): List<ProgressStep> - LongMethod:ANSIProgressRenderer.kt$ANSIProgressRenderer$// Returns number of lines rendered. private fun renderLevel(ansi: Ansi, error: Boolean): Int - LongMethod:ANSIProgressRenderer.kt$ANSIProgressRenderer$fun printingBody() - LongMethod:ANSIProgressRenderer.kt$ANSIProgressRenderer$private fun renderInternal(flowProgressHandle: FlowProgressHandle<*>?) - LongMethod:ANSIProgressRenderer.kt$StdoutANSIProgressRenderer$override fun setup() - LongMethod:AbstractAMQPSerializationSchemeTest.kt$AbstractAMQPSerializationSchemeTest$@Test fun `number of cached factories must be bounded by maxFactories`() - LongMethod:AbstractCashSelection.kt$AbstractCashSelection$ @Suspendable fun unconsumedCashStatesForSpending(services: ServiceHub, amount: Amount<Currency>, onlyFromIssuerParties: Set<AbstractParty> = emptySet(), notary: Party? = null, lockId: UUID, withIssuerRefs: Set<OpaqueBytes> = emptySet()): List<StateAndRef<Cash.State>> - LongMethod:AbstractCashSelection.kt$AbstractCashSelection$private fun attemptSpend(services: ServiceHub, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, stateAndRefs: MutableList<StateAndRef<Cash.State>>): Boolean - LongMethod:AbstractNode.kt$AbstractNode$ private fun loadNotaryClusterIdentity(serviceLegalName: CordaX500Name): Pair<PartyAndCertificate, KeyPair> - LongMethod:AbstractNode.kt$AbstractNode$ private fun obtainIdentity(): Pair<PartyAndCertificate, KeyPair> - LongMethod:AbstractNode.kt$AbstractNode$fun <T : SerializeAsToken> installCordaService(serviceClass: Class<T>): T - LongMethod:AbstractNode.kt$AbstractNode$open fun start(): S - LongMethod:AbstractNode.kt$AbstractNode$private fun createAndStoreLegalIdentity(alias: String): PartyAndCertificate - LongMethod:AbstractNode.kt$AbstractNode$private fun installCordaServices() - LongMethod:AbstractNode.kt$AbstractNode$private fun makeCordappLoader(configuration: NodeConfiguration, versionInfo: VersionInfo): CordappLoader - LongMethod:AbstractNode.kt$AbstractNode$private fun updateNodeInfo(identity: PartyAndCertificate, identityKeyPair: KeyPair, publish: Boolean): Triple<MutableSet<KeyPair>, NodeInfoAndSigned, PartyAndCertificate?> - LongMethod:AbstractNode.kt$AbstractNode$private fun validateKeyStores(): X509Certificate - LongMethod:AbstractRPCTest.kt$AbstractRPCTest$inline fun <reified I : RPCOps> RPCDriverDSL.testProxy( ops: I, rpcUser: User = rpcTestUser, clientConfiguration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT, serverConfiguration: RPCServerConfiguration = RPCServerConfiguration.DEFAULT, queueDrainTimeout: Duration = 5.seconds ): TestProxy<I> - LongMethod:ActionExecutorImpl.kt$ActionExecutorImpl$@Suspendable override fun executeAction(fiber: FlowFiber, action: Action) - LongMethod:AdditionP2PAddressModeTest.kt$AdditionP2PAddressModeTest$@Test fun `runs nodes with one configured to use additionalP2PAddresses`() - LongMethod:AdvancedExceptionDialog.kt$//Attach a stacktrace for the exception that was used in the initialization of the dialog. fun AdvancedExceptionDialog.withStacktrace() : AdvancedExceptionDialog - LongMethod:AffinityExecutorTests.kt$AffinityExecutorTests$@Test fun `pooled executor`() - LongMethod:AffinityExecutorTests.kt$AffinityExecutorTests$@Test fun `single threaded affinity executor runs on correct thread`() - LongMethod:AggregatedList.kt$AggregatedList$override fun sourceChanged(c: ListChangeListener.Change<out E>) - LongMethod:AggregatedList.kt$AggregatedList$private fun addItem(addedItem: E): Int? - LongMethod:AggregatedList.kt$AggregatedList$private fun removeItem(removedItem: E): Pair<Int, AggregationGroup<E, A>>? - LongMethod:AggregatedListTest.kt$AggregatedListTest$@Test fun removeWorks() - LongMethod:AlwaysUseExactMath.kt$AlwaysUseExactMath$override fun emit(context: EmitterContext, instruction: Instruction) - LongMethod:Amount.kt$Amount.Companion$ @JvmStatic fun parseCurrency(input: String): Amount<Currency> - LongMethod:Amount.kt$AmountTransfer$ fun apply(balances: List<SourceAndAmount<T, P>>, newRef: Any? = null): List<SourceAndAmount<T, P>> - LongMethod:AmountTests.kt$AmountTests$@Test fun `amount transfer aggregation`() - LongMethod:AmountTests.kt$AmountTests$@Test fun `amount transfer apply`() - LongMethod:AmountTests.kt$AmountTests$@Test fun `amount transfers equality`() - LongMethod:AnalysisConfiguration.kt$AnalysisConfiguration.Companion$ fun createRoot( whitelist: Whitelist = Whitelist.MINIMAL, additionalPinnedClasses: Set<String> = emptySet(), minimumSeverityLevel: Severity = Severity.WARNING, analyzeAnnotations: Boolean = false, prefixFilters: List<String> = emptyList(), classModule: ClassModule = ClassModule(), memberModule: MemberModule = MemberModule(), bootstrapClassLoader: BootstrapClassLoader? = null, sourceClassLoaderFactory: (ClassResolver, BootstrapClassLoader?) -> SourceClassLoader = { classResolver, bootstrapCL -> SourceClassLoader(emptyList(), classResolver, bootstrapCL) } ): AnalysisConfiguration - LongMethod:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase$private fun set(key: K, value: V, logWarning: Boolean, store: (K, V) -> V?): Boolean - LongMethod:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase.Transactional.InFlight$fun alsoWrite(_value: T) - LongMethod:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest$@Test fun `concurrent test purge between A and B`() - LongMethod:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest$@Test fun `test no purge with only a single transaction`() - LongMethod:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest$@Test fun `test purge mid-way in a single transaction`() - LongMethod:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest.TestThread$private fun doActivity() - LongMethod:ArtemisMessagingServer.kt$ArtemisMessagingServer$// TODO: Maybe wrap [IOException] on a key store load error so that it's clearly splitting key store loading from // Artemis IO errors @Throws(IOException::class, AddressBindingException::class, KeyStoreException::class) private fun configureAndStartServer() - LongMethod:ArtemisMessagingTest.kt$ArtemisMessagingTest$@Before fun setUp() - LongMethod:ArtemisRpcTests.kt$ArtemisRpcTests$private fun testSslCommunication(nodeSSlconfig: MutualSslConfiguration, brokerSslOptions: BrokerRpcSslOptions?, useSslForBroker: Boolean, clientSslOptions: ClientRpcSslOptions?, address: NetworkHostAndPort = ports.nextHostAndPort(), adminAddress: NetworkHostAndPort = ports.nextHostAndPort(), baseDirectory: Path = tempFolder.root.toPath() ) - LongMethod:AttachmentDemo.kt$@Suppress("DEPRECATION") // DOCSTART 1 fun recipient(rpc: CordaRPCOps, webPort: Int) - LongMethod:AttachmentDemo.kt$fun main(args: Array<String>) - LongMethod:AttachmentDemoTest.kt$AttachmentDemoTest$// run with a 10,000,000 bytes in-memory zip file. In practice, a slightly bigger file will be used (~10,002,000 bytes). @Test fun `attachment demo using a 10MB zip file`() - LongMethod:AttachmentDownloadServlet.kt$AttachmentDownloadServlet$@Throws(IOException::class) override fun doGet(req: HttpServletRequest, resp: HttpServletResponse) - LongMethod:AttachmentVersionNumberMigration.kt$AttachmentVersionNumberMigration$override fun execute(database: Database?) - LongMethod:AttachmentsClassLoader.kt$AttachmentsClassLoader$private fun checkAttachments(attachments: List<Attachment>) - LongMethod:AttachmentsClassLoader.kt$AttachmentsClassLoader.Companion$ private fun setOrDecorateURLStreamHandlerFactory() - LongMethod:AttachmentsClassLoaderSerializationTests.kt$AttachmentsClassLoaderSerializationTests$@Test fun `Can serialize and deserialize with an attachment classloader`() - LongMethod:AuthDBTests.kt$AuthDBTests$@Before override fun setUp() - LongMethod:AzureBackend.kt$AzureBackend.Companion$fun fromContext(context: Context): AzureBackend - LongMethod:AzureInstantiator.kt$AzureInstantiator$override fun instantiateContainer(imageId: String, portsToOpen: List<Int>, instanceName: String, env: Map<String, String>?): CompletableFuture<Pair<String, Map<Int, Int>>> - LongMethod:BCCryptoServiceTests.kt$BCCryptoServiceTests$private fun generateKeyAndSignForScheme(cryptoService: BCCryptoService, signatureScheme: SignatureScheme) - LongMethod:BFTNotaryServiceTests.kt$BFTNotaryServiceTests$@Test fun `detect double spend`() - LongMethod:BFTNotaryServiceTests.kt$BFTNotaryServiceTests$@Test fun `transactions can be re-notarised outside their time window`() - LongMethod:BFTNotaryServiceTests.kt$BFTNotaryServiceTests$@Test fun `transactions outside their time window are rejected`() - LongMethod:BFTNotaryServiceTests.kt$BFTNotaryServiceTests.Companion$fun startBftClusterAndNode(clusterSize: Int, mockNet: InternalMockNetwork, exposeRaces: Boolean = false): Pair<Party, TestStartedNode> - LongMethod:BFTSmart.kt$BFTSmart.Replica$protected fun commitInputStates( states: List<StateRef>, txId: SecureHash, callerName: CordaX500Name, requestSignature: NotarisationRequestSignature, timeWindow: TimeWindow?, references: List<StateRef> = emptyList() ) - LongMethod:BFTSmartNotaryService.kt$BFTSmartNotaryService$private fun createMap(): AppendOnlyPersistentMap<StateRef, SecureHash, CommittedState, PersistentStateRef> - LongMethod:BankOfCordaClientApi.kt$BankOfCordaClientApi$// DOCSTART rpcClientConnectionWithRetry private fun establishConnectionWithRetry(nodeHostAndPorts: List<NetworkHostAndPort>, username: String, password: String): CordaRPCConnection - LongMethod:BankOfCordaWebApi.kt$BankOfCordaWebApi$ @POST @Path("issue-asset-request") @Consumes(MediaType.APPLICATION_JSON) fun issueAssetRequest(params: IssueRequestParams): Response - LongMethod:Base58Test.kt$Base58Test$@Test fun testDecode() - LongMethod:BlobInspector.kt$BlobInspector$fun run(out: PrintStream): Int - LongMethod:BootstrapperView.kt$BootstrapperView$private fun processSelectedDirectory(dir: File) - LongMethod:BridgeControlListener.kt$BridgeControlListener$fun start() - LongMethod:BridgeControlListener.kt$BridgeControlListener$private fun processControlMessage(msg: ClientMessage) - LongMethod:BrokerJaasLoginModule.kt$BrokerJaasLoginModule$// The Main authentication logic, responsible for running all the configured checks for each user type // and return the actual User and principals private fun authenticateAndAuthorise(username: String, certificates: Array<X509Certificate>?, password: String): Pair<String, List<RolePrincipal>> - LongMethod:BrokerJaasLoginModule.kt$BrokerJaasLoginModule$override fun login(): Boolean - LongMethod:BusinessCalendar.kt$BusinessCalendar.Companion$ @JvmStatic fun createGenericSchedule(startDate: LocalDate, period: Frequency, calendar: BusinessCalendar = EMPTY, dateRollConvention: DateRollConvention = DateRollConvention.Following, noOfAdditionalPeriods: Int = Integer.MAX_VALUE, endDate: LocalDate? = null, periodOffset: Int? = null): List<LocalDate> - LongMethod:Cap.kt$Cap$@Test fun `first fixing`() - LongMethod:Cap.kt$Cap$@Test fun `second fixing`() - LongMethod:Caplet.kt$Caplet$@Test fun fixing() - LongMethod:Cash.kt$Cash$override fun verify(tx: LedgerTransaction) - LongMethod:CashExitFlow.kt$CashExitFlow$ @Suspendable @Throws(CashException::class) override fun call(): AbstractCashFlow.Result - LongMethod:CashPaymentFlow.kt$CashPaymentFlow$@Suspendable override fun call(): AbstractCashFlow.Result - LongMethod:CashPaymentFlowTests.kt$CashPaymentFlowTests$@Test fun `pay some cash`() - LongMethod:CashSelectionH2Impl.kt$CashSelectionH2Impl$// We are using an H2 specific means of selecting a minimum set of rows that match a request amount of coins: // 1) There is no standard SQL mechanism of calculating a cumulative total on a field and restricting row selection on the // running total of such an accumulator // 2) H2 uses session variables to perform this accumulator function: // http://www.h2database.com/html/functions.html#set // 3) H2 does not support JOIN's in FOR UPDATE (hence we are forced to execute 2 queries) override fun executeQuery(connection: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, withResultSet: (ResultSet) -> Boolean): Boolean - LongMethod:CashSelectionPostgreSQLImpl.kt$CashSelectionPostgreSQLImpl$// This is using PostgreSQL window functions for selecting a minimum set of rows that match a request amount of coins: // 1) This may also be possible with user-defined functions (e.g. using PL/pgSQL) // 2) The window function accumulated column (`total`) does not include the current row (starts from 0) and cannot // appear in the WHERE clause, hence restricting row selection and adjusting the returned total in the outer query. // 3) Currently (version 9.6), FOR UPDATE cannot be specified with window functions override fun executeQuery(connection: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, withResultSet: (ResultSet) -> Boolean): Boolean - LongMethod:CashSelectionSQLServerImpl.kt$CashSelectionSQLServerImpl$// This is one MSSQL implementation of the query to select just enough cash states to meet the desired amount. // We select the cash states with smaller amounts first so that as the result, we minimize the numbers of // unspent cash states remaining in the vault. // // If there is not enough cash, the query will return an empty resultset, which should signal to the caller // of an exception, since the desired amount is assumed to always > 0. // NOTE: The other two implementations, H2 and PostgresSQL, behave differently in this case - they return // all in the vault instead of nothing. That seems to give the caller an extra burden to verify total returned // >= amount. // In addition, extra data fetched results in unnecessary I/O. // Nevertheless, if so desired, we can achieve the same by changing the last FROM clause to // FROM CTE LEFT JOIN Boundary AS B ON 1 = 1 // WHERE B.seqNo IS NULL OR CTE.seqNo <= B.seqNo // // Common Table Expression and Windowed functions help make the query more readable. // Query plan does index scan on pennies_idx, which may be unavoidable due to the nature of the query. override fun executeQuery(connection: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, withResultSet: (ResultSet) -> Boolean): Boolean - LongMethod:CashSelectionTest.kt$CashSelectionTest$@Test fun `cash selection sees states added in the same transaction`() - LongMethod:CashSelectionTest.kt$CashSelectionTest$@Test fun `don't return extra coins if the selected amount has been reached`() - LongMethod:CashSelectionTest.kt$CashSelectionTest$@Test fun `select cash states issued by single transaction and give change`() - LongMethod:CashSteps.kt$CashSteps$override fun initialize(state: ScenarioState) - LongMethod:CashTests.kt$CashTests$// Double spend. @Test fun chainCashDoubleSpendFailsWith() - LongMethod:CashTests.kt$CashTests$// TODO: Optimise this so that we don't throw away and rebuild state that can be shared across tests. @Before fun setUp() - LongMethod:CashTests.kt$CashTests$@Test fun `extended issue examples`() - LongMethod:CashTests.kt$CashTests$@Test fun exitLedger() - LongMethod:CashTests.kt$CashTests$@Test fun generateSimpleSpendWithChange() - LongMethod:CashTests.kt$CashTests$@Test fun generateSpendMixedDeposits() - LongMethod:CashTests.kt$CashTests$@Test fun generateSpendTwiceWithinATransaction() - LongMethod:CashTests.kt$CashTests$@Test fun multiIssuer() - LongMethod:CashTests.kt$CashTests$@Test fun multiSpend() - LongMethod:CashTests.kt$CashTests$@Test fun testMergeSplit() - LongMethod:CashTests.kt$CashTests$@Test fun trivial() - LongMethod:CashTests.kt$CashTests$@Test fun trivialMismatches() - LongMethod:CashUtils.kt$CashUtils$ @JvmStatic @Throws(InsufficientBalanceException::class) @Suspendable fun generateSpend(services: ServiceHub, tx: TransactionBuilder, payments: List<PartyAndAmount<Currency>>, ourIdentity: PartyAndCertificate, onlyFromParties: Set<AbstractParty> = emptySet()): Pair<TransactionBuilder, List<PublicKey>> - LongMethod:CertRoleTests.kt$CertRoleTests$@Test fun `check cert roles verify for various cert hierarchies`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `AMPQ Client to Server connection fails when client's certificate is revoked and soft fail is disabled`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `AMPQ Client to Server connection fails when client's certificate is revoked and soft fail is enabled`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `AMPQ Client to Server connection fails when servers's certificate is revoked and soft fail is enabled`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `AMPQ Client to Server connection fails when servers's certificate is revoked`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `AMPQ Client to Server connection succeeds when CRL cannot be obtained and soft fail is enabled`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `AMPQ Client to Server connection succeeds when CRL retrieval is forbidden and soft fail is enabled`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `Revocation status chceck fails when the CRL distribution point is not set and soft fail is disabled`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `Revocation status chceck succeds when the CRL distribution point is not set and soft fail is enabled`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `Simple AMPQ Client to Server connection works and soft fail is disabled`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `Simple AMPQ Client to Server connection works and soft fail is enabled`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$@Test fun `verify CRL algorithms`() - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$private fun Pair<CertificateStoreSupplier, MutualSslConfiguration>.recreateNodeCaAndTlsCertificates(nodeCaCrlDistPoint: String, tlsCrlDistPoint: String?): X509Certificate - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$private fun createClient(targetPort: Int, crlCheckSoftFail: Boolean, nodeCrlDistPoint: String = "http://${server.hostAndPort}/crl/node.crl", tlsCrlDistPoint: String? = "http://${server.hostAndPort}/crl/empty.crl", maxMessageSize: Int = MAX_MESSAGE_SIZE): Pair<AMQPClient, X509Certificate> - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$private fun createServer(port: Int, name: CordaX500Name = ALICE_NAME, crlCheckSoftFail: Boolean, nodeCrlDistPoint: String = "http://${server.hostAndPort}/crl/node.crl", tlsCrlDistPoint: String? = "http://${server.hostAndPort}/crl/empty.crl", maxMessageSize: Int = MAX_MESSAGE_SIZE): Pair<AMQPServer, X509Certificate> - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$private fun replaceCrlDistPointCaCertificate(currentCaCert: X509Certificate, certType: CertificateType, issuerKeyPair: KeyPair, crlDistPoint: String?, crlIssuer: X500Name? = null): X509Certificate - LongMethod:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests.Companion$fun createRevocationList(clrServer: CrlServer, signatureAlgorithm: String, caCertificate: X509Certificate, caPrivateKey: PrivateKey, endpoint: String, indirect: Boolean, vararg serialNumbers: BigInteger): X509CRL - LongMethod:CheckpointVerifier.kt$CheckpointVerifier$ fun verifyCheckpointsCompatible( checkpointStorage: CheckpointStorage, currentCordapps: List<Cordapp>, platformVersion: Int, serviceHub: ServiceHub, tokenizableServices: List<Any> ) - LongMethod:ClassAndMemberVisitor.kt$ClassAndMemberVisitor.ClassVisitorImpl$ override fun visit( version: Int, access: Int, name: String, signature: String?, superName: String?, interfaces: Array<String>? ) - LongMethod:ClassAndMemberVisitor.kt$ClassAndMemberVisitor.ClassVisitorImpl$ override fun visitField( access: Int, name: String, desc: String, signature: String?, value: Any? ): FieldVisitor? - LongMethod:ClassAndMemberVisitor.kt$ClassAndMemberVisitor.ClassVisitorImpl$ override fun visitMethod( access: Int, name: String, desc: String, signature: String?, exceptions: Array<out String>? ): MethodVisitor? - LongMethod:ClassAndMemberVisitorTest.kt$ClassAndMemberVisitorTest$@Test fun `can traverse instructions when writing`() - LongMethod:ClassCarpenter.kt$ClassCarpenterImpl$ override fun build(schema: Schema): Class<*> - LongMethod:ClassCarpenter.kt$ClassCarpenterImpl$ private fun validateSchema(schema: Schema) - LongMethod:ClassCarpenter.kt$ClassCarpenterImpl$private fun ClassWriter.generateClassConstructor(schema: Schema) - LongMethod:ClassCarpenter.kt$ClassCarpenterImpl$private fun ClassWriter.generateStaticEnumConstructor(schema: Schema) - LongMethod:ClassCarpenter.kt$ClassCarpenterImpl$private fun generateClass(classSchema: Schema): Class<*> - LongMethod:ClassCarpenterTest.kt$ClassCarpenterTest$@Test fun `generate multiple interfaces`() - LongMethod:ClassCarpenterTest.kt$ClassCarpenterTest$@Test fun `interface implementing interface`() - LongMethod:ClassCarpenterTest.kt$ClassCarpenterTest$@Test fun `string arrays`() - LongMethod:ClassCarpenterTest.kt$ClassCarpenterTest$@Test fun prims() - LongMethod:ClassCarpenterTestUtils.kt$AmqpCarpenterBase$protected fun RemoteTypeInformation.rename(from: TypeIdentifier, to: TypeIdentifier): RemoteTypeInformation - LongMethod:ClassCarpentingTypeLoaderTests.kt$ClassCarpentingTypeLoaderTests$@Test fun `carpent some related classes`() - LongMethod:ClassCommand.kt$ClassCommand$override fun handleCommand(): Boolean - LongMethod:ClassCommand.kt$ClassCommand$private fun findDiscoverableRunnables(filters: Array<String>): List<Class<*>> - LongMethod:ClassHierarchyTest.kt$ClassHierarchyTest$@Test fun `can derive the correct inherited member from classes in hierarchy when multiple variants of member exists`() - LongMethod:ClassModule.kt$ClassModule$ fun getTypes(abbreviatedSignature: String): List<String> - LongMethod:ClassResolver.kt$ClassResolver$ fun resolveDescriptor(descriptor: String): String - LongMethod:ClientRPCInfrastructureTests.kt$ClientRPCInfrastructureTests$@Test fun `complex ListenableFuture`() - LongMethod:ClientRPCInfrastructureTests.kt$ClientRPCInfrastructureTests$@Test fun `complex observables`() - LongMethod:ClientRpcTutorial.kt$// START 6 fun generateTransactions(proxy: CordaRPCOps) - LongMethod:ClientRpcTutorial.kt$@Suppress("DEPRECATION") fun main(args: Array<String>) - LongMethod:ClockUtilsTest.kt$ClockUtilsTest$@Test @Suspendable fun `test waiting for a deadline with multiple clock advance and incomplete Guava future on Fibers`() - LongMethod:ClockUtilsTest.kt$ClockUtilsTest$@Test @Suspendable fun `test waiting for a deadline with multiple clock advance and incomplete JDK8 future on Fibers`() - LongMethod:CollectSignaturesFlow.kt$CollectSignaturesFlow$@Suspendable override fun call(): SignedTransaction - LongMethod:CollectSignaturesFlow.kt$SignTransactionFlow$@Suspendable override fun call(): SignedTransaction - LongMethod:CommandBase.kt$CommandBase$protected fun printException(exception: Throwable) - LongMethod:CommandBase.kt$CommandBase$protected fun printMessages(messages: MessageCollection, origins: Map<String, Set<EntityReference>> = emptyMap()) - LongMethod:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$fun checkAllParamsAreOfTheSameType(old: CommandDescription, new: CommandDescription): List<CliBackwardsCompatibilityValidationCheck> - LongMethod:CommandLineInterface.kt$CommandLineInterface$fun run(parsedArgs: CliParser) - LongMethod:CommercialPaper.kt$CommercialPaper$override fun verify(tx: LedgerTransaction) - LongMethod:CommercialPaperTests.kt$CommercialPaperTestsGeneric$@Test fun `issue move and then redeem`() - LongMethod:CommercialPaperTests.kt$CommercialPaperTestsGeneric$@Test fun `trade lifecycle test`() - LongMethod:CompatibilityTest.kt$CompatibilityTest$private fun assertSchemasMatch(original: Schema, reserialized: Schema) - LongMethod:CompatibleTransactionTests.kt$CompatibleTransactionTests$@Test fun `Command visibility tests`() - LongMethod:CompatibleTransactionTests.kt$CompatibleTransactionTests$@Test fun `FilteredTransaction constructors and compatibility`() - LongMethod:CompatibleTransactionTests.kt$CompatibleTransactionTests$@Test fun `FilteredTransaction signer manipulation tests`() - LongMethod:CompatibleTransactionTests.kt$CompatibleTransactionTests$@Test fun `Merkle root computations`() - LongMethod:CompatibleTransactionTests.kt$CompatibleTransactionTests$@Test fun `WireTransaction constructors and compatibility`() - LongMethod:CompatibleTransactionTests.kt$CompatibleTransactionTests$@Test fun `parameters hash visibility`() - LongMethod:CompositeKeyTests.kt$CompositeKeyTests$@Test fun `Test save to keystore`() - LongMethod:CompositeKeyTests.kt$CompositeKeyTests$@Test() fun `composite key constraints`() - LongMethod:CompositeKeyTests.kt$CompositeKeyTests$@Test() fun `composite key validation with graph cycle detection`() - LongMethod:ConcatenatedList.kt$ConcatenatedList$// This is where we create a listener for a *nested* list. Note that 'indexMap' doesn't need to be adjusted on any // of these changes as the indices of nested lists don't change, just their contents. private fun createListener(wrapped: WrappedObservableList<A>): ListChangeListener<A> - LongMethod:ConcatenatedList.kt$ConcatenatedList$// This is where we handle changes to the *source* list. override fun sourceChanged(change: ListChangeListener.Change<out ObservableList<A>>) - LongMethod:ConcatenatedListTest.kt$ConcatenatedListTest$@Test fun addWorks() - LongMethod:ConcatenatedListTest.kt$ConcatenatedListTest$@Test fun permutationWorks() - LongMethod:ConcatenatedListTest.kt$ConcatenatedListTest$@Test fun removeWorks() - LongMethod:ConfigExporter.kt$fun main(args: Array<String>) - LongMethod:ConfigUtilities.kt$// For Iterables figure out the type parameter and apply the same logic as above on the individual elements. private fun Iterable<*>.toConfigIterable(field: Field): Iterable<Any?> - LongMethod:ConfigUtilities.kt$// Problems: // - Forces you to have a primary constructor with all fields of name and type matching the configuration file structure. // - Encourages weak bean-like types. // - Cannot support a many-to-one relationship between configuration file structures and configuration domain type. This is essential for versioning of the configuration files. // - It's complicated and based on reflection, meaning problems with it are typically found at runtime. // - It doesn't support validation errors in a structured way. If something goes wrong, it throws exceptions, which doesn't support good usability practices like displaying all the errors at once. fun <T : Any> Config.parseAs(clazz: KClass<T>, onUnknownKeys: ((Set<String>, logger: Logger) -> Unit) = UnknownConfigKeysPolicy.FAIL::handle, nestedPath: String? = null): T - LongMethod:ConfigUtilities.kt$// TODO Move this to KeyStoreConfigHelpers. fun MutualSslConfiguration.configureDevKeyAndTrustStores(myLegalName: CordaX500Name, signingCertificateStore: FileBasedCertificateStoreSupplier, certificatesDirectory: Path, cryptoService: CryptoService? = null) - LongMethod:ConfigUtilities.kt$@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN") // Reflect over the fields of the receiver and generate a value Map that can use to create Config object. private fun Any.toConfigMap(): Map<String, Any> - LongMethod:ConfigUtilities.kt$ConfigHelper$fun loadConfig(baseDirectory: Path, configFile: Path = baseDirectory / "node.conf", allowMissingConfig: Boolean = false, configOverrides: Config = ConfigFactory.empty()): Config - LongMethod:ConfigUtilities.kt$private fun Config.getCollectionValue(path: String, type: KType, onUnknownKeys: (Set<String>, logger: Logger) -> Unit, nestedPath: String? = null): Collection<Any> - LongMethod:ConfigUtilities.kt$private fun Config.getSingleValue(path: String, type: KType, onUnknownKeys: (Set<String>, logger: Logger) -> Unit, nestedPath: String? = null): Any? - LongMethod:ConfigurationSteps.kt$ConfigurationSteps$override fun initialize(state: ScenarioState) - LongMethod:ConnectionStateMachine.kt$ConnectionStateMachine$fun transportProcessInput(msg: ByteBuf) - LongMethod:ConnectionStateMachine.kt$ConnectionStateMachine$fun transportProcessOutput(ctx: ChannelHandlerContext) - LongMethod:ConnectionStateMachine.kt$ConnectionStateMachine$override fun onConnectionFinal(event: Event) - LongMethod:ConnectionStateMachine.kt$ConnectionStateMachine$override fun onDelivery(event: Event) - LongMethod:ConnectionStateMachine.kt$ConnectionStateMachine$private fun getSender(target: String): Sender - LongMethod:ConnectionStateMachine.kt$ConnectionStateMachine$private fun transmitMessages(sender: Sender) - LongMethod:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test @Ignore // TODO(mike): rework fun `Happy path for Hash to Signature Constraint migration`() - LongMethod:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test fun `Attachment canBeTransitionedFrom behaves as expected`() - LongMethod:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test fun `Fail early in the TransactionBuilder when attempting to change the hash of the HashConstraint on the spending transaction`() - LongMethod:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test fun `Input states contract version may be lower that current contract version`() - LongMethod:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test fun `On contract annotated with NoConstraintPropagation there is no platform check for propagation, but the transaction builder can't use the AutomaticPlaceholderConstraint`() - LongMethod:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test fun `Transaction validation fails, when constraints do not propagate correctly`() - LongMethod:ContainerService.kt$ContainerService$override fun startService(): Boolean - LongMethod:ContainerService.kt$ContainerService$override fun waitUntilStarted(): Boolean - LongMethod:ContractDefinition.kt$ContractDefinition$/* @Test fun `builder problem - should not compile`() { val arr = arrange { actions { acmeCorp may { "execute" anytime { acmeCorp may { "problem" anytime { highStreetBank.gives(acmeCorp, 1.M, USD) } } } } } } assertTrue( arr is Actions ) if (arr is Actions) { assertEquals(1, arr.actions.size) } } */ @Test fun `builder problem - legal`() - LongMethod:ContractJarTestUtils.kt$ContractJarTestUtils$fun signContractJar(jarURL: URL, copyFirst: Boolean, keyStoreDir: Path? = null, alias: String = "testAlias", pwd: String = "testPassword"): Pair<Path, PublicKey> - LongMethod:ContractJarTestUtils.kt$ContractJarTestUtils$private fun createTestClass(workingDir: Path, className: String, packages: List<String>, versionSeed: Int = 0): Path - LongMethod:ContractUpgradeFlowRPCTest.kt$ContractUpgradeFlowRPCTest$@Test fun `2 parties contract upgrade using RPC`() - LongMethod:ContractUpgradeFlowTest.kt$ContractUpgradeFlowTest$@Test fun `2 parties contract upgrade`() - LongMethod:ContractUpgradeFlowTest.kt$ContractUpgradeFlowTest$@Test fun `upgrade Cash to v2`() - LongMethod:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$ fun resolve(services: ServicesForResolution, sigs: List<TransactionSignature>): ContractUpgradeLedgerTransaction - LongMethod:ContractUpgradeUtils.kt$ContractUpgradeUtils$fun <OldState : ContractState, NewState : ContractState> assembleUpgradeTx( stateAndRef: StateAndRef<OldState>, upgradedContractClass: Class<out UpgradedContract<OldState, NewState>>, privacySalt: PrivacySalt, services: ServicesForResolution ): ContractUpgradeWireTransaction - LongMethod:CorDappInfoServlet.kt$CorDappInfoServlet$@Throws(IOException::class) override fun doGet(req: HttpServletRequest, resp: HttpServletResponse) - LongMethod:CorDappSerializerTests.kt$CorDappSerializerTests$@Test fun testWithWhitelistAllowed() - LongMethod:CordaCliWrapper.kt$fun CordaCliWrapper.start(args: Array<String>) - LongMethod:CordaFutureImpl.kt$ fun <V> Collection<CordaFuture<out V>>.transpose(): CordaFuture<List<V>> - LongMethod:CordaFutureImplTest.kt$CordaFutureTest$@Test fun `flatMap works`() - LongMethod:CordaFutureImplTest.kt$CordaFutureTest$@Test fun `map works`() - LongMethod:CordaModule.kt$CordaModule$override fun setupModule(context: SetupContext) - LongMethod:CordaPersistence.kt$CordaPersistence$private fun <T> inTopLevelTransaction(isolationLevel: TransactionIsolationLevel, recoverableFailureTolerance: Int, recoverAnyNestedSQLException: Boolean, statement: DatabaseTransaction.() -> T): T - LongMethod:CordaRPCClient.kt$CordaRPCClientConfiguration$ @Suppress("DEPRECATION") @JvmOverloads fun copy( connectionMaxRetryInterval: Duration = this.connectionMaxRetryInterval, minimumServerProtocolVersion: Int = this.minimumServerProtocolVersion, trackRpcCallSites: Boolean = this.trackRpcCallSites, reapInterval: Duration = this.reapInterval, observationExecutorPoolSize: Int = this.observationExecutorPoolSize, cacheConcurrencyLevel: Int = this.cacheConcurrencyLevel, connectionRetryInterval: Duration = this.connectionRetryInterval, connectionRetryIntervalMultiplier: Double = this.connectionRetryIntervalMultiplier, maxReconnectAttempts: Int = this.maxReconnectAttempts, maxFileSize: Int = this.maxFileSize, deduplicationCacheExpiry: Duration = this.deduplicationCacheExpiry ): CordaRPCClientConfiguration - LongMethod:CordaRPCClientTest.kt$CordaRPCClientTest$@Test fun `flow initiator via RPC`() - LongMethod:CordaRPCClientTest.kt$CordaRPCClientTest$@Test fun `shutdown command stops the node`() - LongMethod:CordaRPCOps.kt$ @Deprecated("For automated upgrades, consider using the `gracefulShutdown` command in an SSH session instead.") fun CordaRPCOps.pendingFlowsCount(): DataFeed<Int, Pair<Int, Int>> - LongMethod:CordaRPCOpsImplTest.kt$CordaRPCOpsImplTest$@Test fun `cash issue accepted`() - LongMethod:CordaRPCOpsImplTest.kt$CordaRPCOpsImplTest$@Test fun `issue and move`() - LongMethod:CordappConstraintsTests.kt$CordappConstraintsTests$@Test @Ignore // TODO(mike): rework fun `issue cash and transfer using hash to signature constraints migration`() - LongMethod:CordappConstraintsTests.kt$CordappConstraintsTests$@Test fun `issue and consume cash using hash constraints`() - LongMethod:CordappConstraintsTests.kt$CordappConstraintsTests$@Test fun `issue and consume cash using signature constraints`() - LongMethod:CordappConstraintsTests.kt$CordappConstraintsTests$@Test fun `issue cash using hash and signature constraints`() - LongMethod:CordappConstraintsTests.kt$CordappConstraintsTests$@Test fun `issue cash using signature constraints`() - LongMethod:CordappSmokeTest.kt$CordappSmokeTest$@Test fun `FlowContent appName returns the filename of the CorDapp jar`() - LongMethod:CordappSmokeTest.kt$CordappSmokeTest$private fun createNodeInfoWithSingleIdentity(name: CordaX500Name, nodeKeyPair: KeyPair, identityCertPublicKey: PublicKey): NodeInfo - LongMethod:CrossCashTest.kt$CrossCashState$override fun toString(): String - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$// key generation test @Test fun `Generate key pairs`() - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$@Test fun `ECDSA K1 keyPair from entropy`() - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$@Test fun `ECDSA R1 keyPair from entropy`() - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$@Test fun `ECDSA secp256K1 deterministic key generation`() - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$@Test fun `ECDSA secp256R1 deterministic key generation`() - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$@Test fun `ECDSA secp256k1 full process keygen-sign-verify`() - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$@Test fun `ECDSA secp256r1 full process keygen-sign-verify`() - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$@Test fun `EDDSA ed25519 full process keygen-sign-verify`() - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$@Test fun `EdDSA ed25519 deterministic key generation`() - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$@Test fun `RSA full process keygen-sign-verify`() - LongMethod:CryptoUtilsTest.kt$CryptoUtilsTest$@Test fun `SPHINCS-256 full process keygen-sign-verify`() - LongMethod:CustomCordapp.kt$CustomCordapp$private fun signJar(jarFile: Path) - LongMethod:CustomSerializerRegistry.kt$CachingCustomSerializerRegistry$private fun doFindCustomSerializer(clazz: Class<*>, declaredType: Type): AMQPSerializer<Any>? - LongMethod:CustomVaultQuery.kt$CustomVaultQuery.Service$fun rebalanceCurrencyReserves(): List<Amount<Currency>> - LongMethod:DBCheckpointStorageTests.kt$DBCheckpointStorageTests$@Test fun `add checkpoint and then remove after 'restart'`() - LongMethod:DBCheckpointStorageTests.kt$DBCheckpointStorageTests$@Test fun `add two checkpoints then remove first one`() - LongMethod:DBCheckpointStorageTests.kt$DBCheckpointStorageTests$@Test fun `verify checkpoints compatible`() - LongMethod:DBNetworkParametersStorageTest.kt$DBNetworkParametersStorageTest$@Before fun setUp() - LongMethod:DBTransactionStorage.kt$DBTransactionStorage.Companion$fun createTransactionsMap(cacheFactory: NamedCacheFactory) : AppendOnlyPersistentMapBase<SecureHash, TxCacheValue, DBTransaction, String> - LongMethod:DJVMExceptionTest.kt$DJVMExceptionTest$@Test fun testMultipleExceptions() - LongMethod:DJVMTest.kt$DJVMTest$@Test fun testUnsandboxingArrays() - LongMethod:DataUploadServlet.kt$DataUploadServlet$@Throws(IOException::class) override fun doPost(req: HttpServletRequest, resp: HttpServletResponse) - LongMethod:DatabaseConnection.kt$DatabaseConnection$private fun query(conn: Connection?, stmt: String? = null) - LongMethod:DbMapDeadlockTest.kt$DbMapDeadlockTest$fun recreateDeadlock(hikariProperties: Properties) - LongMethod:DefaultKryoCustomizer.kt$DefaultKryoCustomizer$fun customize(kryo: Kryo, publicKeySerializer: Serializer<PublicKey> = PublicKeySerializer): Kryo - LongMethod:DefaultKryoCustomizer.kt$DefaultKryoCustomizer.ContractAttachmentSerializer$@Suppress("UNCHECKED_CAST") override fun read(kryo: Kryo, input: Input, type: Class<ContractAttachment>): ContractAttachment - LongMethod:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$override fun transition(): TransitionResult - LongMethod:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$private fun TransitionBuilder.confirmMessageTransition(sessionState: SessionState, message: ConfirmSessionMessage) - LongMethod:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$private fun TransitionBuilder.endMessageTransition() - LongMethod:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$private fun TransitionBuilder.errorMessageTransition(sessionState: SessionState, payload: ErrorSessionMessage) - LongMethod:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$private fun TransitionBuilder.rejectMessageTransition(sessionState: SessionState, payload: RejectSessionMessage) - LongMethod:DeserializationInput.kt$DeserializationInput$internal fun readObject(obj: Any, schemas: SerializationSchemas, type: Type, context: SerializationContext): Any - LongMethod:DeserializationInput.kt$DeserializationInput.Companion$@VisibleForTesting @Throws(AMQPNoTypeNotSerializableException::class) fun <T> withDataBytes( byteSequence: ByteSequence, encodingWhitelist: EncodingWhitelist, task: (ByteBuffer) -> T ) : T - LongMethod:DeserializeNeedingCarpentryOfEnumsTest.kt$DeserializeNeedingCarpentryOfEnumsTest$@Test fun compositeIncludingEnums() - LongMethod:DeserializeNeedingCarpentrySimpleTypesTest.kt$DeserializeNeedingCarpentrySimpleTypesTest$@Test fun manyTypes() - LongMethod:DeserializeNeedingCarpentryTests.kt$DeserializeNeedingCarpentryTests$@Test fun arrayOfTypes() - LongMethod:DeserializeNeedingCarpentryTests.kt$DeserializeNeedingCarpentryTests$@Test fun listOfType() - LongMethod:DeserializeNeedingCarpentryTests.kt$DeserializeNeedingCarpentryTests$@Test fun repeatedTypesAreRecognised() - LongMethod:DeserializeNeedingCarpentryTests.kt$DeserializeNeedingCarpentryTests$@Test fun verySimpleType() - LongMethod:DeserializeSimpleTypesTests.kt$DeserializeSimpleTypesTests$@Test fun arrayOfArrayOfIntArray() - LongMethod:DeserializeSimpleTypesTests.kt$DeserializeSimpleTypesTests$@Test fun testByteArray() - LongMethod:DeserializeSimpleTypesTests.kt$DeserializeSimpleTypesTests$@Test fun testCharArray() - LongMethod:Disruption.kt$fun <A> Nodes.withDisruptions(disruptions: List<DisruptionSpec>, mainRandom: SplittableRandom, action: () -> A): A - LongMethod:DistributedServiceTests.kt$DistributedServiceTests$// TODO This should be in RaftNotaryServiceTests @Test fun `cluster survives if a notary is killed`() - LongMethod:DistributedServiceTests.kt$DistributedServiceTests$private fun setup(compositeIdentity: Boolean = false, testBlock: () -> Unit) - LongMethod:DockerInstantiator.kt$DockerInstantiator$override fun instantiateContainer(imageId: String, portsToOpen: List<Int>, instanceName: String, env: Map<String, String>?): CompletableFuture<Pair<String, Map<Int, Int>>> - LongMethod:Driver.kt$ fun <A> driver(defaultParameters: DriverParameters = DriverParameters(), dsl: DriverDSL.() -> A): A - LongMethod:Driver.kt$DriverParameters$fun copy( isDebug: Boolean, driverDirectory: Path, portAllocation: PortAllocation, debugPortAllocation: PortAllocation, systemProperties: Map<String, String>, useTestClock: Boolean, startNodesInProcess: Boolean, waitForAllNodesToFinish: Boolean, notarySpecs: List<NotarySpec>, extraCordappPackagesToScan: List<String>, jmxPolicy: JmxPolicy, networkParameters: NetworkParameters ) - LongMethod:Driver.kt$DriverParameters$fun copy( isDebug: Boolean, driverDirectory: Path, portAllocation: PortAllocation, debugPortAllocation: PortAllocation, systemProperties: Map<String, String>, useTestClock: Boolean, startNodesInProcess: Boolean, waitForAllNodesToFinish: Boolean, notarySpecs: List<NotarySpec>, extraCordappPackagesToScan: List<String>, jmxPolicy: JmxPolicy, networkParameters: NetworkParameters, cordappsForAllNodes: Set<TestCordapp>? ) - LongMethod:DriverDSLImpl.kt$ fun <DI : DriverDSL, D : InternalDriverDSL, A> genericDriver( defaultParameters: DriverParameters = DriverParameters(), driverDslWrapper: (DriverDSLImpl) -> D, coerce: (D) -> DI, dsl: DI.() -> A ): A - LongMethod:DriverDSLImpl.kt$DriverDSLImpl$override fun start() - LongMethod:DriverDSLImpl.kt$DriverDSLImpl$private fun establishRpc(config: NodeConfig, processDeathFuture: CordaFuture<out Process>): CordaFuture<CordaRPCOps> - LongMethod:DriverDSLImpl.kt$DriverDSLImpl$private fun startNodeInternal(config: NodeConfig, webAddress: NetworkHostAndPort, localNetworkMap: LocalNetworkMap?, parameters: NodeParameters): CordaFuture<NodeHandle> - LongMethod:DriverDSLImpl.kt$DriverDSLImpl$private fun startNodeRegistration( providedName: CordaX500Name, rootCert: X509Certificate, networkServicesConfig: NetworkServicesConfig, customOverrides: Map<String, Any?> = mapOf() ): CordaFuture<NodeConfig> - LongMethod:DriverDSLImpl.kt$DriverDSLImpl$private fun startNotaryIdentityGeneration(): CordaFuture<List<NotaryInfo>> - LongMethod:DriverDSLImpl.kt$DriverDSLImpl$private fun startNotaryRegistration( spec: NotarySpec, rootCert: X509Certificate, compatibilityZone: CompatibilityZoneParams ): CordaFuture<NotaryInfo> - LongMethod:DriverDSLImpl.kt$DriverDSLImpl$private fun startRaftNotaryCluster(spec: NotarySpec, localNetworkMap: LocalNetworkMap?): CordaFuture<List<NodeHandle>> - LongMethod:DriverDSLImpl.kt$DriverDSLImpl$private fun startRegisteredNode(name: CordaX500Name, localNetworkMap: LocalNetworkMap?, parameters: NodeParameters, p2pAddress: NetworkHostAndPort = portAllocation.nextHostAndPort()): CordaFuture<NodeHandle> - LongMethod:DriverDSLImpl.kt$DriverDSLImpl.Companion$private fun startInProcessNode( executorService: ScheduledExecutorService, config: NodeConfig ): CordaFuture<Pair<NodeWithInfo, Thread>> - LongMethod:DriverDSLImpl.kt$DriverDSLImpl.Companion$private fun startOutOfProcessNode( config: NodeConfig, quasarJarPath: String, debugPort: Int?, overriddenSystemProperties: Map<String, String>, maximumHeapSize: String, vararg extraCmdLineFlag: String ): Process - LongMethod:DriverDSLImpl.kt$NetworkVisibilityController.VisibilityHandle$fun listen(rpc: CordaRPCOps): CordaFuture<Unit> - LongMethod:DriverDSLImpl.kt$fun <A> internalDriver( isDebug: Boolean = DriverParameters().isDebug, driverDirectory: Path = DriverParameters().driverDirectory, portAllocation: PortAllocation = DriverParameters().portAllocation, debugPortAllocation: PortAllocation = DriverParameters().debugPortAllocation, systemProperties: Map<String, String> = DriverParameters().systemProperties, useTestClock: Boolean = DriverParameters().useTestClock, startNodesInProcess: Boolean = DriverParameters().startNodesInProcess, extraCordappPackagesToScan: List<String> = DriverParameters().extraCordappPackagesToScan, waitForAllNodesToFinish: Boolean = DriverParameters().waitForAllNodesToFinish, notarySpecs: List<NotarySpec> = DriverParameters().notarySpecs, jmxPolicy: JmxPolicy = DriverParameters().jmxPolicy, networkParameters: NetworkParameters = DriverParameters().networkParameters, compatibilityZone: CompatibilityZoneParams? = null, notaryCustomOverrides: Map<String, Any?> = DriverParameters().notaryCustomOverrides, inMemoryDB: Boolean = DriverParameters().inMemoryDB, cordappsForAllNodes: Collection<TestCordappInternal>? = null, dsl: DriverDSLImpl.() -> A ): A - LongMethod:DummyFungibleContract.kt$DummyFungibleContract$override fun verify(tx: LedgerTransaction) - LongMethod:DummyFungibleContract.kt$DummyFungibleContract.State$ override fun generateMappedObject(schema: MappedSchema): PersistentState - LongMethod:DummyLinearContract.kt$DummyLinearContract.State$override fun generateMappedObject(schema: MappedSchema): PersistentState - LongMethod:DumpHistoryOnErrorInterceptor.kt$DumpHistoryOnErrorInterceptor$@Suspendable override fun executeTransition( fiber: FlowFiber, previousState: StateMachineState, event: Event, transition: TransitionResult, actionExecutor: ActionExecutor ): Pair<FlowContinuation, StateMachineState> LongMethod:EdDSATests.kt$EdDSATests$@Test fun `PureEdDSA Ed25519 test vectors`() - LongMethod:EnumEvolvabilityTests.kt$EnumEvolvabilityTests$@Test fun defaultAnnotationIsAddedToEnvelopeAndDeserialised() - LongMethod:EnumEvolvabilityTests.kt$EnumEvolvabilityTests$@Test fun doubleRenameAnnotationIsAdded() - LongMethod:EnumEvolvabilityTests.kt$EnumEvolvabilityTests$@Test fun multiEnums() - LongMethod:EnumEvolvabilityTests.kt$EnumEvolvabilityTests$@Test fun renameAnnotationIsAdded() - LongMethod:EnumEvolveTests.kt$EnumEvolveTests$@Test fun deserializeWithRename() - LongMethod:EnumEvolveTests.kt$EnumEvolveTests$@Test fun multiOperations() - LongMethod:EnumTests.kt$EnumTests$@Test fun deserialiseSimpleTest() - LongMethod:EnumTransforms.kt$EnumTransforms$ private fun validateNoCycles(constants: Map<String, Int>) - LongMethod:ErrorFlowTransition.kt$ErrorFlowTransition$// Buffer error messages in Initiating sessions, return the initialised ones. private fun bufferErrorMessagesInInitiatingSessions( sessions: Map<SessionId, SessionState>, errorMessages: List<ErrorSessionMessage> ): Pair<List<SessionState.Initiated>, Map<SessionId, SessionState>> - LongMethod:ErrorFlowTransition.kt$ErrorFlowTransition$override fun transition(): TransitionResult - LongMethod:Eventually.kt$ inline fun <R> eventually( duration: Duration = Duration.ofSeconds(5), waitBetween: Duration = Duration.ofMillis(100), waitBefore: Duration = waitBetween, test: () -> R): R - LongMethod:EvolvabilityTests.kt$EvolvabilityTests$@Test fun addMandatoryFieldWithAltReorderedConstructor() - LongMethod:EvolvabilityTests.kt$EvolvabilityTests$@Test fun addMandatoryFieldWithAltReorderedConstructorAndRemoval() - LongMethod:EvolvabilityTests.kt$EvolvabilityTests$@Test fun changeSubType() - LongMethod:EvolvabilityTests.kt$EvolvabilityTests$@Test fun moreComplexNonNullWithReorder() - LongMethod:EvolvabilityTests.kt$EvolvabilityTests$@Test fun multiVersion() - LongMethod:EvolvabilityTests.kt$EvolvabilityTests$@Test fun multiVersionWithRemoval() - LongMethod:Expect.kt$ fun <S, E : Any> S.genericExpectEvents( isStrict: Boolean = true, stream: S.((E) -> Unit) -> Unit, expectCompose: () -> ExpectCompose<E> ) - LongMethod:Expect.kt$ExpectComposeState.Companion$fun <E : Any> fromExpectCompose(expectCompose: ExpectCompose<E>): ExpectComposeState<E> - LongMethod:Explorer.kt$Explorer$@Throws(IOException::class) fun open(config: NodeConfigWrapper, onExit: (NodeConfigWrapper) -> Unit) - LongMethod:ExternalIdMappingTest.kt$ExternalIdMappingTest$@Test fun `Two states can be mapped to a single externalId`() - LongMethod:FXFwdTimeOption.kt$FXFwdTimeOption$@Test fun `maturity, bank exercise`() - LongMethod:FXFwdTimeOption.kt$FXFwdTimeOption$@Test fun `maturity, corp exercise`() - LongMethod:FiberDeserializationCheckingInterceptor.kt$FiberDeserializationChecker$fun start(checkpointSerializationContext: CheckpointSerializationContext) - LongMethod:FinalityFlow.kt$FinalityFlow$@Suspendable @Throws(NotaryException::class) override fun call(): SignedTransaction - LongMethod:FlattenedList.kt$FlattenedList$override fun sourceChanged(c: ListChangeListener.Change<out ObservableValue<out A>>) - LongMethod:FlattenedListTest.kt$FlattenedListTest$@Test fun addWorks() - LongMethod:FlowCheckpointVersionNodeStartupCheckTest.kt$FlowCheckpointVersionNodeStartupCheckTest$@Test fun `restart node with mismatch between suspended flow and installed CorDapps`() LongMethod:FlowCookbook.kt$InitiatorFlow$@Suppress("RemoveExplicitTypeArguments") @Suspendable override fun call() - LongMethod:FlowFrameworkPersistenceTests.kt$FlowFrameworkPersistenceTests$@Ignore("Some changes in startup order make this test's assumptions fail.") @Test fun `flow with send will resend on interrupted restart`() - LongMethod:FlowFrameworkTests.kt$FlowFrameworkTests$@Test fun `FlowException thrown on other side`() - LongMethod:FlowFrameworkTests.kt$FlowFrameworkTests$@Test fun `non-FlowException thrown on other side`() - LongMethod:FlowFrameworkTripartyTests.kt$FlowFrameworkTripartyTests$@Test fun `FlowException thrown and there is a 3rd unrelated party flow`() - LongMethod:FlowFrameworkTripartyTests.kt$FlowFrameworkTripartyTests$@Test fun `receiving from multiple parties`() - LongMethod:FlowFrameworkTripartyTests.kt$FlowFrameworkTripartyTests$@Test fun `sending to multiple parties`() - LongMethod:FlowManager.kt$NodeFlowManager$@Synchronized override fun <F : FlowLogic<*>> registerInitiatedFlow(initiator: Class<out FlowLogic<*>>, responder: Class<F>) - LongMethod:FlowRetryTest.kt$InitiatorFlow$@Suspendable override fun call(): Any - LongMethod:FlowStackSnapshot.kt$FlowStackSnapshotFactoryImpl$private fun extractStackSnapshotFromFiber(fiber: Fiber<*>, stackTrace: List<StackTraceElement>, flowClass: Class<out FlowLogic<*>>): FlowStackSnapshot - LongMethod:FlowStackSnapshotTest.kt$FlowStackSnapshotTest$@Test fun `persistFlowStackSnapshot stack traces are aligned with stack objects`() - LongMethod:FlowStateMachineImpl.kt$FlowStateMachineImpl$ @Suspendable private fun processEventsUntilFlowIsResumed(isDbTransactionOpenOnEntry: Boolean, isDbTransactionOpenOnExit: Boolean): Any? - LongMethod:FlowStateMachineImpl.kt$FlowStateMachineImpl$@Suspendable override fun <R : Any> suspend(ioRequest: FlowIORequest<R>, maySkipCheckpoint: Boolean): R - LongMethod:FlowStateMachineImpl.kt$FlowStateMachineImpl$@Suspendable override fun <R> subFlow(subFlow: FlowLogic<R>): R - LongMethod:FlowStateMachineImpl.kt$FlowStateMachineImpl$@Suspendable override fun run() - LongMethod:FlowStateMachineImpl.kt$FlowStateMachineImpl$private fun Throwable.fillInLocalStackTrace(): Throwable - LongMethod:FlowWatchPrintingSubscriber.kt$FlowWatchPrintingSubscriber$// TODO Add progress tracker? private fun createStateMachinesRow(smmUpdate: StateMachineUpdate) - LongMethod:FxTransactionBuildTutorial.kt$ForeignExchangeFlow$@Suspendable override fun call(): SecureHash - LongMethod:FxTransactionBuildTutorial.kt$ForeignExchangeRemoteFlow$@Suspendable override fun call() - LongMethod:FxTransactionBuildTutorialTest.kt$FxTransactionBuildTutorialTest$@Test fun `Run ForeignExchangeFlow to completion`() - LongMethod:GenerateRpcSslCertsCli.kt$GenerateRpcSslCerts$private fun generateRpcSslCertificates(conf: NodeConfiguration) - LongMethod:Generator.kt$Generator.Companion$ fun <A> frequency(generators: List<Pair<Double, Generator<A>>>): Generator<A> - LongMethod:Generator.kt$Generator.Companion$fun <A> pickN(number: Int, list: List<A>) - LongMethod:Generator.kt$Generator.Companion$fun <A> replicatePoisson(meanSize: Double, generator: Generator<A>, atLeastOne: Boolean = false) - LongMethod:GenericsTests.kt$GenericsTests$// // If this doesn't blow up all is fine private fun fingerprintingDiffersStrip(state: Any) - LongMethod:GenericsTests.kt$GenericsTests$@Test fun nestedGenericsReferencesByteArrayViaSerializedBytes() - LongMethod:GenericsTests.kt$GenericsTests$@Test fun nestedSerializationInMultipleContextsDoesntColideGenericTypes() - LongMethod:GenericsTests.kt$GenericsTests$@Test fun nestedSerializationOfGenerics() - LongMethod:GenericsTests.kt$GenericsTests$@Test fun nestedSerializationWhereGenericDoesntImpactFingerprint() - LongMethod:HTTPNetworkRegistrationService.kt$HTTPNetworkRegistrationService$@Throws(CertificateRequestException::class) override fun retrieveCertificates(requestId: String): CertificateResponse - LongMethod:HardRestartTest.kt$HardRestartTest$@Test fun restartLongPingPongFlowRandomly() - LongMethod:HardRestartTest.kt$HardRestartTest$@Test fun restartRecursiveFlowRandomly() - LongMethod:HardRestartTest.kt$HardRestartTest$@Test fun restartShortPingPongFlowRandomly() - LongMethod:HardRestartTest.kt$HardRestartTest$@Test fun softRestartLongPingPongFlowRandomly() - LongMethod:HardRestartTest.kt$HardRestartTest.RecursiveA$@Suspendable override fun call(): String - LongMethod:HibernateColumnConverterTests.kt$HibernateColumnConverterTests$// AbstractPartyToX500NameAsStringConverter could cause circular flush of Hibernate session because it is invoked during flush, and a // cache miss was doing a flush. This also checks that loading during flush does actually work. @Test fun `issue some cash on a notary that exists only in the database to check cache loading works in our identity column converters during flush of vault update`() - LongMethod:HibernateConfiguration.kt$HibernateConfiguration$private fun makeSessionFactoryForSchemas(schemas: Set<MappedSchema>): SessionFactory - LongMethod:HibernateConfigurationTest.kt$HibernateConfigurationTest$ @Test fun `composite or query across VaultStates, VaultLinearStates and DummyLinearStates`() - LongMethod:HibernateConfigurationTest.kt$HibernateConfigurationTest$ @Test fun `query fungible states by owner party`() - LongMethod:HibernateConfigurationTest.kt$HibernateConfigurationTest$ @Test fun `query fungible states by participants`() - LongMethod:HibernateConfigurationTest.kt$HibernateConfigurationTest$ @Test fun `select by composite primary between VaultStates, VaultLinearStates and DummyLinearStates`() - LongMethod:HibernateConfigurationTest.kt$HibernateConfigurationTest$ @Test fun `three way join by composite primary between VaultStates, VaultLinearStates and DummyLinearStates`() - LongMethod:HibernateConfigurationTest.kt$HibernateConfigurationTest$ @Test fun `with sorting on attribute from common table`() - LongMethod:HibernateConfigurationTest.kt$HibernateConfigurationTest$ @Test fun `with sorting on attribute from custom table`() - LongMethod:HibernateConfigurationTest.kt$HibernateConfigurationTest$@Before fun setUp() - LongMethod:HibernateConfigurationTest.kt$HibernateConfigurationTest$@Test fun `calculate and order by cash balance for owner and currency`() - LongMethod:HibernateConfigurationTest.kt$HibernateConfigurationTest$@Test fun `calculate cash balances`() - LongMethod:HibernateQueryCriteriaParser.kt$AbstractQueryCriteriaParser$private fun collectionComparisonToPredicate(column: Path<out Any?>, columnPredicate: CollectionExpression<*>): Predicate - LongMethod:HibernateQueryCriteriaParser.kt$HibernateAttachmentQueryCriteriaParser$override fun parseCriteria(criteria: AttachmentQueryCriteria.AttachmentsQueryCriteria): Collection<Predicate> - LongMethod:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$override fun <L : StatePersistable> parseCriteria(criteria: QueryCriteria.VaultCustomQueryCriteria<L>): Collection<Predicate> - LongMethod:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$override fun parseCriteria(criteria: CommonQueryCriteria): Collection<Predicate> - LongMethod:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$override fun parseCriteria(criteria: QueryCriteria.FungibleAssetQueryCriteria): Collection<Predicate> - LongMethod:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$override fun parseCriteria(criteria: QueryCriteria.LinearStateQueryCriteria): Collection<Predicate> - LongMethod:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$override fun parseCriteria(criteria: QueryCriteria.VaultQueryCriteria): Collection<Predicate> - LongMethod:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$private fun <O, R> parseAggregateFunction(root: Root<O>, expression: CriteriaExpression.AggregateFunctionExpression<O, R>): Expression<out Any?>? - LongMethod:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$private fun parse(sorting: Sort) - LongMethod:HospitalisingInterceptor.kt$HospitalisingInterceptor$@Suspendable override fun executeTransition( fiber: FlowFiber, previousState: StateMachineState, event: Event, transition: TransitionResult, actionExecutor: ActionExecutor ): Pair<FlowContinuation, StateMachineState> - LongMethod:IRS.kt$IRS$@Test fun `first fixing`() - LongMethod:IRS.kt$InterestRateSwap$ fun generateAgreement(floatingLeg: FloatingLeg, fixedLeg: FixedLeg, calculation: Calculation, common: Common, oracle: Party, notary: Party): TransactionBuilder - LongMethod:IRS.kt$InterestRateSwap$override fun verify(tx: LedgerTransaction) - LongMethod:IRS.kt$InterestRateSwap$private fun verifyFixCommand(inputs: List<State>, outputs: List<State>, command: CommandWithParties<Commands.Refix>) - LongMethod:IRS.kt$InterestRateSwap.FloatingLeg$fun copy(floatingRatePayer: AbstractParty = this.floatingRatePayer, notional: Amount<Currency> = this.notional, paymentFrequency: Frequency = this.paymentFrequency, effectiveDate: LocalDate = this.effectiveDate, effectiveDateAdjustment: DateRollConvention? = this.effectiveDateAdjustment, terminationDate: LocalDate = this.terminationDate, terminationDateAdjustment: DateRollConvention? = this.terminationDateAdjustment, dayCountBasisDay: DayCountBasisDay = this.dayCountBasisDay, dayCountBasisYear: DayCountBasisYear = this.dayCountBasisYear, dayInMonth: Int = this.dayInMonth, paymentRule: PaymentRule = this.paymentRule, paymentDelay: Int = this.paymentDelay, paymentCalendar: BusinessCalendar = this.paymentCalendar, interestPeriodAdjustment: AccrualAdjustment = this.interestPeriodAdjustment, rollConvention: DateRollConvention = this.rollConvention, fixingRollConvention: DateRollConvention = this.fixingRollConvention, resetDayInMonth: Int = this.resetDayInMonth, fixingPeriod: Int = this.fixingPeriodOffset, resetRule: PaymentRule = this.resetRule, fixingsPerPayment: Frequency = this.fixingsPerPayment, fixingCalendar: BusinessCalendar = this.fixingCalendar, index: String = this.index, indexSource: String = this.indexSource, indexTenor: Tenor = this.indexTenor ) - LongMethod:IRSDemoTest.kt$IRSDemoTest$@Test fun `runs IRS demo`() - LongMethod:IRSTests.kt$IRSTests$ @Test fun generateIRSandFixSome() - LongMethod:IRSTests.kt$IRSTests$ fun trade(): LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter> - LongMethod:IRSTests.kt$IRSTests$ fun tradegroups(): LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter> - LongMethod:IRSTests.kt$IRSTests$@Test fun `ensure trade date and termination date checks are done pt1`() - LongMethod:IRSTests.kt$IRSTests$@Test fun `ensure trade date and termination date checks are done pt2`() - LongMethod:IRSTests.kt$IRSTests$@Test fun `expression calculation testing`() - LongMethod:IRSTests.kt$IRSTests$@Test fun `various fixing tests`() LongMethod:IRSTests.kt$fun createDummyIRS(irsSelect: Int): InterestRateSwap.State - LongMethod:IdenticonRenderer.kt$IdenticonRenderer$ private fun render(code: Int, patchSize: Double, backgroundColor: Color = Color.WHITE): Image - LongMethod:IdenticonRenderer.kt$IdenticonRenderer$private fun drawPatch(g: GraphicsContext, x: Double, y: Double, patchIndex: Int, turn: Int, patchSize: Double, _invert: Boolean, color: PatchColor) - LongMethod:IdentityServiceInternal.kt$IdentityServiceInternal$ @Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) fun verifyAndRegisterIdentity(trustAnchor: TrustAnchor, identity: PartyAndCertificate, isNewRandomIdentity: Boolean = false): PartyAndCertificate? - LongMethod:IdentitySyncFlowTests.kt$IdentitySyncFlowTests$@Test fun `don't offer other's identities confidential identities`() - LongMethod:IdentitySyncFlowTests.kt$IdentitySyncFlowTests$@Test fun `sync confidential identities`() - LongMethod:InMemoryIdentityServiceTests.kt$InMemoryIdentityServiceTests$ @Test fun `assert ownership`() - LongMethod:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$@Test fun `fourth get outside first transaction from empty cache with invalidate in the middle returns result of third loader`() - LongMethod:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$@Test fun `fourth get outside first transaction from empty cache with nested invalidate in the middle returns result of third loader`() - LongMethod:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$@Test fun `other thread get outside first transaction with invalidate in the middle returns result of other thread`() - LongMethod:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$@Test fun `transaction started before invalidating thread commits does not cache until after the other thread commits`() - LongMethod:Injectors.kt$fun startPublishingFixedRateInjector( metricRegistry: MetricRegistry, parallelism: Int, overallDuration: Duration, injectionRate: Rate, queueSizeMetricName: String = "QueueSize", workDurationMetricName: String = "WorkDuration", work: () -> Unit ) - LongMethod:Injectors.kt$fun startTightLoopInjector( parallelism: Int, numberOfInjections: Int, queueBound: Int, work: () -> Unit ) - LongMethod:InspectionCommand.kt$InspectionCommand$override fun processClasses(classes: List<Class<*>>) - LongMethod:InstallShellExtensionsParser.kt$ShellExtensionsGenerator$fun installShellExtensions(): Int - LongMethod:InteractiveShell.kt$InteractiveShell$ @JvmStatic fun runFlowByNameFragment(nameFragment: String, inputData: String, output: RenderPrintWriter, rpcOps: CordaRPCOps, ansiProgressRenderer: ANSIProgressRenderer, inputObjectMapper: ObjectMapper = createYamlInputMapper(rpcOps)) - LongMethod:InteractiveShell.kt$InteractiveShell$ @Throws(NoApplicableConstructor::class) fun <T> runFlowFromString(invoke: (Class<out FlowLogic<T>>, Array<out Any?>) -> FlowProgressHandle<T>, inputData: String, clazz: Class<out FlowLogic<T>>, om: ObjectMapper): FlowProgressHandle<T> - LongMethod:InteractiveShell.kt$InteractiveShell$// TODO Filtering on error/success when we will have some sort of flow auditing, for now it doesn't make much sense. @JvmStatic fun runStateMachinesView(out: RenderPrintWriter, rpcOps: CordaRPCOps): Any? - LongMethod:InteractiveShell.kt$InteractiveShell$@JvmStatic fun gracefulShutdown(userSessionOut: RenderPrintWriter, cordaRPCOps: CordaRPCOps) - LongMethod:InteractiveShell.kt$InteractiveShell$@JvmStatic fun killFlowById(id: String, output: RenderPrintWriter, rpcOps: CordaRPCOps, inputObjectMapper: ObjectMapper = createYamlInputMapper(rpcOps)) - LongMethod:InteractiveShell.kt$InteractiveShell$@JvmStatic fun runRPCFromString(input: List<String>, out: RenderPrintWriter, context: InvocationContext<out Any>, cordaRPCOps: CordaRPCOps, inputObjectMapper: ObjectMapper): Any? - LongMethod:InteractiveShell.kt$InteractiveShell$fun runLocalShell(onExit: () -> Unit = {}) - LongMethod:InteractiveShell.kt$InteractiveShell$private fun _startShell(configuration: ShellConfiguration, classLoader: ClassLoader? = null) - LongMethod:InteractiveShell.kt$InteractiveShell.ShellLifecycle$fun start(config: Properties, localUserName: String = "", localUserPassword: String = ""): Shell - LongMethod:InteractiveShellIntegrationTest.kt$InteractiveShellIntegrationTest$@Ignore @Test fun `ssh run flows via standalone shell over ssl to node`() - LongMethod:InteractiveShellIntegrationTest.kt$InteractiveShellIntegrationTest$@Ignore @Test fun `ssh runs flows via standalone shell`() - LongMethod:InteractiveShellIntegrationTest.kt$InteractiveShellIntegrationTest$@Test fun `shell shoud not log in with invalid truststore`() - LongMethod:InteractiveShellIntegrationTest.kt$InteractiveShellIntegrationTest$@Test fun `shell should fail to start flow with ambiguous class name`() - LongMethod:InteractiveShellIntegrationTest.kt$InteractiveShellIntegrationTest$@Test fun `shell should log in with ssl`() - LongMethod:InteractiveShellIntegrationTest.kt$InteractiveShellIntegrationTest$@Test fun `shell should start flow with fully qualified class name`() - LongMethod:InteractiveShellIntegrationTest.kt$InteractiveShellIntegrationTest$@Test fun `shell should start flow with partially matching class name`() - LongMethod:InteractiveShellIntegrationTest.kt$InteractiveShellIntegrationTest$@Test fun `shell should start flow with unique un-qualified class name`() - LongMethod:InteractiveShellTest.kt$InteractiveShellTest$@Test fun niceTypeNamesInErrors() - LongMethod:InternalMockNetwork.kt$InternalMockNetwork$private fun createNodeImpl(parameters: InternalMockNodeParameters, nodeFactory: (MockNodeArgs) -> MockNode, start: Boolean): MockNode - LongMethod:InternalMockNetwork.kt$private fun mockNodeConfiguration(certificatesDirectory: Path): NodeConfiguration - LongMethod:InternalMockNetworkTests.kt$InternalMockNetworkTests$ @Test fun `skip unhandled messages`() - LongMethod:InternalUtils.kt$// TODO: Add inline back when a new Kotlin version is released and check if the java.lang.VerifyError // returns in the IRSSimulationTest. If not, commit the inline back. @DeleteForDJVM fun <T> logElapsedTime(label: String, logger: Logger? = null, body: () -> T): T - LongMethod:Interpolators.kt$CubicSplineInterpolator$private fun computeSplineFunction(): SplineFunction - LongMethod:IsolatedTask.kt$IsolatedTask$ fun <T> run(action: IsolatedTask.() -> T?): Result<T> - LongMethod:IssueCash.kt$IssueCash$@JvmStatic fun main(args: Array<String>) - LongMethod:JacksonSupport.kt$JacksonSupport.X509CertificateSerializer$override fun serialize(value: X509Certificate, gen: JsonGenerator, serializers: SerializerProvider) - LongMethod:JacksonSupportTest.kt$JacksonSupportTest$@Test fun TransactionSignature() - LongMethod:JacksonSupportTest.kt$JacksonSupportTest$@Test fun `NodeInfo serialization`() - LongMethod:JacksonSupportTest.kt$JacksonSupportTest$@Test fun `SignedTransaction (WireTransaction)`() - LongMethod:JarScanningCordappLoader.kt$JarScanningCordappLoader$private fun RestrictedScanResult.toCordapp(url: RestrictedURL): CordappImpl - LongMethod:JarScanningCordappLoader.kt$JarScanningCordappLoader$private fun loadCordapps(): List<CordappImpl> - LongMethod:JarScanningCordappLoader.kt$JarScanningCordappLoader$private fun parseCordappInfo(manifest: Manifest?, defaultName: String): Cordapp.Info - LongMethod:JarSignatureTestUtils.kt$JarSignatureTestUtils$fun Path.addManifest(fileName: String, vararg entry: Pair<Attributes.Name, String>) - LongMethod:KMSUtils.kt$ fun freshCertificate(identityService: IdentityService, subjectPublicKey: PublicKey, issuer: PartyAndCertificate, issuerSigner: ContentSigner): PartyAndCertificate - LongMethod:KeyStoreGenerator.kt$KeyStoreGenerator$fun writeKeyStore(output: OutputStream, alias: String, password: CharArray) - LongMethod:KotlinIntegrationTestingTutorial.kt$KotlinIntegrationTestingTutorial$@Test fun `alice bob cash exchange example`() - LongMethod:Kryo.kt$ImmutableClassSerializer$override fun read(kryo: Kryo, input: Input, type: Class<T>): T - LongMethod:Kryo.kt$ImmutableClassSerializer$override fun write(kryo: Kryo, output: Output, obj: T) - LongMethod:KryoCheckpointSerializer.kt$KryoCheckpointSerializer$override fun <T : Any> deserialize(byteSequence: ByteSequence, clazz: Class<T>, context: CheckpointSerializationContext): T - LongMethod:KryoStreamsTest.kt$KryoStreamsTest$@Test fun `ByteBufferOutputStream works`() - LongMethod:KryoTests.kt$KryoTests$@Test fun rxSubscriptionsAreNotSerialized() - LongMethod:LargeTransactionsTest.kt$LargeTransactionsTest$@Test fun checkCanSendLargeTransactions() - LongMethod:LedgerDSLInterpreter.kt$Verifies$ fun failsWith(expectedMessage: String?): EnforceVerifyOrFail - LongMethod:LedgerTransaction.kt$LedgerTransaction$ private fun createLtxForVerification(): LedgerTransaction - LongMethod:LedgerTransaction.kt$LedgerTransaction$@Deprecated("LedgerTransactions should not be created directly, use WireTransaction.toLedgerTransaction instead.") fun copy(inputs: List<StateAndRef<ContractState>> = this.inputs, outputs: List<TransactionState<ContractState>> = this.outputs, commands: List<CommandWithParties<CommandData>> = this.commands, attachments: List<Attachment> = this.attachments, id: SecureHash = this.id, notary: Party? = this.notary, timeWindow: TimeWindow? = this.timeWindow, privacySalt: PrivacySalt = this.privacySalt, networkParameters: NetworkParameters? = this.networkParameters ): LedgerTransaction - LongMethod:LedgerTransaction.kt$LedgerTransaction$@Deprecated("LedgerTransactions should not be created directly, use WireTransaction.toLedgerTransaction instead.") fun copy(inputs: List<StateAndRef<ContractState>>, outputs: List<TransactionState<ContractState>>, commands: List<CommandWithParties<CommandData>>, attachments: List<Attachment>, id: SecureHash, notary: Party?, timeWindow: TimeWindow?, privacySalt: PrivacySalt ): LedgerTransaction - LongMethod:LedgerTransaction.kt$LedgerTransaction.Companion$@CordaInternal internal fun create( inputs: List<StateAndRef<ContractState>>, outputs: List<TransactionState<ContractState>>, commands: List<CommandWithParties<CommandData>>, attachments: List<Attachment>, id: SecureHash, notary: Party?, timeWindow: TimeWindow?, privacySalt: PrivacySalt, networkParameters: NetworkParameters, references: List<StateAndRef<ContractState>>, componentGroups: List<ComponentGroup>? = null, serializedInputs: List<SerializedStateAndRef>? = null, serializedReferences: List<SerializedStateAndRef>? = null ): LedgerTransaction - LongMethod:LeftOuterJoinedMapTest.kt$LeftOuterJoinedMapTest$// TODO perhaps these are too brittle because they test indices that are not stable. Use Expect dsl? @Test fun addWorks() - LongMethod:LeftOuterJoinedMapTest.kt$LeftOuterJoinedMapTest$@Test fun removeWorks() - LongMethod:LoadTest.kt$ fun runLoadTests(configuration: LoadTestConfiguration, tests: List<Pair<LoadTest<*, *>, LoadTest.RunParameters>>) - LongMethod:LoadTest.kt$LoadTest$fun run(nodes: Nodes, parameters: RunParameters, random: SplittableRandom) - LongMethod:LocalTypeInformationBuilder.kt$ private fun constructorForDeserialization(type: Type): KFunction<Any>? - LongMethod:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$ private fun buildNonAtomic(rawType: Class<*>, type: Type, typeIdentifier: TypeIdentifier, typeParameterInformation: List<LocalTypeInformation>): LocalTypeInformation - LongMethod:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$private fun buildForClass(type: Class<*>, typeIdentifier: TypeIdentifier, isOpaque: Boolean): LocalTypeInformation - LongMethod:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$private fun buildForParameterised( rawType: Class<*>, type: ParameterizedType, typeIdentifier: TypeIdentifier.Parameterised, isOpaque: Boolean): LocalTypeInformation - LongMethod:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$private fun makeConstructorPairedProperty(constructorIndex: Int, descriptor: PropertyDescriptor, constructorInformation: LocalConstructorInformation): LocalPropertyInformation? - LongMethod:LocalTypeModelTests.kt$LocalTypeModelTests$@Test fun `Primitives and collections`() - LongMethod:LogSource.kt$LogSource$fun find(pattern: String? = null): List<MatchedLogContent> - LongMethod:LoginView.kt$LoginView$tailrec fun login(): NodeMonitorModel? - LongMethod:MQSecurityAsNodeTest.kt$MQSecurityAsNodeTest$@Test fun `login with invalid certificate chain`() - LongMethod:Main.kt$Main$override fun start(stage: Stage) - LongMethod:Main.kt$Node$fun avalancheLoop() - LongMethod:Main.kt$fun main(args: Array<String>) - LongMethod:Main.kt$private fun runLoadTest(loadTestConfiguration: LoadTestConfiguration) - LongMethod:Main.kt$private fun runStabilityTest(loadTestConfiguration: LoadTestConfiguration) - LongMethod:MappedList.kt$MappedList$override fun sourceChanged(change: ListChangeListener.Change<out A>) - LongMethod:MatcherTests.kt$MatcherTests$@Test fun `nested items indent`() - LongMethod:MaxTransactionSizeTests.kt$MaxTransactionSizeTests$@Test fun `check transaction will fail when exceed max transaction size limit`() - LongMethod:MemberModule.kt$MemberModule$ fun numberOfArguments(signature: String): Int - LongMethod:MerkleTransaction.kt$FilteredTransaction.Companion$fun <T : Any> filter(t: T, componentGroupIndex: Int, internalIndex: Int) - LongMethod:MessageCollection.kt$MessageCollection$ fun add(message: Message) - LongMethod:MockAttachmentStorage.kt$MockAttachmentStorage$override fun queryAttachments(criteria: AttachmentQueryCriteria, sorting: AttachmentSort?): List<AttachmentId> - LongMethod:MockAttachmentStorage.kt$MockAttachmentStorage$private fun importAttachmentInternal(jar: InputStream, uploader: String, contractClassNames: List<ContractClassName>? = null, attachmentId: AttachmentId? = null, signers: List<PublicKey> = emptyList()): AttachmentId - LongMethod:MockCordappProvider.kt$MockCordappProvider$fun addMockCordapp( contractClassName: ContractClassName, attachments: MockAttachmentStorage, contractHash: AttachmentId? = null, signers: List<PublicKey> = emptyList(), jarManifestAttributes: Map<String,String> = emptyMap() ): AttachmentId - LongMethod:MockNodeMessagingService.kt$MockNodeMessagingService$ fun start(network: InMemoryMessagingNetwork, manuallyPumped: Boolean, id: Int, notaryService: PartyAndCertificate?) - LongMethod:MockNodeMessagingService.kt$MockNodeMessagingService$ private fun getNextQueue(q: LinkedBlockingQueue<InMemoryMessagingNetwork.MessageTransfer>, block: Boolean): Pair<InMemoryMessagingNetwork.MessageTransfer, List<Handler>>? - LongMethod:MockNodeMessagingService.kt$MockNodeMessagingService$private fun pumpReceiveInternal(block: Boolean): InMemoryMessagingNetwork.MessageTransfer? - LongMethod:MockServices.kt$MockServices.Companion$ @JvmStatic @JvmOverloads fun makeTestDatabaseAndPersistentServices( cordappPackages: List<String>, initialIdentity: TestIdentity, networkParameters: NetworkParameters = testNetworkParameters(modifiedTime = Instant.MIN), moreKeys: Set<KeyPair>, moreIdentities: Set<PartyAndCertificate> ): Pair<CordaPersistence, MockServices> - LongMethod:MultiMemberCompositeSchemaToClassCarpenterTests.kt$MultiMemberCompositeSchemaToClassCarpenterTests$@Test fun calculatedValues() - LongMethod:Network.kt$Network$fun waitUntilRunning(waitDuration: Duration? = null): Boolean - LongMethod:Network.kt$Network$private fun NodeInfo.render(): MapViewComponents - LongMethod:Network.kt$Network$private fun NodeInfo.renderButton(mapLabel: Label): Button - LongMethod:Network.kt$Network$private fun bootstrapLocalNetwork() - LongMethod:Network.kt$Network$private fun cleanup() - LongMethod:Network.kt$Network$private fun fireBulletBetweenNodes(senderParty: Party, destParty: Party, startType: String, endType: String) - LongMethod:NetworkBootstrapper.kt$NetworkBootstrapper$private fun bootstrap( directory: Path, cordappJars: List<Path>, copyCordapps: CopyCordapps, fromCordform: Boolean, networkParametersOverrides: NetworkParametersOverrides = NetworkParametersOverrides() ) - LongMethod:NetworkBootstrapper.kt$NetworkBootstrapper$private fun createNodeDirectoriesIfNeeded(directory: Path, fromCordform: Boolean): Boolean - LongMethod:NetworkBootstrapper.kt$NetworkBootstrapper$private fun installNetworkParameters( notaryInfos: List<NotaryInfo>, whitelist: Map<String, List<AttachmentId>>, existingNetParams: NetworkParameters?, nodeDirs: List<Path>, networkParametersOverrides: NetworkParametersOverrides ): NetworkParameters - LongMethod:NetworkBootstrapper.kt$NetworkBootstrapper$private fun loadNetworkParameters(nodeDirs: List<Path>): NetworkParameters? - LongMethod:NetworkBootstrapper.kt$NetworkBootstrapper.Companion$private fun generateNodeInfo(nodeDir: Path): Path - LongMethod:NetworkBuilder.kt$NetworkBuilderImpl$override fun build(): CompletableFuture<Pair<List<NodeInstance>, Context>> - LongMethod:NetworkMapServer.kt$NetworkMapServer.InMemoryNetworkMapService$@POST @Path("publish") @Consumes(MediaType.APPLICATION_OCTET_STREAM) fun publishNodeInfo(input: InputStream): Response - LongMethod:NetworkMapTest.kt$NetworkMapTest$@Test fun `parameters update test`() - LongMethod:NetworkMapTest.kt$NetworkMapTest$@Test fun `test node heartbeat`() - LongMethod:NetworkMapTest.kt$NetworkMapTest.Companion$@JvmStatic @Parameterized.Parameters(name = "{0}") fun runParams() - LongMethod:NetworkMapUpdater.kt$NetworkMapUpdater$fun start(trustRoot: X509Certificate, currentParametersHash: SecureHash, ourNodeInfo: SignedNodeInfo, networkParameters: NetworkParameters, keyManagementService: KeyManagementService, networkParameterAcceptanceSettings: NetworkParameterAcceptanceSettings) - LongMethod:NetworkMapUpdater.kt$NetworkMapUpdater$fun updateNetworkMapCache(): Duration - LongMethod:NetworkMapUpdater.kt$NetworkMapUpdater$private fun handleUpdateNetworkParameters(networkMapClient: NetworkMapClient, update: ParametersUpdate) - LongMethod:NetworkMapUpdater.kt$NetworkMapUpdater$private fun watchForNodeInfoFiles(): Subscription - LongMethod:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$@Test fun `auto acceptance checks are correct`() - LongMethod:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$@Test fun `emit new parameters update info on parameters update from network map`() - LongMethod:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$@Test fun `network map updater removes the correct node info after node info changes`() - LongMethod:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$@Test fun `process add node updates from network map, with additional node infos from dir`() - LongMethod:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$@Test fun `process remove node updates from network map, with additional node infos from dir`() - LongMethod:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$@Test fun `remove node from filesystem deletes it from network map cache`() - LongMethod:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$@Test fun `remove node info file, but node in network map server`() - LongMethod:NetworkParameterOverridesSpec.kt$NetworkParameterOverridesSpec.PackageOwnershipSpec$override fun parseValid(configuration: Config): Validated<PackageOwner, Configuration.Validation.Error> - LongMethod:NetworkParameters.kt$NetworkParameters$ fun copy(minimumPlatformVersion: Int = this.minimumPlatformVersion, notaries: List<NotaryInfo> = this.notaries, maxMessageSize: Int = this.maxMessageSize, maxTransactionSize: Int = this.maxTransactionSize, modifiedTime: Instant = this.modifiedTime, epoch: Int = this.epoch, whitelistedContractImplementations: Map<String, List<AttachmentId>> = this.whitelistedContractImplementations ): NetworkParameters - LongMethod:NetworkParameters.kt$NetworkParameters$ fun copy(minimumPlatformVersion: Int = this.minimumPlatformVersion, notaries: List<NotaryInfo> = this.notaries, maxMessageSize: Int = this.maxMessageSize, maxTransactionSize: Int = this.maxTransactionSize, modifiedTime: Instant = this.modifiedTime, epoch: Int = this.epoch, whitelistedContractImplementations: Map<String, List<AttachmentId>> = this.whitelistedContractImplementations, eventHorizon: Duration = this.eventHorizon ): NetworkParameters - LongMethod:NetworkParametersReader.kt$NetworkParametersReader$fun read(): NetworkParametersAndSigned - LongMethod:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$// This function is resolving and signing WireTransaction with special parameters. private fun TransactionBuilder.toSignedTransactionWithParameters(parameters: NetworkParameters?, services: ServiceHub): SignedTransaction - LongMethod:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$@Test fun `incorrect triangle of transactions`() - LongMethod:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$@Test fun `request parameters that are not in the storage`() - LongMethod:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$@Test fun `transaction chain out of order parameters`() - LongMethod:NetworkParametersTest.kt$NetworkParametersTest$@Test fun `package ownership checks are correct`() - LongMethod:NetworkParametersTest.kt$NetworkParametersTest$@Test fun `that we can copy while preserving the event horizon`() - LongMethod:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$ fun generateKeysAndRegister() - LongMethod:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$ private fun pollServerForCertificates(requestId: String): List<X509Certificate> - LongMethod:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$ private fun submitOrResumeCertificateSigningRequest(publicKey: PublicKey, contentSigner: ContentSigner): String - LongMethod:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$private fun validateCertificates(registeringPublicKey: PublicKey, certificates: List<X509Certificate>) - LongMethod:NetworkRegistrationHelper.kt$NodeRegistrationHelper$private fun createSSLKeystore(nodeCaPublicKey: PublicKey, nodeCaContentSigner: ContentSigner, nodeCaCertificateChain: List<X509Certificate>, tlsCertCrlIssuer: X500Name?) - LongMethod:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest$@Test fun `successful registration`() - LongMethod:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest$private fun createRegistrationHelper(certRole: CertRole = CertRole.NODE_CA, dynamicResponse: (JcaPKCS10CertificationRequest) -> List<X509Certificate>): NetworkRegistrationHelper - LongMethod:NewTransaction.kt$NewTransaction$fun show(window: Window) - LongMethod:Node.kt$Node$ override fun startDatabase() - LongMethod:Node.kt$Node$ private fun tryDetectIfNotPublicHost(host: String): String? - LongMethod:Node.kt$Node$fun startDependencies(): Boolean - LongMethod:Node.kt$Node$override fun startMessagingService(rpcOps: RPCOps, nodeInfo: NodeInfo, myNotaryIdentity: PartyAndCertificate?, networkParameters: NetworkParameters) - LongMethod:Node.kt$Node.Builder$fun build(): Node - LongMethod:NodeAttachmentService.kt$NodeAttachmentService$// TODO: PLT-147: The attachment should be randomised to prevent brute force guessing and thus privacy leaks. private fun import(jar: InputStream, uploader: String?, filename: String?): AttachmentId - LongMethod:NodeAttachmentService.kt$NodeAttachmentService.Companion$// Just iterate over the entries with verification enabled: should be good enough to catch mistakes. // Note that JarInputStream won't throw any kind of error at all if the file stream is in fact not // a ZIP! It'll just pretend it's an empty archive, which is kind of stupid but that's how it works. // So we have to check to ensure we found at least one item. // // For signed Jars add additional checks to close security holes left by the default jarSigner verifier: // - All entries listed in the Manifest are in the JAR file. // - No extra files in the JAR that were not listed in the Manifest. // Together with the check that all entries need to be signed by the same signers that is performed when the signers are read, // it should close any possibility of foul play. internal fun checkIsAValidJAR(stream: InputStream) - LongMethod:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `The strict JAR verification function fails signed JARs with removed or extra files that are valid according to the usual jarsigner`() - LongMethod:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `contract class, versioning and signing metadata can be used to search`() - LongMethod:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `corrupt entry throws exception`() - LongMethod:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `development mode - retrieve latest versions of signed contracts - multiple versions of same version id exist in store`() - LongMethod:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `missing is not cached`() - LongMethod:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `sorting and compound conditions work`() - LongMethod:NodeBasedTest.kt$NodeBasedTest$@JvmOverloads fun startNode(legalName: CordaX500Name, platformVersion: Int = PLATFORM_VERSION, rpcUsers: List<User> = emptyList(), configOverrides: Map<String, Any> = emptyMap(), flowManager: FlowManager = NodeFlowManager(FlowOverrideConfig())): NodeWithInfo - LongMethod:NodeConfigTest.kt$NodeConfigTest$@Test fun `reading node configuration`() - LongMethod:NodeConfigTest.kt$NodeConfigTest$@Test fun `reading webserver configuration`() - LongMethod:NodeConfigTest.kt$NodeConfigTest$private fun createConfig( legalName: CordaX500Name = CordaX500Name(organisation = "Unknown", locality = "Nowhere", country = "GB"), p2pPort: Int = -1, rpcPort: Int = -1, rpcAdminPort: Int = -1, webPort: Int = -1, h2port: Int = -1, notary: NotaryService?, users: List<User> = listOf(user("guest")), issuableCurrencies: List<String> = emptyList() ): NodeConfig - LongMethod:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$private fun testNodeConfiguration(): NodeConfigurationImpl - LongMethod:NodeController.kt$NodeController$ fun validate(nodeData: NodeData): NodeConfigWrapper? - LongMethod:NodeController.kt$NodeController$fun runCorda(pty: R3Pty, config: NodeConfigWrapper): Boolean - LongMethod:NodeControllerTest.kt$NodeControllerTest$private fun createConfig( organisation: String = "Unknown", p2pPort: Int = 0, rpcPort: Int = 0, rpcAdminPort: Int = 0, webPort: Int = 0, h2port: Int = 0, notary: NotaryService? = null, users: List<User> = listOf(user("guest")) ): NodeConfigWrapper - LongMethod:NodeCopier.kt$NodeCopier$fun copyBootstrapperFiles(nodeCacheDir: File) - LongMethod:NodeCopier.kt$NodeCopier$internal fun mergeConfigs(configInCacheDir: File, rpcSettings: ConfigValue, sshSettings: ConfigValue, mergeMode: Mode = Mode.NODE) - LongMethod:NodeInfoFilesCopier.kt$NodeInfoFilesCopier$private fun atomicCopy(source: Path, destination: Path) - LongMethod:NodeInfoWatcher.kt$NodeInfoWatcher$private fun pollDirectory(): List<NodeInfoUpdate> - LongMethod:NodeKeystoreCheckTest.kt$NodeKeystoreCheckTest$@Test fun `node should throw exception if cert path does not chain to the trust root`() - LongMethod:NodeMonitorModel.kt$NodeMonitorModel$ fun register(nodeHostAndPort: NetworkHostAndPort, username: String, password: String) - LongMethod:NodeMonitorModel.kt$NodeMonitorModel$private fun establishConnectionWithRetry(nodeHostAndPort: NetworkHostAndPort, username: String, password: String, shouldRetry: Boolean): CordaRPCConnection - LongMethod:NodeMonitorModel.kt$NodeMonitorModel$private fun performRpcReconnect(nodeHostAndPort: NetworkHostAndPort, username: String, password: String, shouldRetry: Boolean): List<StateMachineInfo> - LongMethod:NodeNamedCache.kt$DefaultNamedCacheFactory$open protected fun <K, V> configuredForNamed(caffeine: Caffeine<K, V>, name: String): Caffeine<K, V> - LongMethod:NodePerformanceTests.kt$NodePerformanceTests$@Test fun `empty flow per second`() - LongMethod:NodePerformanceTests.kt$NodePerformanceTests$@Test fun `self pay rate`() - LongMethod:NodeProcess.kt$NodeProcess.Factory$private fun waitForNode(process: Process, config: NodeConfig, client: CordaRPCClient) - LongMethod:NodeSchedulerService.kt$NodeSchedulerService$private fun getFlow(scheduledState: ScheduledStateRef): FlowLogic<*>? - LongMethod:NodeSchedulerService.kt$NodeSchedulerService$private fun runLoopFunction() - LongMethod:NodeSchedulerService.kt$NodeSchedulerService.Companion$ // We should try to make the Clock used in our code injectable (for tests etc) and to use the extension below // to wait in our code, rather than <code>Thread.sleep()</code> or other time-based pauses. @Suspendable @VisibleForTesting // We specify full classpath on SettableFuture to differentiate it from the Quasar class of the same name fun awaitWithDeadline(clock: CordaClock, deadline: Instant, future: Future<*> = GuavaSettableFuture.create<Any>()): Boolean - LongMethod:NodeSchedulerServiceTest.kt$NodeSchedulerPersistenceTest$@Ignore("Temporarily") @Test fun `test that if schedule is updated then the flow is invoked on the correct schedule`() - LongMethod:NodeSchedulerServiceTest.kt$NodeSchedulerPersistenceTest$@Test fun `test that schedule is persisted`() - LongMethod:NodeStartup.kt$NodeStartup$fun initialiseAndRun(cmdLineOptions: SharedNodeCmdLineOptions, afterNodeInitialisation: RunAfterNodeInitialisation, requireCertificates: Boolean = false): Int - LongMethod:NodeStartup.kt$NodeStartup$fun isNodeRunningAt(baseDirectory: Path): Boolean - LongMethod:NodeStartup.kt$NodeStartup$fun startNode(node: Node, startTime: Long) - LongMethod:NodeStartup.kt$NodeStartup$open fun drawBanner(versionInfo: VersionInfo) - LongMethod:NodeStartup.kt$NodeStartup$private fun lookupMachineNameAndMaybeWarn(): String - LongMethod:NodeStartup.kt$NodeStartup$protected open fun logStartupInfo(versionInfo: VersionInfo, conf: NodeConfiguration) - LongMethod:NodeStartup.kt$NodeStartupCli$override fun runProgram(): Int - LongMethod:NodeStartup.kt$fun CliWrapperBase.initLogging(baseDirectory: Path): Boolean - LongMethod:NodeStatePersistenceTests.kt$NodeStatePersistenceTests$@Test fun `persistent state survives node restart without reinitialising database schema`() - LongMethod:NodeStatePersistenceTests.kt$NodeStatePersistenceTests$@Test fun `persistent state survives node restart`() - LongMethod:NodeTabView.kt$NodeTabView$private fun Pane.nearestCityField(): ComboBox<WorldMapLocation> - LongMethod:NodeTabView.kt$NodeTabView$private fun launchNode(config: NodeConfigWrapper) - LongMethod:NodeTerminalView.kt$NodeTerminalView$/* * We only want to run one web server for each node. * So disable the "launch" button when we have * launched the web server and only reenable it when * the web server has exited. */ private fun configureWebButton(config: NodeConfigWrapper) - LongMethod:NodeTerminalView.kt$NodeTerminalView$@Suppress("DEPRECATION") private fun initialise(config: NodeConfigWrapper, ops: CordaRPCOps) - LongMethod:NodeTerminalView.kt$NodeTerminalView$fun open(config: NodeConfigWrapper, onExit: (Int) -> Unit) - LongMethod:NodeTest.kt$NodeTest$@Test fun `Node can start with multiple keypairs for its identity`() - LongMethod:NodeTest.kt$NodeTest$@Test fun `clear network map cache works`() - LongMethod:NodeTest.kt$NodeTest$private fun createConfig(nodeName: CordaX500Name): NodeConfigurationImpl - LongMethod:NodeVaultService.kt$NodeVaultService$ private fun bootstrapContractStateTypes() - LongMethod:NodeVaultService.kt$NodeVaultService$@Suspendable @Throws(StatesNotAvailableException::class) override fun <T : FungibleState<*>> tryLockFungibleStatesForSpending( lockId: UUID, eligibleStatesQuery: QueryCriteria, amount: Amount<*>, contractStateType: Class<out T> ): List<StateAndRef<T>> - LongMethod:NodeVaultService.kt$NodeVaultService$@Throws(StatesNotAvailableException::class) override fun softLockReserve(lockId: UUID, stateRefs: NonEmptySet<StateRef>) - LongMethod:NodeVaultService.kt$NodeVaultService$@Throws(VaultQueryException::class) private fun <T : ContractState> _queryBy(criteria: QueryCriteria, paging_: PageSpecification, sorting: Sort, contractStateType: Class<out T>, skipPagingChecks: Boolean): Vault.Page<T> - LongMethod:NodeVaultService.kt$NodeVaultService$fun makeUpdate(tx: WireTransaction): Vault.Update<ContractState>? - LongMethod:NodeVaultService.kt$NodeVaultService$fun resolveAndMakeUpdate(tx: CoreTransaction): Vault.Update<ContractState>? - LongMethod:NodeVaultService.kt$NodeVaultService$override fun softLockRelease(lockId: UUID, stateRefs: NonEmptySet<StateRef>?) - LongMethod:NodeVaultService.kt$NodeVaultService$private fun processAndNotify(updates: List<Vault.Update<ContractState>>) - LongMethod:NodeVaultService.kt$NodeVaultService$private fun recordUpdate(update: Vault.Update<ContractState>): Vault.Update<ContractState> - LongMethod:NodeVaultService.kt$NodeVaultService$private fun saveStates(session: Session, states: Map<StateRef, StateAndRef<ContractState>>) - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$// TODO: Unit test linear state relevancy checks @Test fun `correct updates are generated for general transactions`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test @Ignore fun `trackByCriteria filters updates and snapshots`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test fun `attempt to lock states already soft locked by me`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test fun `correct updates are generated when changing notaries`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test fun `fungible state selection test`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test fun `lock additional states to some already soft locked by me`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test fun `soft locking attempt concurrent reserve`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test fun `soft locking partial reserve states fails`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test fun `states soft locking query granularity`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test fun `states soft locking reserve and release`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test fun `unconsumedStatesForSpending from specific issuer party and refs`() - LongMethod:NodeVaultServiceTest.kt$NodeVaultServiceTest$@Test fun addNoteToTransaction() - LongMethod:NodeWebServer.kt$NodeWebServer$private fun buildServletContextHandler(localRpc: CordaRPCOps): ServletContextHandler - LongMethod:NodeWebServer.kt$NodeWebServer$private fun initWebServer(localRpc: CordaRPCOps): Server - LongMethod:NonValidatingNotaryFlow.kt$NonValidatingNotaryFlow$override fun verifyTransaction(requestPayload: NotarisationPayload) - LongMethod:NonValidatingNotaryServiceTests.kt$NonValidatingNotaryServiceTests$@Test fun `should re-sign a transaction with an expired time-window`() - LongMethod:NonValidatingNotaryServiceTests.kt$NonValidatingNotaryServiceTests$@Test fun `should report conflict when inputs are reused across transactions`() - LongMethod:NonValidatingNotaryServiceTests.kt$NonValidatingNotaryServiceTests$@Test fun `should sign identical transaction multiple times (notarisation is idempotent)`() - LongMethod:NotaryChangeTests.kt$NotaryChangeTests$@Test fun `should not break encumbrance links`() - LongMethod:NotaryCopier.kt$NotaryCopier$private fun copyNotaryBootstrapperFiles(nodeCacheDir: File) - LongMethod:NotaryServiceFlow.kt$NotaryServiceFlow$@Suspendable override fun call(): Void? - LongMethod:NotaryWhitelistTests.kt$NotaryWhitelistTests$ @Test fun `can't perform a regular transaction on a de-listed notary`() - LongMethod:NotaryWhitelistTests.kt$NotaryWhitelistTests$@Test fun `should reject transaction when a dependency does not contain notary in whitelist`() - LongMethod:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$// obtains the data and calculates the grid of results private fun calculate(runner: CalculationRunner) - LongMethod:OGSwapPricingExample.kt$SwapPricingExample$// Create a fixed vs libor 3m swap private fun createStub3mFixedVsLibor3mSwap(): Trade - LongMethod:OGSwapPricingExample.kt$SwapPricingExample$// Create an overnight averaged vs libor 3m swap with spread private fun createOvernightAveragedWithSpreadVsLibor3mSwap(): Trade - LongMethod:OGSwapPricingExample.kt$SwapPricingExample$// create a libor 3m vs libor 6m basis swap with spread private fun createBasisLibor3mVsLibor6mWithSpreadSwap(): Trade - LongMethod:OGSwapPricingExample.kt$SwapPricingExample$// obtains the data and calculates the grid of results private fun calculate(runner: CalculationRunner) - LongMethod:OGTrade.kt$OGTrade$override fun verify(tx: LedgerTransaction) - LongMethod:ObjectDiffer.kt$ObjectDiffer$fun diff(a: Any?, b: Any?): DiffTree? - LongMethod:ObjectSerializer.kt$EvolutionObjectSerializer.Companion$fun make(localTypeInformation: LocalTypeInformation.Composable, remoteTypeInformation: RemoteTypeInformation.Composable, constructor: LocalConstructorInformation, properties: Map<String, LocalPropertyInformation>, classLoader: ClassLoader, mustPreserveData: Boolean): EvolutionObjectSerializer - LongMethod:ObjectSerializer.kt$ObjectSerializer.Companion$private fun makeForComposable(typeInformation: LocalTypeInformation.Composable, typeNotation: CompositeType, typeDescriptor: Symbol, factory: LocalSerializerFactory): ComposableObjectSerializer - LongMethod:Obligation.kt$ fun <P : AbstractParty, T : Any> sumAmountsDue(balances: Map<Pair<P, P>, Amount<T>>): Map<P, Long> - LongMethod:Obligation.kt$Obligation$ @VisibleForTesting private fun verifySetLifecycleCommand(inputs: List<FungibleAsset<Terms<P>>>, outputs: List<FungibleAsset<Terms<P>>>, tx: LedgerTransaction, setLifecycleCommand: CommandWithParties<Commands.SetLifecycle>) - LongMethod:Obligation.kt$Obligation$override fun verify(tx: LedgerTransaction) - LongMethod:Obligation.kt$Obligation$private fun verifyNetCommand(tx: LedgerTransaction, command: CommandWithParties<NetCommand>) - LongMethod:Obligation.kt$Obligation$private fun verifySettleCommand(tx: LedgerTransaction, inputs: List<FungibleAsset<Terms<P>>>, outputs: List<FungibleAsset<Terms<P>>>, command: CommandWithParties<Commands.Settle<P>>, groupingKey: Issued<Terms<P>>) - LongMethod:ObligationTests.kt$ObligationTests$ @Test fun `generate set lifecycle`() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun `cash settlement`() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun `close-out netting`() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun `commodity settlement`() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun `exit single product obligation`() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun `issue debt`() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun `nettability of settlement contracts`() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun `payment default`() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun `payment netting`() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun multiIssuer() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun testMergeSplit() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun trivial() - LongMethod:ObligationTests.kt$ObligationTests$@Test fun trivialMismatches() - LongMethod:ObligationUtils.kt$ObligationUtils$ @JvmStatic fun <P : Any> generateSetLifecycle(tx: TransactionBuilder, statesAndRefs: List<StateAndRef<Obligation.State<P>>>, lifecycle: Obligation.Lifecycle, notary: Party) - LongMethod:ObligationUtils.kt$ObligationUtils$ @JvmStatic fun <P : Any> generateSettle(tx: TransactionBuilder, statesAndRefs: Iterable<StateAndRef<Obligation.State<P>>>, assetStatesAndRefs: Iterable<StateAndRef<FungibleAsset<P>>>, moveCommand: MoveCommand, notary: Party) - LongMethod:ObligationUtils.kt$ObligationUtils$@JvmStatic fun <P : Any> generatePaymentNetting(tx: TransactionBuilder, issued: Issued<Obligation.Terms<P>>, notary: Party, vararg inputs: StateAndRef<Obligation.State<P>>) - LongMethod:ObservablesTests.kt$ObservablesTests$@Test fun `bufferUntilDatabaseCommit delays until transaction closed repeatable`() - LongMethod:ObservablesTests.kt$ObservablesTests$@Test fun `bufferUntilDatabaseCommit delays until transaction closed`() - LongMethod:ObservablesTests.kt$ObservablesTests$@Test fun `bufferUntilDatabaseCommit propagates error if transaction rolled back`() - LongMethod:ObservablesTests.kt$ObservablesTests$@Test fun `bufferUntilDatabaseCommit swallows if transaction rolled back`() - LongMethod:ObservablesTests.kt$ObservablesTests$@Test fun `check wrapping in db tx restarts if we pass through zero subscribers`() - LongMethod:ObservablesTests.kt$ObservablesTests$@Test fun `combine tee and bufferUntilDatabaseCommit`() - LongMethod:ObservablesTests.kt$ObservablesTests$@Test fun `new transaction open in observer when wrapped`() - LongMethod:ObservablesTests.kt$ObservablesTests$@Test fun `tee correctly copies observations to multiple observers`() - LongMethod:OnLedgerAsset.kt$OnLedgerAsset.Companion$ @Throws(InsufficientBalanceException::class) @JvmStatic fun <S : FungibleAsset<T>, T : Any> generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, assetStates: List<StateAndRef<S>>, payChangeTo: AbstractParty, deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>, generateMoveCommand: () -> CommandData, generateExitCommand: (Amount<Issued<T>>) -> CommandData): Set<PublicKey> - LongMethod:OnLedgerAsset.kt$OnLedgerAsset.Companion$ @Throws(InsufficientBalanceException::class) @JvmStatic fun <S : FungibleAsset<T>, T : Any> generateSpend(tx: TransactionBuilder, payments: List<PartyAndAmount<T>>, acceptableStates: List<StateAndRef<S>>, payChangeTo: AbstractParty, deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>, generateMoveCommand: () -> CommandData): Pair<TransactionBuilder, List<PublicKey>> - LongMethod:P2PFlowsDrainingModeTest.kt$P2PFlowsDrainingModeTest$@Test fun `flows draining mode suspends consumption of initial session messages`() - LongMethod:P2PMessagingClient.kt$P2PMessagingClient$ fun run() - LongMethod:P2PMessagingClient.kt$P2PMessagingClient$ fun start(myIdentity: PublicKey, serviceIdentity: PublicKey?, maxMessageSize: Int, advertisedAddress: NetworkHostAndPort = serverAddress) - LongMethod:P2PMessagingClient.kt$P2PMessagingClient$ fun stop() - LongMethod:P2PMessagingClient.kt$P2PMessagingClient$private fun InnerState.registerBridgeControl(session: ClientSession, inboxes: List<String>) - LongMethod:ParametersUtilities.kt$@JvmOverloads fun testNetworkParameters( notaries: List<NotaryInfo> = emptyList(), minimumPlatformVersion: Int = 1, modifiedTime: Instant = Instant.now(), maxMessageSize: Int = 10485760, // TODO: Make this configurable and consistence across driver, bootstrapper, demobench and NetworkMapServer maxTransactionSize: Int = maxMessageSize * 50, whitelistedContractImplementations: Map<String, List<AttachmentId>> = emptyMap(), epoch: Int = 1, eventHorizon: Duration = 30.days, packageOwnership: Map<String, PublicKey> = emptyMap() ): NetworkParameters - LongMethod:PartialMerkleTree.kt$PartialMerkleTree.Companion$ private fun buildPartialTree( root: MerkleTree, includeHashes: List<SecureHash>, usedHashes: MutableList<SecureHash> ): Pair<Boolean, PartialTree> - LongMethod:PartialMerkleTreeTest.kt$PartialMerkleTreeTest$@Before fun init() - LongMethod:PartialMerkleTreeTest.kt$PartialMerkleTreeTest$@Test fun `Find leaf index`() - LongMethod:PartyAndCertificate.kt$PartyAndCertificate$ fun verify(trustAnchor: TrustAnchor): PKIXCertPathValidatorResult - LongMethod:PersistentIdentityServiceTests.kt$PersistentIdentityServiceTests$ @Test fun `assert ownership`() - LongMethod:PersistentNetworkMapCache.kt$PersistentNetworkMapCache$override fun addNode(node: NodeInfo) - LongMethod:PersistentScheduledFlowRepositoryTest.kt$PersistentScheduledFlowRepositoryTest$@Test fun `test that item is rescheduled`() - LongMethod:PersistentStateServiceTests.kt$PersistentStateServiceTests$@Test fun `test child objects are persisted`() - LongMethod:PersistentUniquenessProvider.kt$PersistentUniquenessProvider$private fun commitOne( states: List<StateRef>, txId: SecureHash, callerIdentity: Party, requestSignature: NotarisationRequestSignature, timeWindow: TimeWindow?, references: List<StateRef> ) - LongMethod:PersistentUniquenessProvider.kt$PersistentUniquenessProvider.Companion$fun createMap(cacheFactory: NamedCacheFactory): AppendOnlyPersistentMap<StateRef, SecureHash, CommittedState, PersistentStateRef> - LongMethod:PortfolioApi.kt$PortfolioApi$ @GET @Path("{party}/portfolio/history/aggregated") @Produces(MediaType.APPLICATION_JSON) fun getPartyPortfolioHistoryAggregated(@PathParam("party") partyName: String): Response - LongMethod:PortfolioApi.kt$PortfolioApi$ @GET @Path("{party}/trades") @Produces(MediaType.APPLICATION_JSON) fun getPartyTrades(@PathParam("party") partyName: String): Response - LongMethod:PortfolioApiUtils.kt$PortfolioApiUtils$fun createTradeView(rpc: CordaRPCOps, state: IRSState): TradeView - LongMethod:PortfolioApiUtils.kt$PortfolioApiUtils$fun createValuations(state: PortfolioState, portfolio: Portfolio): ValuationsView - LongMethod:PortfolioSwap.kt$PortfolioSwap$override fun verify(tx: LedgerTransaction) - LongMethod:PostgreSQLService.kt$PostgreSQLService$override fun verify(): Boolean - LongMethod:PrettyPrint.kt$PrettyPrint$fun prettyPrint(arr: Arrangement) - LongMethod:PrettyPrint.kt$PrettyPrint$fun prettyPrintBigDecimal(per: Perceivable<BigDecimal>) - LongMethod:PrettyPrint.kt$PrettyPrint$fun prettyPrintBoolean(per: Perceivable<Boolean>) - LongMethod:ProcessUtilities.kt$ProcessUtilities$fun startJavaProcess( className: String, arguments: List<String>, classPath: List<String> = defaultClassPath, workingDirectory: Path? = null, jdwpPort: Int? = null, extraJvmArguments: List<String> = emptyList(), maximumHeapSize: String? = null ): Process - LongMethod:ProfileController.kt$ProfileController$ @Throws(IOException::class) fun openProfile(): List<InstallConfig>? - LongMethod:ProfileController.kt$ProfileController$ @Throws(IOException::class) fun saveProfile(): Boolean - LongMethod:ProgressTrackerTest.kt$ProgressTrackerTest$@Test fun `steps tree index counts children steps`() - LongMethod:ProgressTrackerTest.kt$ProgressTrackerTest$@Test fun `steps tree index counts two levels of children steps`() - LongMethod:ProgressTrackerTest.kt$ProgressTrackerTest$@Test fun `structure changes are pushed down when progress trackers are added`() - LongMethod:ProgressTrackerTest.kt$ProgressTrackerTest$@Test fun `structure changes are pushed down when progress trackers are removed`() - LongMethod:PropertyDescriptor.kt$PropertyDescriptor$ fun validate() - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$@Test fun `Client Failover for multiple IP`() - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$@Test fun `Message sent from AMQP to non-existent Artemis inbox is rejected and client disconnects`() - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$@Test fun `Send a message from AMQP to Artemis inbox`() - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$@Test fun `Send a message larger then maxMessageSize from AMQP to Artemis inbox`() - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$@Test fun `Simple AMPQ Client to Server`() - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$@Test fun `Test AMQP Client with invalid root certificate`() - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$@Test fun `shared AMQPClient threadpool tests`() - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$private fun createArtemisServerAndClient(maxMessageSize: Int = MAX_MESSAGE_SIZE): Pair<ArtemisMessagingServer, ArtemisMessagingClient> - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$private fun createClient(maxMessageSize: Int = MAX_MESSAGE_SIZE): AMQPClient - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$private fun createServer(port: Int, name: CordaX500Name = ALICE_NAME, maxMessageSize: Int = MAX_MESSAGE_SIZE, crlCheckSoftFail: Boolean = true): AMQPServer - LongMethod:ProtonWrapperTests.kt$ProtonWrapperTests$private fun createSharedThreadsClient(sharedEventGroup: EventLoopGroup, id: Int, maxMessageSize: Int = MAX_MESSAGE_SIZE): AMQPClient - LongMethod:QuasarInstrumentationHook.kt$ fun recordUsedInstrumentedCallStack() - LongMethod:QuasarInstrumentationHook.kt$PackageTree$ fun toGlobs(excludeTree: PackageTree): List<Glob> - LongMethod:QuasarInstrumentationHook.kt$QuasarInstrumentationHook$override fun transform( loader: ClassLoader?, className: String, classBeingRedefined: Class<*>?, protectionDomain: ProtectionDomain?, classfileBuffer: ByteArray ): ByteArray - LongMethod:QuasarInstrumentationHook.kt$QuasarInstrumentationHookAgent.Companion$@JvmStatic fun premain(argumentsString: String?, instrumentation: Instrumentation) - LongMethod:QueryCriteria.kt$QueryCriteria.FungibleAssetQueryCriteria$fun copy( participants: List<AbstractParty>? = this.participants, owner: List<AbstractParty>? = this.owner, quantity: ColumnPredicate<Long>? = this.quantity, issuer: List<AbstractParty>? = this.issuer, issuerRef: List<OpaqueBytes>? = this.issuerRef, status: Vault.StateStatus = this.status, contractStateTypes: Set<Class<out ContractState>>? = this.contractStateTypes ): FungibleAssetQueryCriteria - LongMethod:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$fun copy( status: Vault.StateStatus = this.status, contractStateTypes: Set<Class<out ContractState>>? = this.contractStateTypes, stateRefs: List<StateRef>? = this.stateRefs, notary: List<AbstractParty>? = this.notary, softLockingCondition: SoftLockingCondition? = this.softLockingCondition, timeCondition: TimeCondition? = this.timeCondition ): VaultQueryCriteria - LongMethod:RPCApi.kt$RPCApi.ClientToServer.Companion$fun fromClientMessage(message: ClientMessage): ClientToServer - LongMethod:RPCApi.kt$RPCApi.ServerToClient.Companion$fun fromClientMessage(context: SerializationContext, message: ClientMessage): ServerToClient - LongMethod:RPCClient.kt$RPCClient$fun start( rpcOpsClass: Class<I>, username: String, password: String, externalTrace: Trace? = null, impersonatedActor: Actor? = null, targetLegalIdentity: CordaX500Name? = null ): RPCConnection<I> - LongMethod:RPCClientProxyHandler.kt$RPCClientProxyHandler$ fun start() - LongMethod:RPCClientProxyHandler.kt$RPCClientProxyHandler$// The handler for Artemis messages. private fun artemisMessageHandler(message: ClientMessage) - LongMethod:RPCClientProxyHandler.kt$RPCClientProxyHandler$// This is the general function that transforms a client side RPC to internal Artemis messages. override fun invoke(proxy: Any, method: Method, arguments: Array<out Any?>?): Any? - LongMethod:RPCClientProxyHandler.kt$RPCClientProxyHandler$private fun attemptReconnect() - LongMethod:RPCClientProxyHandler.kt$RPCClientProxyHandler$private fun cleanUpOnConnectionLoss() - LongMethod:RPCDriver.kt$RPCDriverDSL$fun <I : RPCOps> startRpcServerWithBrokerRunning( rpcUser: User = rpcTestUser, nodeLegalName: CordaX500Name = fakeNodeLegalName, configuration: RPCServerConfiguration = RPCServerConfiguration.DEFAULT, ops: I, brokerHandle: RpcBrokerHandle, queueDrainTimeout: Duration = 5.seconds ): RpcServerHandle - LongMethod:RPCDriver.kt$RPCDriverDSL$fun startRpcBroker( serverName: String = "driver-rpc-server-${random63BitValue()}", rpcUser: User = rpcTestUser, maxFileSize: Int = MAX_MESSAGE_SIZE, maxBufferedBytesPerClient: Long = 10L * MAX_MESSAGE_SIZE, customPort: NetworkHostAndPort? = null ): CordaFuture<RpcBrokerHandle> - LongMethod:RPCDriver.kt$RPCDriverDSL$private fun startInVmRpcBroker( rpcUser: User = rpcTestUser, maxFileSize: Int = MAX_MESSAGE_SIZE, maxBufferedBytesPerClient: Long = 10L * MAX_MESSAGE_SIZE ): CordaFuture<RpcBrokerHandle> - LongMethod:RPCDriver.kt$RPCDriverDSL.Companion$private fun ConfigurationImpl.configureCommonSettings(maxFileSize: Int, maxBufferedBytesPerClient: Long) - LongMethod:RPCDriver.kt$RandomRpcUser.Companion$@JvmStatic fun main(args: Array<String>) - LongMethod:RPCDriver.kt$fun <A> rpcDriver( isDebug: Boolean = false, driverDirectory: Path = Paths.get("build") / "rpc-driver" / getTimestampAsDirectoryName(), portAllocation: PortAllocation = globalPortAllocation, debugPortAllocation: PortAllocation = globalDebugPortAllocation, systemProperties: Map<String, String> = emptyMap(), useTestClock: Boolean = false, startNodesInProcess: Boolean = false, waitForNodesToFinish: Boolean = false, extraCordappPackagesToScan: List<String> = emptyList(), notarySpecs: List<NotarySpec> = emptyList(), externalTrace: Trace? = null, @Suppress("DEPRECATION") jmxPolicy: JmxPolicy = JmxPolicy(), networkParameters: NetworkParameters = testNetworkParameters(), notaryCustomOverrides: Map<String, Any?> = emptyMap(), inMemoryDB: Boolean = true, cordappsForAllNodes: Collection<TestCordappInternal>? = null, dsl: RPCDriverDSL.() -> A ): A - LongMethod:RPCPerformanceTests.kt$RPCPerformanceTests$ @Test fun `consumption rate`() - LongMethod:RPCPerformanceTests.kt$RPCPerformanceTests$@Test fun `big messages`() - LongMethod:RPCPerformanceTests.kt$RPCPerformanceTests$@Test fun `measure Megabytes per second for simple RPCs`() - LongMethod:RPCSecurityManagerImpl.kt$RPCPermissionResolver$override fun resolvePermission(representation: String): Permission - LongMethod:RPCSecurityManagerImpl.kt$RPCSecurityManagerImpl.Companion$// Build internal Shiro securityManager instance private fun buildImpl(config: AuthServiceConfig, cacheFactory: NamedCacheFactory): DefaultSecurityManager - LongMethod:RPCSecurityManagerTest.kt$RPCSecurityManagerTest$private fun checkUserActions(permissions: Set<String>, permitted: Set<List<String>>) - LongMethod:RPCServer.kt$RPCServer$fun start(activeMqServerControl: ActiveMQServerControl) - LongMethod:RPCServer.kt$RPCServer$private fun clientArtemisMessageHandler(artemisMessage: ClientMessage) - LongMethod:RPCStabilityTests.kt$RPCStabilityTests$ @Test fun `server cleans up queues after disconnected clients`() - LongMethod:RPCStabilityTests.kt$RPCStabilityTests$@Test fun `3 server failover`() - LongMethod:RPCStabilityTests.kt$RPCStabilityTests$@Test fun `client cleans up leaked observables`() - LongMethod:RPCStabilityTests.kt$RPCStabilityTests$@Test fun `client reconnects to rebooted server`() - LongMethod:RPCStabilityTests.kt$RPCStabilityTests$@Test fun `connection failover fails, rpc calls throw`() - LongMethod:RPCStabilityTests.kt$RPCStabilityTests$@Test fun `deduplication in the client`() - LongMethod:RPCStabilityTests.kt$RPCStabilityTests$@Test fun `deduplication in the server`() - LongMethod:RPCStabilityTests.kt$RPCStabilityTests$@Test fun `observables error when connection breaks`() - LongMethod:RPCStabilityTests.kt$RPCStabilityTests$@Test fun `slow consumers are kicked`() - LongMethod:RaftNotaryServiceTests.kt$RaftNotaryServiceTests$@Test fun `detect double spend`() - LongMethod:RaftTransactionCommitLog.kt$RaftTransactionCommitLog$ fun commitTransaction(raftCommit: Commit<Commands.CommitTransaction>): NotaryError? - LongMethod:RaftTransactionCommitLog.kt$RaftTransactionCommitLog$ override fun install(reader: SnapshotReader) - LongMethod:RaftTransactionCommitLogTests.kt$RaftTransactionCommitLogTests$@Test fun `transactions can be re-notarised outside their time window`() - LongMethod:RaftTransactionCommitLogTests.kt$RaftTransactionCommitLogTests$private fun createReplica(myAddress: NetworkHostAndPort, clusterAddress: NetworkHostAndPort? = null): CompletableFuture<Member> - LongMethod:RaftUniquenessProvider.kt$RaftUniquenessProvider$fun start() - LongMethod:RaftUniquenessProvider.kt$RaftUniquenessProvider$override fun commit( states: List<StateRef>, txId: SecureHash, callerIdentity: Party, requestSignature: NotarisationRequestSignature, timeWindow: TimeWindow?, references: List<StateRef> ): CordaFuture<UniquenessProvider.Result> - LongMethod:RaftUniquenessProvider.kt$RaftUniquenessProvider.Companion$fun createMap(cacheFactory: NamedCacheFactory): AppendOnlyPersistentMap<StateRef, Pair<Long, SecureHash>, CommittedState, String> - LongMethod:ReceiveFinalityFlowTest.kt$ReceiveFinalityFlowTest$@Test fun `sent to flow hospital on error and retry on node restart`() - LongMethod:ReceiveTransactionFlow.kt$ReceiveTransactionFlow$@Suppress("KDocMissingDocumentation") @Suspendable @Throws(SignatureException::class, AttachmentResolutionException::class, TransactionResolutionException::class, TransactionVerificationException::class) override fun call(): SignedTransaction - LongMethod:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.ErrorInterceptingHandler$override fun invoke(proxy: Any, method: Method, args: Array<out Any>?): Any? - LongMethod:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.ReconnectingObservableImpl$private fun _subscribeWithReconnect(observerHandle: ObserverHandle, onNext: (T) -> Unit, onStop: () -> Unit, onDisconnect: () -> Unit, onReconnect: () -> Unit, startWithValues: Iterable<T>? = null) - LongMethod:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.ReconnectingRPCConnection$private tailrec fun establishConnectionWithRetry(retryInterval: Duration = 1.seconds, nrRetries: Int = 0): CordaRPCConnection - LongMethod:ReferenceInputStateTests.kt$ReferenceStateTests$@Test fun `Can't use old reference states`() - LongMethod:ReferenceInputStateTests.kt$ReferenceStateTests$@Test fun `create a reference state then refer to it multiple times`() - LongMethod:ReferenceInputStateTests.kt$ReferenceStateTests.ExampleContract$override fun verify(tx: LedgerTransaction) - LongMethod:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests$@Test fun `check old ref state is consumed when update used in tx with relevant states`() - LongMethod:RemoteSerializerFactory.kt$DefaultRemoteSerializerFactory$private fun getUncached( remoteTypeInformation: RemoteTypeInformation, localTypeInformation: LocalTypeInformation ): AMQPSerializer<Any> - LongMethod:ReplayedList.kt$ReplayedList$override fun sourceChanged(c: ListChangeListener.Change<out A>) - LongMethod:ReplayedListTest.kt$ReplayedListTest$@Test fun addWorks() - LongMethod:ResolveTransactionsFlow.kt$ResolveTransactionsFlow$@Suspendable // TODO use paging here (we literally get the entire dependencies graph in memory) private fun downloadDependencies(depsToCheck: Set<SecureHash>): List<SignedTransaction> - LongMethod:ResolveTransactionsFlow.kt$ResolveTransactionsFlow$@Suspendable @Throws(FetchDataFlow.HashNotFound::class, FetchDataFlow.IllegalTransactionRequest::class) override fun call() - LongMethod:ResolveTransactionsFlowTest.kt$ResolveTransactionsFlowTest$// DOCSTART 2 private fun makeTransactions(signFirstTX: Boolean = true, withAttachment: SecureHash? = null): Pair<SignedTransaction, SignedTransaction> - LongMethod:ResolveTransactionsFlowTest.kt$ResolveTransactionsFlowTest$@Test fun `triangle of transactions resolves fine`() - LongMethod:RetryFlowMockTest.kt$RetryFlowMockTest$@Test fun `Restart does not set senderUUID`() - LongMethod:RewriteClassMethods.kt$RewriteClassMethods$override fun emit(context: EmitterContext, instruction: Instruction) - LongMethod:RoundTripObservableSerializerTests.kt$RoundTripObservableSerializerTests$@Test fun roundTripTest1() - LongMethod:RoundTripTests.kt$RoundTripTests$@Test fun canSerializeClassesWithUntypedProperties() - LongMethod:RpcClientObservableDeSerializer.kt$RpcClientObservableDeSerializer$ override fun readObject(obj: Any, schemas: SerializationSchemas, input: DeserializationInput, context: SerializationContext ): Observable<*> - LongMethod:RpcExceptionHandlingTest.kt$RpcExceptionHandlingTest$@Test fun `FlowException is received by the RPC client only if in devMode`() LongMethod:RpcReconnectTests.kt$RpcReconnectTests$ @Test fun `test that the RPC client is able to reconnect and proceed after node failure, restart, or connection reset`() - LongMethod:RpcServerObservableSerializer.kt$RpcServerObservableSerializer$override fun writeDescribedObject( obj: Observable<*>, data: Data, type: Type, output: SerializationOutput, context: SerializationContext ) - LongMethod:RpcSslTest.kt$RpcSslTest$@Test fun `RPC client using ssl is able to run a command`() - LongMethod:RpcSslTest.kt$RpcSslTest$@Test fun `RPC client using ssl will fail if connecting to a node that cannot present a matching certificate`() - LongMethod:RpcSslTest.kt$RpcSslTest$@Test fun `The system RPC user can not connect to the rpc broker without the node's key`() - LongMethod:SSHClient.kt$SSHClient$fun readLine(): String? - LongMethod:SSHClient.kt$SSHClient.Companion$fun connect( port: Int, password: String, hostname: String = "localhost", username: String = "corda", timeout: Duration = Duration.ofSeconds(4) ): SSHClient - LongMethod:SSHServerTest.kt$SSHServerTest$@Ignore @Test fun `ssh runs flows`() - LongMethod:SSHServerTest.kt$SSHServerTest$@Test fun `ssh respects permissions`() - LongMethod:SSLHelper.kt$LoggingTrustManagerWrapper$private fun certPathToString(certPath: Array<out X509Certificate>?): String - LongMethod:SSLHelper.kt$internal fun createClientSslHelper(target: NetworkHostAndPort, expectedRemoteLegalNames: Set<CordaX500Name>, keyManagerFactory: KeyManagerFactory, trustManagerFactory: TrustManagerFactory): SslHandler - LongMethod:SandboxClassLoader.kt$SandboxClassLoader$ @Throws(ClassNotFoundException::class) override fun loadClass(name: String, resolve: Boolean): Class<*> - LongMethod:SandboxClassLoader.kt$SandboxClassLoader$ private fun loadClassAndBytes(request: ClassSource, context: AnalysisContext): LoadedClass - LongMethod:SandboxClassWriter.kt$SandboxClassWriter$ override fun getCommonSuperClass(type1: String, type2: String): String - LongMethod:SandboxExecutor.kt$SandboxExecutor$ @Throws(Exception::class) open fun run( runnableClass: ClassSource, input: TInput ): ExecutionSummaryWithResult<TOutput> - LongMethod:SandboxExecutor.kt$SandboxExecutor$ private fun validate( context: AnalysisContext, classLoader: SandboxClassLoader, classSources: List<ClassSource> ): ReferenceValidationSummary - LongMethod:SandboxExecutorTest.kt$SandboxExecutorTest.TestCatchThrowableErrorsAndThreadDeath$override fun apply(input: Int): Int - LongMethod:SandboxExecutorTest.kt$SandboxExecutorTest.TestMonitors$override fun apply(input: Int): String? - LongMethod:ScenarioRunner.kt$fun main(args: Array<out String>) - LongMethod:ScheduledFlowIntegrationTests.kt$ScheduledFlowIntegrationTests$@Test fun `test that when states are being spent at the same time that schedules trigger everything is processed`() - LongMethod:ScheduledFlowTests.kt$ScheduledFlowTests$@Test fun `create and run scheduled flow then wait for result`() - LongMethod:ScheduledFlowTests.kt$ScheduledFlowTests$@Test fun `run a whole batch of scheduled flows`() - LongMethod:ScheduledFlowsDrainingModeTest.kt$ScheduledFlowsDrainingModeTest$@Test fun `flows draining mode ignores scheduled flows until unset`() - LongMethod:SchemaMigration.kt$SchemaMigration$ private fun migrateOlderDatabaseToUseLiquibase(existingCheckpoints: Boolean): Boolean - LongMethod:SchemaMigration.kt$SchemaMigration$private fun doRunMigration(run: Boolean, check: Boolean, existingCheckpoints: Boolean? = null) - LongMethod:SchemaTest.kt$SchemaTest$@Test fun describe_with_nested_properties_does_not_show_sensitive_values() - LongMethod:SchemaTest.kt$SchemaTest$@Test fun describe_with_nested_properties_list_does_not_show_sensitive_values() - LongMethod:SchemaTest.kt$SchemaTest$@Test fun validation_with_nested_properties() - LongMethod:SchemaTest.kt$SchemaTest$@Test fun validation_with_unknown_properties() - LongMethod:SchemaTest.kt$SchemaTest$@Test fun validation_with_wrong_nested_properties() - LongMethod:SendTransactionFlow.kt$DataVendingFlow$@Suspendable override fun call(): Void? - LongMethod:SerializationOutput.kt$SerializationOutput$internal fun <T : Any> _serialize(obj: T, context: SerializationContext): SerializedBytes<T> - LongMethod:SerializationOutputTests.kt$SerializationOutputTests$@Test fun `class constructor is invoked on deserialisation`() - LongMethod:SerializationOutputTests.kt$SerializationOutputTests$@Test fun `test complex throwables serialize`() - LongMethod:SerializationOutputTests.kt$SerializationOutputTests$@Test fun `test suppressed throwables serialize`() - LongMethod:SerializationOutputTests.kt$SerializationOutputTests$@Test fun `test transaction state`() - LongMethod:SerializationOutputTests.kt$SerializationOutputTests$@Test fun isPrimitive() - LongMethod:SerializationOutputTests.kt$SerializationOutputTests$private inline fun <reified T : Any> serdes(obj: T, factory: SerializerFactory = defaultFactory(), freshDeserializationFactory: SerializerFactory = defaultFactory(), expectedEqual: Boolean = true, expectDeserializedEqual: Boolean = true): T - LongMethod:SerializationPropertyOrdering.kt$SerializationPropertyOrdering$@Suppress("UNCHECKED_CAST") @Test fun randomOrderSetter() - LongMethod:SerializationPropertyOrdering.kt$SerializationPropertyOrdering$@Test fun randomOrder() - LongMethod:SerializerFactoryBuilder.kt$SerializerFactoryBuilder$@JvmStatic @DeleteForDJVM fun build( whitelist: ClassWhitelist, carpenterClassLoader: ClassLoader, lenientCarpenterEnabled: Boolean = false, descriptorBasedSerializerRegistry: DescriptorBasedSerializerRegistry = DefaultDescriptorBasedSerializerRegistry(), allowEvolution: Boolean = true, overrideFingerPrinter: FingerPrinter? = null, onlyCustomSerializers: Boolean = false, mustPreserveDataWhenEvolving: Boolean = false): SerializerFactory - LongMethod:SerializerFactoryBuilder.kt$SerializerFactoryBuilder$@JvmStatic @DeleteForDJVM fun build( whitelist: ClassWhitelist, classCarpenter: ClassCarpenter, descriptorBasedSerializerRegistry: DescriptorBasedSerializerRegistry = DefaultDescriptorBasedSerializerRegistry(), allowEvolution: Boolean = true, overrideFingerPrinter: FingerPrinter? = null, onlyCustomSerializers: Boolean = false, mustPreserveDataWhenEvolving: Boolean = false): SerializerFactory - LongMethod:SerializerFactoryBuilder.kt$SerializerFactoryBuilder$private fun makeFactory(whitelist: ClassWhitelist, classCarpenter: ClassCarpenter, descriptorBasedSerializerRegistry: DescriptorBasedSerializerRegistry, allowEvolution: Boolean, overrideFingerPrinter: FingerPrinter?, onlyCustomSerializers: Boolean, mustPreserveDataWhenEvolving: Boolean): SerializerFactory - LongMethod:Service.kt$Service$fun start(): Boolean - LongMethod:ServiceHubConcurrentUsageTest.kt$ServiceHubConcurrentUsageTest$@Test fun `operations requiring a transaction work from another thread`() - LongMethod:ServicesForResolutionImpl.kt$ServicesForResolutionImpl$// We may need to recursively chase transactions if there are notary changes. fun inner(stateRef: StateRef, forContractClassName: String?): Attachment - LongMethod:SettingsModelTest.kt$SettingsModelTest$@Test fun `test save config and rollback`() - LongMethod:ShowCommand.kt$ShowCommand$override fun processClasses(classes: List<Class<*>>) - LongMethod:ShutdownManager.kt$ShutdownManager$fun shutdown() - LongMethod:SignatureConstraintVersioningTests.kt$SignatureConstraintVersioningTests$@Test fun `can evolve from lower contract class version to higher one`() - LongMethod:SignedNodeInfo.kt$SignedNodeInfo$// TODO Add root cert param (or TrustAnchor) to make sure all the identities belong to the same root fun verified(): NodeInfo - LongMethod:SignedNodeInfoTest.kt$SignedNodeInfoTest$private fun createNodeInfoWithSingleIdentity(name: CordaX500Name, nodeKeyPair: KeyPair, identityCertPublicKey: PublicKey): NodeInfo - LongMethod:SignedTransaction.kt$SignedTransaction$// TODO: Verify contract constraints here as well as in LedgerTransaction to ensure that anything being deserialised // from the attachment is trusted. This will require some partial serialisation work to not load the ContractState // objects from the TransactionState. @DeleteForDJVM private fun verifyRegularTransaction(services: ServiceHub, checkSufficientSignatures: Boolean) - LongMethod:SimmFlow.kt$SimmFlow.Receiver$ @Suspendable private fun agreeValuation(portfolio: Portfolio, asOf: LocalDate, valuer: Party): PortfolioValuation - LongMethod:SimmFlow.kt$SimmFlow.Requester$@Suspendable private fun agreeValuation(portfolio: Portfolio, asOf: LocalDate, valuer: Party): PortfolioValuation - LongMethod:SimmValuationTest.kt$SimmValuationTest$@Test fun `runs SIMM valuation demo`() - LongMethod:SinglePartyNotaryService.kt$SinglePartyNotaryService$ @Suspendable open fun commitInputStates( inputs: List<StateRef>, txId: SecureHash, caller: Party, requestSignature: NotarisationRequestSignature, timeWindow: TimeWindow?, references: List<StateRef> ) - LongMethod:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$// The flow's event queue may be non-empty in case it shut down abruptly. We handle outstanding events here. private fun drainFlowEventQueue(flow: Flow) - LongMethod:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$override fun killFlow(id: StateMachineRunId): Boolean - LongMethod:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$override fun retryFlowFromSafePoint(currentState: StateMachineState) - LongMethod:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$override fun start(tokenizableServices: List<Any>) - LongMethod:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$private fun <A> startFlowInternal( invocationContext: InvocationContext, flowLogic: FlowLogic<A>, flowStart: FlowStart, ourIdentity: Party, deduplicationHandler: DeduplicationHandler?, isStartIdempotent: Boolean ): CordaFuture<FlowStateMachine<A>> - LongMethod:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$private fun addAndStartFlow(id: StateMachineRunId, flow: Flow) - LongMethod:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$private fun createFlowFromCheckpoint( id: StateMachineRunId, checkpoint: Checkpoint, isAnyCheckpointPersisted: Boolean, isStartIdempotent: Boolean, initialDeduplicationHandler: DeduplicationHandler? ): Flow - LongMethod:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$private fun onExistingSessionMessage(sessionMessage: ExistingSessionMessage, deduplicationHandler: DeduplicationHandler, sender: Party) - LongMethod:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$private fun onSessionInit(sessionMessage: InitialSessionMessage, sender: Party, event: ExternalEvent.ExternalMessageEvent) - LongMethod:SourceLocation.kt$SourceLocation$ fun format(): String - LongMethod:StabilityTest.kt$StabilityTest$fun crossCashTest(replication: Int) - LongMethod:StabilityTest.kt$StabilityTest$fun selfIssueTest(replication: Int) - LongMethod:StaffedFlowHospital.kt$StaffedFlowHospital$ fun flowErrored(flowFiber: FlowFiber, currentState: StateMachineState, errors: List<Throwable>) - LongMethod:StaffedFlowHospital.kt$StaffedFlowHospital$ fun sessionInitErrored(sessionMessage: InitialSessionMessage, sender: Party, event: ExternalEvent.ExternalMessageEvent, error: Throwable) - LongMethod:StandaloneShell.kt$StandaloneShell$override fun runProgram(): Int - LongMethod:StandaloneShellArgsParserTest.kt$StandaloneShellArgsParserTest$@Test fun args_to_config() - LongMethod:StandaloneShellArgsParserTest.kt$StandaloneShellArgsParserTest$@Test fun cmd_options_override_config_from_file() - LongMethod:StandaloneShellArgsParserTest.kt$StandaloneShellArgsParserTest$@Test fun cmd_options_to_config_from_file() - LongMethod:StartedFlowTransition.kt$StartedFlowTransition$override fun transition(): TransitionResult - LongMethod:StartedFlowTransition.kt$StartedFlowTransition$private fun TransitionBuilder.sendInitialSessionMessagesIfNeeded(sourceSessions: Set<SessionId>) - LongMethod:StartedFlowTransition.kt$StartedFlowTransition$private fun TransitionBuilder.sendToSessionsTransition(sourceSessionIdToMessage: Map<SessionId, SerializedBytes<Any>>) - LongMethod:StartedFlowTransition.kt$StartedFlowTransition$private fun collectEndedEmptySessionErrors(sessionIds: Collection<SessionId>, checkpoint: Checkpoint): List<Throwable> - LongMethod:StartedFlowTransition.kt$StartedFlowTransition$private fun collectRelevantErrorsToThrow(flowIORequest: FlowIORequest<*>, checkpoint: Checkpoint): List<Throwable> - LongMethod:StartedFlowTransition.kt$StartedFlowTransition$private fun pollSessionMessages(sessions: SessionMap, sessionIds: Set<SessionId>): PollResult? - LongMethod:StartedFlowTransition.kt$StartedFlowTransition$private fun sendAndReceiveTransition(flowIORequest: FlowIORequest.SendAndReceive): TransitionResult - LongMethod:StartupSteps.kt$StartupSteps$override fun initialize(state: ScenarioState) - LongMethod:StateMachineState.kt$Checkpoint.Companion$fun create( invocationContext: InvocationContext, flowStart: FlowStart, flowLogicClass: Class<FlowLogic<*>>, frozenFlowLogic: SerializedBytes<FlowLogic<*>>, ourIdentity: Party, subFlowVersion: SubFlowVersion, isEnabledTimedFlow: Boolean ): Try<Checkpoint> - LongMethod:StatusTransitions.kt$StatusTransitions$ fun verify(tx: LedgerTransaction) - LongMethod:StatusTransitionsTest.kt$StatusTransitionsTest$@Test fun `basic correct cases`() - LongMethod:StatusTransitionsTest.kt$StatusTransitionsTest$@Test fun `role change signer correct`() - LongMethod:StringToMethodCallParser.kt$StringToMethodCallParser$ @Throws(UnparseableCallException::class) fun parse(target: T?, command: String): ParsedMethodCall - LongMethod:StringToMethodCallParser.kt$StringToMethodCallParser$ @Throws(UnparseableCallException::class) fun parseArguments(methodNameHint: String, parameters: List<Pair<String, Type>>, args: String): Array<Any?> - LongMethod:StructuresTests.kt$AttachmentTest$@Test fun `openAsJAR does not leak file handle if attachment has corrupted manifest`() - LongMethod:SwapDataView.kt$fun SwapData.toView(viewingParty: Party, portfolio: Portfolio? = null, presentValue: MultiCurrencyAmount? = null, IM: InitialMarginTriple? = null): SwapDataView - LongMethod:SwapExample.kt$SwapExample$fun main(@Suppress("UNUSED_PARAMETER") args: Array<String>) - LongMethod:SwapExample.kt$SwapExample$fun testingEqualitymain(@Suppress("UNUSED_PARAMETER") args: Array<String>) - LongMethod:SwapIdentitiesFlow.kt$SwapIdentitiesFlow$@Suspendable override fun call(): LinkedHashMap<Party, AnonymousParty> - LongMethod:SwapIdentitiesFlowTests.kt$SwapIdentitiesFlowTests$@Test fun `issue key`() - LongMethod:TLSAuthenticationTests.kt$TLSAuthenticationTests$private fun buildTLSFactories( rootCAScheme: SignatureScheme, intermediateCAScheme: SignatureScheme, client1CAScheme: SignatureScheme, client1TLSScheme: SignatureScheme, client2CAScheme: SignatureScheme, client2TLSScheme: SignatureScheme ): Pair<SSLServerSocketFactory, SSLSocketFactory> - LongMethod:TLSAuthenticationTests.kt$TLSAuthenticationTests$private fun buildTLSSockets( serverSocketFactory: SSLServerSocketFactory, clientSocketFactory: SSLSocketFactory, serverPort: Int = 0, // Use 0 to get first free socket. clientPort: Int = 0, // Use 0 to get first free socket. cipherSuitesServer: Array<String> = CORDA_TLS_CIPHER_SUITES, cipherSuitesClient: Array<String> = CORDA_TLS_CIPHER_SUITES ): Pair<SSLServerSocket, SSLSocket> - LongMethod:TLSAuthenticationTests.kt$TLSAuthenticationTests$private fun testConnect(serverSocket: ServerSocket, clientSocket: SSLSocket, expectedCipherSuite: String) - LongMethod:TestBase.kt$TestBase$ fun sandbox( vararg options: Any, pinnedClasses: Set<java.lang.Class<*>> = emptySet(), minimumSeverityLevel: Severity = Severity.WARNING, enableTracing: Boolean = true, action: SandboxRuntimeContext.() -> Unit ) - LongMethod:TestBase.kt$TestBase$fun parentedSandbox( minimumSeverityLevel: Severity = Severity.WARNING, enableTracing: Boolean = true, action: SandboxRuntimeContext.() -> Unit ) - LongMethod:TestBase.kt$TestBase.Companion$@BeforeClass @JvmStatic fun setupParentClassLoader() - LongMethod:TestCommsFlow.kt$TestCommsFlowInitiator$@Suspendable override fun call(): List<String> - LongMethod:TestDSL.kt$TestLedgerDSLInterpreter$override fun verifies(): EnforceVerifyOrFail - LongMethod:TestDSL.kt$TestLedgerDSLInterpreter$private fun <R> recordTransactionWithTransactionMap( transactionLabel: String?, transactionBuilder: TransactionBuilder, dsl: TestTransactionDSLInterpreter.() -> R, transactionMap: HashMap<SecureHash, WireTransactionWithLocation> = HashMap(), /** If set to true, will add dummy components to [transactionBuilder] to make it valid. */ fillTransaction: Boolean ): WireTransaction - LongMethod:TestNotaryFlow.kt$TestNotaryFlow$@Suspendable override fun call(): String - LongMethod:ThrowableSerializer.kt$ThrowableSerializer$override fun fromProxy(proxy: ThrowableProxy): Throwable - LongMethod:ThrowableWrapperFactory.kt$ThrowableWrapperFactory$ private fun ClassWriter.baseClass() - LongMethod:ThrowableWrapperFactory.kt$ThrowableWrapperFactory$ private fun ClassWriter.childClass() - LongMethod:TimedFlowTests.kt$TimedFlowTests$@Test fun `timed flow can update its ETA`() - LongMethod:TimedFlowTests.kt$TimedFlowTests$@Test fun `timed flow cannot update its ETA to less than default`() - LongMethod:TimedFlowTests.kt$TimedFlowTests.Companion$private fun startClusterAndNode(mockNet: InternalMockNetwork): Triple<Party, TestStartedNode, TestStartedNode> - LongMethod:ToggleFieldTest.kt$ToggleFieldTest$ @Test fun `leaked thread propagates holder to non-global thread, with warning`() - LongMethod:ToggleFieldTest.kt$ToggleFieldTest$@Test fun `inherited values are poisoned on clear`() - LongMethod:TopLevelTransition.kt$TopLevelTransition$private fun enterSubFlowTransition(event: Event.EnterSubFlow): TransitionResult - LongMethod:TopLevelTransition.kt$TopLevelTransition$private fun flowFinishTransition(event: Event.FlowFinish): TransitionResult - LongMethod:TopLevelTransition.kt$TopLevelTransition$private fun leaveSubFlowTransition(): TransitionResult - LongMethod:TopLevelTransition.kt$TopLevelTransition$private fun suspendTransition(event: Event.Suspend): TransitionResult - LongMethod:TopologicalSort.kt$ fun Observable<SignedTransaction>.topologicalSort(initialUnspentRefs: Collection<StateRef>): Observable<SignedTransaction> - LongMethod:TopologicalSortTest.kt$TopologicalSortTest$@Test fun topologicalObservableSort() - LongMethod:TraceAllocations.kt$TraceAllocations$override fun emit(context: EmitterContext, instruction: Instruction) - LongMethod:TraderDemo.kt$TraderDemo$fun main(args: Array<String>) - LongMethod:TraderDemoClientApi.kt$TraderDemoClientApi$fun runIssuer(amount: Amount<Currency>, buyerName: CordaX500Name, sellerName: CordaX500Name) - LongMethod:TraderDemoTest.kt$TraderDemoTest$@Test fun `Test restart node during flow works properly`() - LongMethod:TraderDemoTest.kt$TraderDemoTest$@Test fun `runs trader demo`() - LongMethod:TransactionBuilder.kt$TransactionBuilder$ private fun addMissingDependency(services: ServicesForResolution, wireTx: WireTransaction): Boolean - LongMethod:TransactionBuilder.kt$TransactionBuilder$ private fun attachmentConstraintsTransition(constraints: Set<AttachmentConstraint>, attachmentToUse: ContractAttachment): AttachmentConstraint - LongMethod:TransactionBuilder.kt$TransactionBuilder$ private fun handleContract( contractClassName: ContractClassName, inputStates: List<TransactionState<ContractState>>?, inputStateRefs: Set<StateRef>?, outputStates: List<TransactionState<ContractState>>?, explicitContractAttachment: AttachmentId?, services: ServicesForResolution ): Pair<AttachmentId, List<TransactionState<ContractState>>?> - LongMethod:TransactionBuilder.kt$TransactionBuilder$ private fun resolveStatePointers(transactionState: TransactionState<*>) - LongMethod:TransactionBuilder.kt$TransactionBuilder$ private fun selectAttachmentConstraint( contractClassName: ContractClassName, inputStates: List<TransactionState<ContractState>>?, attachmentToUse: ContractAttachment, services: ServicesForResolution): AttachmentConstraint - LongMethod:TransactionBuilder.kt$TransactionBuilder$ private fun selectContractAttachmentsAndOutputStateConstraints( services: ServicesForResolution, serializationContext: SerializationContext?): Pair<Collection<SecureHash>, List<TransactionState<ContractState>>> - LongMethod:TransactionBuilder.kt$TransactionBuilder$@CordaInternal internal fun toWireTransactionWithContext(services: ServicesForResolution, serializationContext: SerializationContext? = null): WireTransaction - LongMethod:TransactionBuilder.kt$TransactionBuilder$private fun addMissingAttachment(missingClass: String, services: ServicesForResolution, originalException: Throwable): Boolean - LongMethod:TransactionBuilderTest.kt$TransactionBuilderTest$@Before fun setup() - LongMethod:TransactionBuilderTest.kt$TransactionBuilderTest$@Test fun `automatic signature constraint`() - LongMethod:TransactionDataModel.kt$PartiallyResolvedTransaction.Companion$fun fromSignedTransaction( transaction: SignedTransaction, inputTransactions: Map<StateRef, SignedTransaction?> ): PartiallyResolvedTransaction - LongMethod:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$@Test fun `correct encumbrance state must be provided`() - LongMethod:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$@Test fun `encumbered states cannot be assigned to different notaries`() - LongMethod:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$@Test fun `non bi-directional encumbrance will fail`() - LongMethod:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$@Test fun `states must be bi-directionally encumbered`() - LongMethod:TransactionGenerator.kt$TransactionGenerator$fun writeFailure(output: OutputStream) - LongMethod:TransactionGenerator.kt$TransactionGenerator$fun writeSuccess(output: OutputStream) - LongMethod:TransactionOrderingTests.kt$TransactionOrderingTests$@Test fun `Out of order transactions are recorded in vault correctly`() - LongMethod:TransactionSignatureTest.kt$TransactionSignatureTest$@Test fun `Verify multi-tx signature`() - LongMethod:TransactionTests.kt$TransactionTests$@Test fun `general transactions cannot change notary`() - LongMethod:TransactionTests.kt$TransactionTests$@Test fun `signed transaction missing signatures - CompositeKey`() - LongMethod:TransactionTests.kt$TransactionTests$@Test fun `signed transaction missing signatures`() - LongMethod:TransactionTests.kt$TransactionTests$@Test fun `transactions with no inputs can have any notary`() - LongMethod:TransactionUtils.kt$ fun <T : Any> deserialiseComponentGroup(componentGroups: List<ComponentGroup>, clazz: KClass<T>, groupEnum: ComponentGroupEnum, forceDeserialize: Boolean = false, factory: SerializationFactory = SerializationFactory.defaultFactory, context: SerializationContext = factory.defaultContext): List<T> - LongMethod:TransactionUtils.kt$ fun createComponentGroups(inputs: List<StateRef>, outputs: List<TransactionState<ContractState>>, commands: List<Command<*>>, attachments: List<SecureHash>, notary: Party?, timeWindow: TimeWindow?, references: List<StateRef>, networkParametersHash: SecureHash?): List<ComponentGroup> - LongMethod:TransactionUtils.kt$ fun deserialiseCommands(componentGroups: List<ComponentGroup>, forceDeserialize: Boolean = false, factory: SerializationFactory = SerializationFactory.defaultFactory, context: SerializationContext = factory.defaultContext): List<Command<*>> - LongMethod:TransactionVerifierServiceInternal.kt$Verifier$ private fun verifyConstraintsValidity(contractAttachmentsByContract: Map<ContractClassName, ContractAttachment>) - LongMethod:TransactionVerifierServiceInternal.kt$Verifier$ private fun verifyContracts() - LongMethod:TransactionVerifierServiceInternal.kt$Verifier$// Using basic graph theory, a full cycle of encumbered (co-dependent) states should exist to achieve bi-directional // encumbrances. This property is important to ensure that no states involved in an encumbrance-relationship // can be spent on their own. Briefly, if any of the states is having more than one encumbrance references by // other states, a full cycle detection will fail. As a result, all of the encumbered states must be present // as "from" and "to" only once (or zero times if no encumbrance takes place). For instance, // a -> b // c -> b and a -> b // b -> a b -> c // do not satisfy the bi-directionality (full cycle) property. // // In the first example "b" appears twice in encumbrance ("to") list and "c" exists in the encumbered ("from") list only. // Due the above, one could consume "a" and "b" in the same transaction and then, because "b" is already consumed, "c" cannot be spent. // // Similarly, the second example does not form a full cycle because "a" and "c" exist in one of the lists only. // As a result, one can consume "b" and "c" in the same transactions, which will make "a" impossible to be spent. // // On other hand the following are valid constructions: // a -> b a -> c // b -> c and c -> b // c -> a b -> a // and form a full cycle, meaning that the bi-directionality property is satisfied. private fun checkBidirectionalOutputEncumbrances(statesAndEncumbrance: List<Pair<Int, Int>>) - LongMethod:TransactionViewer.kt$TransactionViewer.ContractStatesView$private fun getCell(contractState: StateAndRef<ContractState>): Node - LongMethod:TransformsSchema.kt$TransformsSchema$@Suppress("NAME_SHADOWING") override fun toString(): String - LongMethod:TransformsSchema.kt$TransformsSchema.Companion$ override fun newInstance(described: Any?): TransformsSchema - LongMethod:TransitionDiagnosticRecord.kt$TransitionDiagnosticRecord$override fun toString(): String - LongMethod:TransitionExecutorImpl.kt$TransitionExecutorImpl$@Suspendable override fun executeTransition( fiber: FlowFiber, previousState: StateMachineState, event: Event, transition: TransitionResult, actionExecutor: ActionExecutor ): Pair<FlowContinuation, StateMachineState> - LongMethod:TutorialContract.kt$CommercialPaper$// DOCSTART 3 override fun verify(tx: LedgerTransaction) - LongMethod:TutorialTestDSL.kt$TutorialTestDSL$// DOCSTART 10 @Test fun `chain commercial tweak`() - LongMethod:TutorialTestDSL.kt$TutorialTestDSL$// DOCSTART 8 @Test fun `chain commercial paper`() - LongMethod:TutorialTestDSL.kt$TutorialTestDSL$// DOCSTART 9 @Test fun `chain commercial paper double spend`() - LongMethod:TwoPartyDealFlow.kt$TwoPartyDealFlow.Secondary$@Suspendable override fun call(): SignedTransaction - LongMethod:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$@Test fun `check dependencies of sale asset are resolved`() - LongMethod:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$@Test fun `shutdown and restore`() - LongMethod:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$@Test fun `track works`() - LongMethod:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$@Test fun `trade cash for commercial paper`() - LongMethod:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$@Test(expected = InsufficientBalanceException::class) fun `trade cash for commercial paper fails using soft locking`() - LongMethod:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$private fun LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>.fillUpForBuyerAndInsertFakeTransactions( withError: Boolean, issuer: PartyAndReference, owner: AbstractParty, notary: Party, node: TestStartedNode, identity: Party, notaryNode: TestStartedNode, vararg extraSigningNodes: TestStartedNode ): Triple<Vault<ContractState>, List<WireTransaction>, Map<SecureHash,SignedTransaction>> - LongMethod:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$private fun LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>.fillUpForSeller( withError: Boolean, issuer: PartyAndReference, owner: AbstractParty, amount: Amount<Issued<Currency>>, attachmentID: SecureHash?, notary: Party): Pair<Vault<ContractState>, List<WireTransaction>> - LongMethod:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$private fun LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter>.runWithError( bobError: Boolean, aliceError: Boolean, expectedMessageSubstring: String ) - LongMethod:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$private fun insertFakeTransactions( wtxToSign: List<WireTransaction>, node: TestStartedNode, identity: Party, notaryNode: TestStartedNode, vararg extraSigningNodes: TestStartedNode): Map<SecureHash, SignedTransaction> - LongMethod:TypeLoader.kt$ClassCarpentingTypeLoader$override fun load( remoteTypeInformation: Collection<RemoteTypeInformation>, context: SerializationContext ): Map<TypeIdentifier, Type> - LongMethod:TypeModellingFingerPrinter.kt$FingerPrintingState$// For a type we haven't seen before, determine the correct path depending on the type of type it is. private fun fingerprintNewType(type: LocalTypeInformation) - LongMethod:TypeParameterUtils.kt$ private fun inferTypeVariables(actualClass: Class<*>, declaredClass: Class<*>, declaredType: ParameterizedType): Type? - LongMethod:UniversalContract.kt$UniversalContract$fun evalBigDecimal(tx: LedgerTransaction, expr: Perceivable<BigDecimal>): BigDecimal - LongMethod:UniversalContract.kt$UniversalContract$override fun verify(tx: LedgerTransaction) - LongMethod:UnstartedFlowTransition.kt$UnstartedFlowTransition$// Initialise initiated session, store initial payload, send confirmation back. private fun TransitionBuilder.initialiseInitiatedSession(flowStart: FlowStart.Initiated) - LongMethod:Util.kt$fun <T> debugCompare(perLeft: Perceivable<T>, perRight: Perceivable<T>) - LongMethod:Util.kt$fun debugCompare(arrLeft: Arrangement, arrRight: Arrangement) - LongMethod:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$override fun parseValid(configuration: Config): Valid<NodeConfiguration> - LongMethod:ValidatingNotaryServiceTests.kt$ValidatingNotaryServiceTests$@Test fun `should re-sign a transaction with an expired time-window`() - LongMethod:ValidatingNotaryServiceTests.kt$ValidatingNotaryServiceTests$@Test fun `should reject transaction without network parameters`() - LongMethod:ValidatingNotaryServiceTests.kt$ValidatingNotaryServiceTests$@Test fun `should report conflict when inputs are reused across transactions`() - LongMethod:ValidatingNotaryServiceTests.kt$ValidatingNotaryServiceTests$@Test fun `should sign identical transaction multiple times (notarisation is idempotent)`() - LongMethod:VaultFiller.kt$VaultFiller$ fun fillWithSomeTestCash(howMuch: Amount<Currency>, issuerServices: ServiceHub, atLeastThisManyStates: Int, atMostThisManyStates: Int, issuedBy: PartyAndReference, owner: AbstractParty? = null, rng: Random? = null, statesToRecord: StatesToRecord = StatesToRecord.ONLY_RELEVANT): Vault<Cash.State> - LongMethod:VaultFiller.kt$VaultFiller$@JvmOverloads fun fillWithSomeTestDeals(dealIds: List<String>, issuerServices: ServiceHub = services, participants: List<AbstractParty> = emptyList(), includeMe: Boolean = true): Vault<DealState> - LongMethod:VaultFiller.kt$VaultFiller$@JvmOverloads fun fillWithSomeTestLinearAndDealStates(numberToCreate: Int, externalId: String? = null, participants: List<AbstractParty> = emptyList(), linearString: String = "", linearNumber: Long = 0L, linearBoolean: Boolean = false, linearTimestamp: Instant = now()): Vault<LinearState> - LongMethod:VaultFiller.kt$VaultFiller$@JvmOverloads fun fillWithSomeTestLinearStates(numberToCreate: Int, externalId: String? = null, participants: List<AbstractParty> = emptyList(), uniqueIdentifier: UniqueIdentifier? = null, linearString: String = "", linearNumber: Long = 0L, linearBoolean: Boolean = false, linearTimestamp: Instant = now(), constraint: AttachmentConstraint = AutomaticPlaceholderConstraint, includeMe: Boolean = true): Vault<LinearState> - LongMethod:VaultFiller.kt$VaultFiller.Companion$fun calculateRandomlySizedAmounts(howMuch: Amount<Currency>, min: Int, max: Int, rng: Random): LongArray - LongMethod:VaultQueryTests.kt$VaultQueryTests$ @Test fun trackCashStates_unconsumed() - LongMethod:VaultQueryTests.kt$VaultQueryTests$@Test fun `track by of contract state interface returns updates of all states`() - LongMethod:VaultQueryTests.kt$VaultQueryTests$@Test fun `track by of super class only returns updates of sub classes of tracked type`() - LongMethod:VaultQueryTests.kt$VaultQueryTests$@Test fun `track by only returns updates of tracked type`() - LongMethod:VaultQueryTests.kt$VaultQueryTests$@Test fun trackCashStates_all() - LongMethod:VaultQueryTests.kt$VaultQueryTests$@Test fun trackCashStates_consumed() - LongMethod:VaultQueryTests.kt$VaultQueryTests$@Test fun trackDealStates() - LongMethod:VaultQueryTests.kt$VaultQueryTests$@Test fun trackLinearStates() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$ // specifying Query on Commercial Paper contract state attributes @Test fun `custom query using JPA - commercial paper schema V1 single attribute`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$// specifying Query on Commercial Paper contract state attributes @Test fun `custom query using JPA - commercial paper schema V1 - multiple attributes`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$// specifying Query on Linear state attributes @Test fun `unconsumed linear heads for linearId between two timestamps for a given external id`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$// test paging with aggregate function and group by clause @Test fun `test paging with aggregate function and group by clause`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `aggregate functions count by contract type and state status`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `aggregate functions sum by issuer and currency and sort by aggregate sum`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `aggregate functions with single group clause`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `aggregate functions without group clause`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `composite query for fungible and linear states for multiple participants`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `composite query for fungible and linear states`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `query by contract states constraint type and data`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `query by contract states constraint type`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `query with sort criteria works even when multiple pages have the same value for the sort criteria field`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `query with sort criteria works with pagination`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `state relevancy queries`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `unconsumed cash states sorted by state ref txnId and index`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `unconsumed cash states sorted by state ref`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `unconsumed fungible assets for selected issuer parties`() - LongMethod:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `unconsumed states with soft locking`() - LongMethod:VaultRestartTest.kt$VaultRestartTest$@Test fun `restart and query vault after adding some cash states`() - LongMethod:VaultStateMigration.kt$VaultStateMigration$override fun execute(database: Database?) - LongMethod:VaultStateMigrationTest.kt$VaultStateMigrationTest$// Used to generate a persistent database for further testing. @Test @Ignore fun `Create persistent DB`() - LongMethod:VaultStateMigrationTest.kt$VaultStateMigrationTest$@Test fun `Check state fields are correct`() - LongMethod:VaultStateMigrationTest.kt$VaultStateMigrationTest$@Test fun `State with non-owning key for our name marked as relevant`() - LongMethod:VaultStateMigrationTest.kt$VaultStateMigrationTest$private fun addNetworkParameters() - LongMethod:VaultSteps.kt$VaultSteps$override fun initialize(state: ScenarioState) - LongMethod:VaultWithCashTest.kt$VaultWithCashTest$@Test fun `consuming multiple contract state types`() - LongMethod:VaultWithCashTest.kt$VaultWithCashTest$@Test fun `issue and attempt double spend`() - LongMethod:VaultWithCashTest.kt$VaultWithCashTest$@Test fun `issue and spend total correctly and irrelevant ignored`() - LongMethod:VaultWithCashTest.kt$VaultWithCashTest$@Test fun `sequencing LinearStates works`() - LongMethod:VaultWithCashTest.kt$VaultWithCashTest$@Test fun `spending cash in vault of mixed state types works`() - LongMethod:VirtualCordapps.kt$VirtualCordapp$ fun generateBFTSmartNotary(versionInfo: VersionInfo): CordappImpl - LongMethod:VirtualCordapps.kt$VirtualCordapp$ fun generateCore(versionInfo: VersionInfo): CordappImpl - LongMethod:VirtualCordapps.kt$VirtualCordapp$ fun generateRaftNotary(versionInfo: VersionInfo): CordappImpl - LongMethod:VirtualCordapps.kt$VirtualCordapp$ fun generateSimpleNotary(versionInfo: VersionInfo): CordappImpl - LongMethod:WebServer.kt$WebServer$@Throws(IOException::class) fun open(config: NodeConfigWrapper): CordaFuture<URI> - LongMethod:WebServer.kt$fun main(args: Array<String>) - LongMethod:Whitelist.kt$Whitelist.Companion$ fun fromStream(inputStream: InputStream): Whitelist - LongMethod:WhitelistGenerator.kt$fun generateWhitelist(networkParameters: NetworkParameters?, excludeContracts: List<ContractClassName>, cordappJars: List<ContractsJar>, includeContracts: List<ContractClassName>, optionalCordappJars: List<ContractsJar>): Map<ContractClassName, List<AttachmentId>> - LongMethod:WireTransaction.kt$WireTransaction$@DeleteForDJVM override fun toString(): String - LongMethod:WireTransaction.kt$WireTransaction$private fun toLedgerTransactionInternal( resolveIdentity: (PublicKey) -> Party?, resolveAttachment: (SecureHash) -> Attachment?, resolveStateRefAsSerialized: (StateRef) -> SerializedBytes<TransactionState<ContractState>>?, resolveParameters: (SecureHash?) -> NetworkParameters?, resolveContractAttachment: (StateRef) -> Attachment ): LedgerTransaction - LongMethod:WireTransaction.kt$WireTransaction.Companion$ @CordaInternal fun resolveStateRefBinaryComponent(stateRef: StateRef, services: ServicesForResolution): SerializedBytes<TransactionState<ContractState>>? - LongMethod:WithReferencedStatesFlow.kt$WithReferencedStatesFlow$@Suspendable override fun call(): T - LongMethod:WorkflowTransactionBuildTutorial.kt$RecordCompletionFlow$@Suspendable override fun call() - LongMethod:WorkflowTransactionBuildTutorial.kt$SubmitCompletionFlow$@Suspendable override fun call(): StateAndRef<TradeApprovalContract.State> - LongMethod:WorkflowTransactionBuildTutorial.kt$TradeApprovalContract$ override fun verify(tx: LedgerTransaction) - LongMethod:WorkflowTransactionBuildTutorialTest.kt$WorkflowTransactionBuildTutorialTest$@Test fun `Run workflow to completion`() - LongMethod:X509NameConstraintsTest.kt$X509NameConstraintsTest$@Test fun `illegal common name`() - LongMethod:X509NameConstraintsTest.kt$X509NameConstraintsTest$@Test fun `x500 name with correct cn and extra attribute`() - LongMethod:X509NameConstraintsTest.kt$X509NameConstraintsTest$private fun makeKeyStores(subjectName: X500Name, nameConstraints: NameConstraints): Pair<X509KeyStore, X509KeyStore> - LongMethod:X509Utilities.kt$X509Utilities$ @JvmStatic fun createCertificate(certificateType: CertificateType, issuerCertificate: X509Certificate, issuerKeyPair: KeyPair, subject: X500Principal, subjectPublicKey: PublicKey, validityWindow: Pair<Duration, Duration> = DEFAULT_VALIDITY_WINDOW, nameConstraints: NameConstraints? = null, crlDistPoint: String? = null, crlIssuer: X500Name? = null): X509Certificate - LongMethod:X509Utilities.kt$X509Utilities$ fun createCertificate(certificateType: CertificateType, issuer: X500Principal, issuerKeyPair: KeyPair, subject: X500Principal, subjectPublicKey: PublicKey, validityWindow: Pair<Date, Date>, nameConstraints: NameConstraints? = null, crlDistPoint: String? = null, crlIssuer: X500Name? = null): X509Certificate - LongMethod:X509Utilities.kt$X509Utilities$ fun createPartialCertificate(certificateType: CertificateType, issuer: X500Principal, issuerPublicKey: PublicKey, subject: X500Principal, subjectPublicKey: PublicKey, validityWindow: Pair<Date, Date>, nameConstraints: NameConstraints? = null, crlDistPoint: String? = null, crlIssuer: X500Name? = null): X509v3CertificateBuilder - LongMethod:X509UtilitiesTest.kt$X509UtilitiesTest$@Test fun `create server cert and use in SSL socket`() - LongMethod:X509UtilitiesTest.kt$X509UtilitiesTest$@Test fun `create server certificate in keystore for SSL`() - LongMethod:X509UtilitiesTest.kt$X509UtilitiesTest$private fun createValidServerCertIncludeCRL(signatureSchemeRoot: SignatureScheme, signatureSchemeChild: SignatureScheme) - LongMethod:ZeroCouponBond.kt$ZeroCouponBond$@Test fun move() LongParameterList:AMQPSerializer.kt$AMQPSerializer$(obj: Any, data: Data, type: Type, output: SerializationOutput, context: SerializationContext, debugIndent: Int = 0) LongParameterList:AbstractCashSelection.kt$AbstractCashSelection$(connection: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, withResultSet: (ResultSet) -> Boolean) LongParameterList:AbstractCashSelection.kt$AbstractCashSelection$(services: ServiceHub, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, stateAndRefs: MutableList<StateAndRef<Cash.State>>) @@ -3794,29 +2699,13 @@ MatchingDeclarationName:TutorialFlowStateMachines.kt$net.corda.docs.kotlin.tutorial.flowstatemachines.TutorialFlowStateMachines.kt MatchingDeclarationName:Utils.kt$io.cryptoblk.core.Utils.kt MatchingDeclarationName:VirtualCordapps.kt$net.corda.node.internal.cordapp.VirtualCordapps.kt - MaxLineLength:AMQPBridgeManager.kt$AMQPBridgeManager : BridgeManager - MaxLineLength:AMQPBridgeManager.kt$AMQPBridgeManager$AMQPBridge MaxLineLength:AMQPBridgeManager.kt$AMQPBridgeManager$crlCheckSoftFail: Boolean - MaxLineLength:AMQPBridgeManager.kt$AMQPBridgeManager$val newBridge = AMQPBridge(queueName, targets, legalNames, amqpConfig, sharedEventLoopGroup!!, artemis!!, bridgeMetricsService) - MaxLineLength:AMQPBridgeManager.kt$AMQPBridgeManager.AMQPBridge$logDebugWithMDC { "Bridged Send to ${legalNames.first()} uuid: ${artemisMessage.getObjectProperty("_AMQ_DUPL_ID")}" } - MaxLineLength:AMQPBridgeManager.kt$AMQPBridgeManager.AMQPBridge$logInfoWithMDC("Rollback rejected message uuid: ${artemisMessage.getObjectProperty("_AMQ_DUPL_ID")}") MaxLineLength:AMQPBridgeManager.kt$AMQPBridgeManager.AMQPBridge$val msg = "Message exceeds maxMessageSize network parameter, maxMessageSize: [${amqpConfig.maxMessageSize}], message size: [${artemisMessage.bodySize}], " + "dropping message, uuid: ${artemisMessage.getObjectProperty("_AMQ_DUPL_ID")}" MaxLineLength:AMQPBridgeManager.kt$AMQPBridgeManager.AMQPBridge$val session = sessionFactory.createSession(NODE_P2P_USER, NODE_P2P_USER, false, true, true, false, DEFAULT_ACK_BATCH_SIZE) MaxLineLength:AMQPBridgeManager.kt$AMQPBridgeManager.AMQPConfigurationImpl$constructor(config: MutualSslConfiguration, maxMessageSize: Int, crlCheckSoftFail: Boolean) : this(config.keyStore.get(), config.trustStore.get(), maxMessageSize, crlCheckSoftFail) - MaxLineLength:AMQPBridgeManager.kt$AMQPBridgeManager.AMQPConfigurationImpl$override val crlCheckSoftFail: Boolean - MaxLineLength:AMQPBridgeManager.kt$import net.corda.nodeapi.internal.ArtemisMessagingComponent.RemoteInboxAddress.Companion.translateLocalQueueToInboxAddress MaxLineLength:AMQPBridgeTest.kt$AMQPBridgeTest$private - MaxLineLength:AMQPBridgeTest.kt$AMQPBridgeTest$val artemisServer = ArtemisMessagingServer(artemisConfig, artemisAddress.copy(host = "0.0.0.0"), MAX_MESSAGE_SIZE) - MaxLineLength:AMQPBridgeTest.kt$AMQPBridgeTest$val bridgeManager = AMQPBridgeManager(artemisConfig.p2pSslOptions, artemisAddress, MAX_MESSAGE_SIZE, artemisConfig.crlCheckSoftFail) - MaxLineLength:AMQPBridgeTest.kt$AMQPBridgeTest${ // Note that the opposite of this test (that a connection is established if strict checking is disabled) is carried out by the // ack/nack test above. "Strict CRL checking" means that soft fail mode is disabled. val sourceQueueName = "internal.peers." + BOB.publicKey.toStringShort() val (artemisServer, artemisClient, bridge) = createArtemis(sourceQueueName, crlCheckSoftFail = false) createAMQPServer().use { val connectedFuture = it.onConnection.toFuture() it.start() val connectedResult = connectedFuture.get() assertEquals(false, connectedResult.connected) } bridge.stop() artemisClient.stop() artemisServer.stop() } - MaxLineLength:AMQPChannelHandler.kt$AMQPChannelHandler$"Message for incorrect legal identity ${msg.destinationLegalName} expected ${remoteCert!!.subjectX500Principal}" MaxLineLength:AMQPChannelHandler.kt$AMQPChannelHandler$eventProcessor = EventProcessor(ch, serverMode, localCert!!.subjectX500Principal.toString(), remoteCert!!.subjectX500Principal.toString(), userName, password) - MaxLineLength:AMQPChannelHandler.kt$AMQPChannelHandler$logErrorWithMDC("Provided certificate subject $remoteX500Name not in expected set $allowedRemoteLegalNames") - MaxLineLength:AMQPChannelHandler.kt$AMQPChannelHandler$require MaxLineLength:AMQPChannelHandler.kt$AMQPChannelHandler${ logWarnWithMDC("SSL Handshake closed early.") } - MaxLineLength:AMQPClient.kt$AMQPClient.ClientChannelInitializer$log.error("Blocking future connection attempts to $target due to bad certificate on endpoint") - MaxLineLength:AMQPClient.kt$AMQPClient.ClientChannelInitializer$val handler = createClientSslHelper(target, parent.allowedRemoteLegalNames, keyManagerFactory, trustManagerFactory) - MaxLineLength:AMQPClientSerializationScheme.kt$AMQPClientSerializationScheme$( cordappCustomSerializers: Set<SerializationCustomSerializer<*,*>>, cordappSerializationWhitelists: Set<SerializationWhitelist>, serializerFactoriesForContexts: MutableMap<SerializationFactoryCacheKey, SerializerFactory> ) MaxLineLength:AMQPClientSerializationScheme.kt$AMQPClientSerializationScheme$@Suppress("UNUSED") constructor() : this(emptySet(), emptySet(), AccessOrderLinkedHashMap<SerializationFactoryCacheKey, SerializerFactory>(128).toSynchronised()) MaxLineLength:AMQPClientSerializationScheme.kt$AMQPClientSerializationScheme$constructor(cordapps: List<Cordapp>) : this(cordapps.customSerializers, cordapps.serializationWhitelists, AccessOrderLinkedHashMap<SerializationFactoryCacheKey, SerializerFactory>(128).toSynchronised()) MaxLineLength:AMQPClientSerializationScheme.kt$AMQPClientSerializationScheme$constructor(cordapps: List<Cordapp>, serializerFactoriesForContexts: MutableMap<SerializationFactoryCacheKey, SerializerFactory>) : this(cordapps.customSerializers, cordapps.serializationWhitelists, serializerFactoriesForContexts) @@ -3824,277 +2713,115 @@ MaxLineLength:AMQPClientSerializationScheme.kt$AMQPClientSerializationScheme.Companion$ fun initialiseSerialization(classLoader: ClassLoader? = null, customSerializers: Set<SerializationCustomSerializer<*, *>> = emptySet(), serializationWhitelists: Set<SerializationWhitelist> = emptySet(), serializerFactoriesForContexts: MutableMap<SerializationFactoryCacheKey, SerializerFactory> = AccessOrderLinkedHashMap<SerializationFactoryCacheKey, SerializerFactory>(128).toSynchronised()) MaxLineLength:AMQPClientSerializationScheme.kt$AMQPClientSerializationScheme.Companion$fun createSerializationEnv(classLoader: ClassLoader? = null, customSerializers: Set<SerializationCustomSerializer<*, *>> = emptySet(), serializationWhitelists: Set<SerializationWhitelist> = emptySet(), serializerFactoriesForContexts: MutableMap<SerializationFactoryCacheKey, SerializerFactory> = AccessOrderLinkedHashMap<SerializationFactoryCacheKey, SerializerFactory>(128).toSynchronised()): SerializationEnvironment MaxLineLength:AMQPClientSerializationScheme.kt$AMQPClientSerializationScheme.Companion$nodeSerializationEnv = createSerializationEnv(classLoader, customSerializers, serializationWhitelists, serializerFactoriesForContexts) - MaxLineLength:AMQPClientSerializationScheme.kt$AMQPClientSerializationScheme.Companion$p2pContext = if (classLoader != null) AMQP_P2P_CONTEXT.withClassLoader(classLoader) else AMQP_P2P_CONTEXT MaxLineLength:AMQPClientSerializationScheme.kt$AMQPClientSerializationScheme.Companion$registerScheme(AMQPClientSerializationScheme(customSerializers, serializationWhitelists, serializerFactoriesForContexts)) - MaxLineLength:AMQPConfiguration.kt$AMQPConfiguration$/** * Enables full debug tracing of all netty and AMQP level packets. This logs aat very high volume and is only for developers. */ @JvmDefault val trace: Boolean get() = false - MaxLineLength:AMQPConfiguration.kt$AMQPConfiguration$/** * Setting crlCheckSoftFail to true allows certificate paths where some leaf certificates do not contain cRLDistributionPoints * and also allows validation to continue if the CRL distribution server is not contactable. */ @JvmDefault val crlCheckSoftFail: Boolean get() = true - MaxLineLength:AMQPConfiguration.kt$AMQPConfiguration$/** * The maximum allowed size for packets, which will be dropped ahead of send. In future may also be enforced on receive, * but currently that is deferred to Artemis and the bridge code. */ val maxMessageSize: Int - MaxLineLength:AMQPRemoteTypeModel.kt$AMQPRemoteTypeModel$cache.getOrPut(typeDescriptor) { interpretationState.run { typeNotation.name.typeIdentifier.interpretIdentifier() } } - MaxLineLength:AMQPRemoteTypeModel.kt$AMQPRemoteTypeModel$throw NotSerializableException("Cannot resolve cyclic reference to ${typeInformation.typeIdentifier}") - MaxLineLength:AMQPRemoteTypeModel.kt$AMQPRemoteTypeModel.InterpretationState$ fun TypeIdentifier.interpretIdentifier(): RemoteTypeInformation - MaxLineLength:AMQPRemoteTypeModel.kt$AMQPRemoteTypeModel.InterpretationState$ private fun TypeIdentifier.interpretNoNotation(): RemoteTypeInformation - MaxLineLength:AMQPRemoteTypeModel.kt$AMQPRemoteTypeModel.InterpretationState$ private fun TypeNotation.interpretNotation(identifier: TypeIdentifier): RemoteTypeInformation - MaxLineLength:AMQPRemoteTypeModel.kt$AMQPRemoteTypeModel.InterpretationState$private - MaxLineLength:AMQPRemoteTypeModel.kt$AMQPRemoteTypeModel.InterpretationState$return if (isInterface) RemoteTypeInformation.AnInterface(typeDescriptor, identifier, properties, interfaces, typeParameters) else RemoteTypeInformation.Composable(typeDescriptor, identifier, properties, interfaces, typeParameters) - MaxLineLength:AMQPRemoteTypeModel.kt$AMQPRemoteTypeModel.InterpretationState$val constants = choices.asSequence().mapIndexed { index, choice -> choice.name to index }.toMap(LinkedHashMap()) - MaxLineLength:AMQPRemoteTypeModelTests.kt$AMQPRemoteTypeModelTests$C<V> : Superclass - MaxLineLength:AMQPRemoteTypeModelTests.kt$AMQPRemoteTypeModelTests.Superclass$open MaxLineLength:AMQPSerializationScheme.kt$AbstractAMQPSerializationScheme$@DeleteForDJVM constructor(cordapps: List<Cordapp>) : this(cordapps.customSerializers, cordapps.serializationWhitelists, AccessOrderLinkedHashMap<SerializationFactoryCacheKey, SerializerFactory>(128).toSynchronised()) MaxLineLength:AMQPSerializationScheme.kt$AbstractAMQPSerializationScheme$private MaxLineLength:AMQPSerializationScheme.kt$AbstractAMQPSerializationScheme$val key = SerializationFactoryCacheKey(context.whitelist, context.deserializationClassLoader, context.preventDataLoss, context.customSerializers) MaxLineLength:AMQPSerializationScheme.kt$AbstractAMQPSerializationScheme${ // This is a hack introduced in version 3 to fix a spring boot issue - CORDA-1747. // It breaks the shell because it overwrites the CordappClassloader with the system classloader that doesn't know about any CorDapps. // In case a spring boot serialization issue with generics is found, a better solution needs to be found to address it. // var contextToUse = context // if (context.useCase == SerializationContext.UseCase.RPCClient) { // contextToUse = context.withClassLoader(getContextClassLoader()) // } val serializerFactory = getSerializerFactory(context) return DeserializationInput(serializerFactory).deserialize(byteSequence, clazz, context) } MaxLineLength:AMQPSerializationScheme.kt$AbstractAMQPSerializationScheme${ // This step is registering custom serializers, which have been added after node initialisation (i.e. via attachments during transaction verification). // Note: the order between the registration of customSerializers and cordappCustomSerializers must be preserved as-is. The reason is the following: // Currently, the serialization infrastructure does not support multiple versions of a class (the first one that is registered dominates). // As a result, when inside a context with attachments class loader, we prioritize serializers loaded on-demand from attachments to serializers that had been // loaded during node initialisation, by scanning the cordapps folder. context.customSerializers.forEach { customSerializer -> factory.registerExternal(CorDappCustomSerializer(customSerializer, factory)) } logger.debug("Custom Serializer list loaded - not scanning classpath") cordappCustomSerializers.forEach { customSerializer -> factory.registerExternal(CorDappCustomSerializer(customSerializer, factory)) } } - MaxLineLength:AMQPSerializationScheme.kt$AbstractAMQPSerializationScheme.Companion$ServiceLoader.load(SerializationWhitelist::class.java, this::class.java.classLoader).toList() + DefaultWhitelist - MaxLineLength:AMQPSerializer.kt$AMQPSerializer$ fun readObject(obj: Any, schemas: SerializationSchemas, input: DeserializationInput, context: SerializationContext): T - MaxLineLength:AMQPSerializer.kt$AMQPSerializer$ fun writeClassInfo(output: SerializationOutput) - MaxLineLength:AMQPSerializer.kt$AMQPSerializer$/** * Textual unique representation of the JVM type this represents. Will be encoded into the AMQP stream and * will appear in the schema. * * This should be unique enough that we can use one global cache of [AMQPSerializer]s and use this as the look up key. */ val typeDescriptor: Symbol - MaxLineLength:AMQPSerializerFactories.kt$SerializerFactoryFactoryImpl$ClassCarpenterImpl(context.whitelist, context.deserializationClassLoader, context.lenientCarpenterEnabled) MaxLineLength:AMQPServer.kt$AMQPServer$server.group(bossGroup, workerGroup).channel(NioServerSocketChannel::class.java).option(ChannelOption.SO_BACKLOG, 100).handler(LoggingHandler(LogLevel.INFO)).childHandler(ServerChannelInitializer(this)) MaxLineLength:AMQPServer.kt$AMQPServer$val channelFuture = server.bind(hostName, port).sync() // block/throw here as better to know we failed to claim port than carry on - MaxLineLength:AMQPServerSerializationScheme.kt$AMQPServerSerializationScheme$( cordappCustomSerializers: Set<SerializationCustomSerializer<*, *>>, cordappSerializationWhitelists: Set<SerializationWhitelist>, serializerFactoriesForContexts: MutableMap<SerializationFactoryCacheKey, SerializerFactory> ) MaxLineLength:AMQPServerSerializationScheme.kt$AMQPServerSerializationScheme$constructor() : this(emptySet(), emptySet(), AccessOrderLinkedHashMap<SerializationFactoryCacheKey, SerializerFactory>(128).toSynchronised() ) MaxLineLength:AMQPServerSerializationScheme.kt$AMQPServerSerializationScheme$constructor(cordapps: List<Cordapp>) : this(cordapps.customSerializers, cordapps.serializationWhitelists, AccessOrderLinkedHashMap<SerializationFactoryCacheKey, SerializerFactory>(128).toSynchronised()) MaxLineLength:AMQPServerSerializationScheme.kt$AMQPServerSerializationScheme$constructor(cordapps: List<Cordapp>, serializerFactoriesForContexts: MutableMap<SerializationFactoryCacheKey, SerializerFactory>) : this(cordapps.customSerializers, cordapps.serializationWhitelists, serializerFactoriesForContexts) MaxLineLength:AMQPServerSerializationScheme.kt$AMQPServerSerializationScheme$return SerializerFactoryBuilder.build(context.whitelist, context.deserializationClassLoader, context.lenientCarpenterEnabled).apply { register(RpcServerObservableSerializer()) register(RpcServerCordaFutureSerializer(this)) register(RxNotificationSerializer(this)) } MaxLineLength:AMQPTestUtils.kt$val dir = ProjectStructure.projectRootDir / "serialization" / "src" / "test" / "resources" / javaClass.packageName.replace('.', separatorChar) - MaxLineLength:AMQPTypeIdentifierParser.kt$AMQPTypeIdentifierParser$else -> throw IllegalTypeNameParserStateException("Type name '$typeString' contains illegal character '$c'") - MaxLineLength:AMQPTypeIdentifierParser.kt$AMQPTypeIdentifierParser$throw IllegalTypeNameParserStateException("Nested depth of type parameters exceeds maximum of $MAX_TYPE_PARAM_DEPTH") - MaxLineLength:AMQPTypeIdentifierParser.kt$AMQPTypeIdentifierParser.ParseState.ParsingArray$data MaxLineLength:AMQPTypeIdentifierParser.kt$AMQPTypeIdentifierParser.ParseState.ParsingParameterList$data MaxLineLength:AMQPTypeIdentifierParser.kt$AMQPTypeIdentifierParser.ParseState.ParsingRawType$data - MaxLineLength:AMQPTypeIdentifierParserTests.kt$AMQPTypeIdentifierParserTests$assertParsesCompatibly<WithParameters<IntArray, WithParameter<Array<WithParameters<Array<Array<Date>>, UUID>>>>>() MaxLineLength:AMQPTypeIdentifierParserTests.kt$AMQPTypeIdentifierParserTests$verify(" java.util.Map < java.util.Map< java.lang.String, java.lang.Integer >, java.util.Map < java.lang.Long , java.lang.String > >") - MaxLineLength:AMQPTypeIdentifierParserTests.kt$AMQPTypeIdentifierParserTests$verify("java.util.List<net.corda.core.contracts.Command<net.corda.core.contracts.Command<net.corda.core.contracts.CommandData>>>") - MaxLineLength:AMQPTypeIdentifiers.kt$AMQPTypeIdentifiers$is TypeIdentifier.Parameterised - MaxLineLength:AMQPTypeIdentifiers.kt$AMQPTypeIdentifiers$private val primitiveByteArrayType = TypeIdentifier.ArrayOf(TypeIdentifier.forClass(Byte::class.javaPrimitiveType!!)) - MaxLineLength:ANSIProgressRenderer.kt$ANSIProgressRenderer$// Create a new tree of steps that also holds a reference to the parent of each step. This is required to uniquely identify each step // (assuming that each step label is unique at a given level). private fun transformTree(inputTree: List<InputTreeStep>): List<ProgressStep> MaxLineLength:ANSIProgressRenderer.kt$ANSIProgressRenderer$ansi.a("${IntStream.range(indent, indent).mapToObj { "\t" }.toList().joinToString(separator = "") { s -> s }} $errorIcon ${error.message}") - MaxLineLength:ANSIProgressRenderer.kt$ANSIProgressRenderer$updatesSubscription - MaxLineLength:ANSIProgressRenderer.kt$ANSIProgressRenderer$val newTree = transformTree(it.first.map { elem -> InputTreeStep(elem.first, elem.second) }) // Process indices first, as if the tree has changed the associated index with this update is for the old tree. Note // that the one case where this isn't true is the very first update, but in this case the index should be 0 (as this // update is for the initial state). The remapping on a new tree assumes the step at index 0 is always at least current, // so this case is handled there. treeIndex = it.second treeIndexProcessed.add(it.second) if (newTree != tree) { remapIndices(newTree) tree = newTree } draw(true) - MaxLineLength:ANSIProgressRenderer.kt$ANSIProgressRenderer${ // By combining the two observables, a race condition where both emit items at roughly the same time is avoided. This could // result in steps being incorrectly marked as skipped. Instead, whenever either observable emits an item, a pair of the // last index and last tree is returned, which ensures that updates to either are processed in series. updatesSubscription = combineLatest(treeUpdates, indexUpdates) { tree, index -> Pair(tree, index) }.subscribe( { val newTree = transformTree(it.first.map { elem -> InputTreeStep(elem.first, elem.second) }) // Process indices first, as if the tree has changed the associated index with this update is for the old tree. Note // that the one case where this isn't true is the very first update, but in this case the index should be 0 (as this // update is for the initial state). The remapping on a new tree assumes the step at index 0 is always at least current, // so this case is handled there. treeIndex = it.second treeIndexProcessed.add(it.second) if (newTree != tree) { remapIndices(newTree) tree = newTree } draw(true) }, { done(it) }, { done(null) } ) } - MaxLineLength:ANSIProgressRenderer.kt$ANSIProgressRenderer${ // If some steps were removed from the progress tracker, we don't want to leave junk hanging around below. val linesToClear = prevLinesDrawn - newLinesDrawn repeat(linesToClear) { ansi.eraseLine() ansi.newline() } ansi.cursorUp(linesToClear) } - MaxLineLength:ANSIProgressRenderer.kt$ANSIProgressRenderer${ // If there is nothing on the stack at any point, it implies that this step is at the top level and has no parent. null } - MaxLineLength:ANSIProgressRenderer.kt$ANSIProgressRenderer${ // The top of the stack is at the same or lower level than the current step. Remove items from the top until the topmost // item is at a higher level - this is the parent step. repeat(levelDifference + 1) { stack.pop() } } - MaxLineLength:ANSIProgressRenderer.kt$StdoutANSIProgressRenderer : ANSIProgressRenderer - MaxLineLength:ANSIProgressRenderer.kt$StdoutANSIProgressRenderer$appenderRefs.forEach { config.addAppender(manager.configuration.appenders[it.ref], it.level, it.filter) } - MaxLineLength:ANSIProgressRenderer.kt$StdoutANSIProgressRenderer$loggerFor<StdoutANSIProgressRenderer>().warn("Cannot find console appender - progress tracking may not work as expected") MaxLineLength:ANSIProgressRenderer.kt$StdoutANSIProgressRenderer$val consoleAppender = manager.configuration.appenders.values.filterIsInstance<ConsoleAppender>().singleOrNull { it.name == "Console-Selector" } - MaxLineLength:ANSIProgressRendererTest.kt$ANSIProgressRendererTest$checkTrackingState(captor, 2, listOf(stepSuccess(STEP_1_LABEL), stepSkipped(STEP_2_LABEL), stepActive(STEP_3_LABEL))) - MaxLineLength:ANSIProgressRendererTest.kt$ANSIProgressRendererTest$checkTrackingState(captor, 3, listOf(stepSuccess(STEP_1_LABEL), stepSuccess(STEP_2_LABEL), stepActive(STEP_3_LABEL))) - MaxLineLength:ANSIProgressRendererTest.kt$ANSIProgressRendererTest$checkTrackingState(captor, 4, listOf(stepActive(STEP_1_LABEL), stepNotRun(STEP_4_LABEL), stepNotRun(STEP_5_LABEL))) MaxLineLength:ANSIProgressRendererTest.kt$ANSIProgressRendererTest$checkTrackingState(captor, 5, listOf(stepSuccess(STEP_1_LABEL), stepSuccess(STEP_3_LABEL), stepSuccess(STEP_2_LABEL), stepActive(STEP_3_LABEL))) MaxLineLength:ANSIProgressRendererTest.kt$ANSIProgressRendererTest$checkTrackingState(captor, 6, listOf(stepSuccess(STEP_1_LABEL), stepSuccess(STEP_3_LABEL), stepSuccess(STEP_2_LABEL), stepActive(STEP_3_LABEL), stepNotRun(STEP_4_LABEL))) MaxLineLength:ANSIProgressRendererTest.kt$ANSIProgressRendererTest$feedSubject.onNext(listOf(Pair(0, STEP_1_LABEL), Pair(1, STEP_2_LABEL), Pair(1, STEP_3_LABEL), Pair(0, STEP_4_LABEL), Pair(0, STEP_5_LABEL))) - MaxLineLength:ANSIProgressRendererTest.kt$ANSIProgressRendererTest$feedSubject.onNext(listOf(Pair(0, STEP_1_LABEL), Pair(1, STEP_3_LABEL), Pair(0, STEP_2_LABEL), Pair(1, STEP_3_LABEL))) MaxLineLength:ANSIProgressRendererTest.kt$ANSIProgressRendererTest$feedSubject.onNext(listOf(Pair(0, STEP_1_LABEL), Pair(1, STEP_3_LABEL), Pair(0, STEP_2_LABEL), Pair(1, STEP_3_LABEL), Pair(2, STEP_4_LABEL))) MaxLineLength:ANSIProgressRendererTest.kt$ANSIProgressRendererTest$flowProgressHandle = FlowProgressHandleImpl(StateMachineRunId.createRandom(), openFuture<String>(), Observable.empty(), stepsTreeIndexFeed, stepsTreeFeed) - MaxLineLength:APIServer.kt$APIServer MaxLineLength:AbstractAMQPSerializationSchemeTest.kt$AbstractAMQPSerializationSchemeTest$ByteSequence.of(byteArrayOf('c'.toByte(), 'o'.toByte(), 'r'.toByte(), 'd'.toByte(), 'a'.toByte(), 0.toByte(), 0.toByte(), 1.toByte())) - MaxLineLength:AbstractAMQPSerializationSchemeTest.kt$AbstractAMQPSerializationSchemeTest$val backingMap = AccessOrderLinkedHashMap<SerializationFactoryCacheKey, SerializerFactory>({ maxFactories }).toSynchronised() MaxLineLength:AbstractAMQPSerializationSchemeTest.kt$AbstractAMQPSerializationSchemeTest$val deserialized = serialized.deserialize(context = context, serializationFactory = serializationEnvironment.serializationFactory) - MaxLineLength:AbstractAMQPSerializationSchemeTest.kt$AbstractAMQPSerializationSchemeTest$val factory = SerializerFactoryBuilder.build(TESTING_CONTEXT.whitelist, TESTING_CONTEXT.deserializationClassLoader) - MaxLineLength:AbstractAMQPSerializationSchemeTest.kt$AbstractAMQPSerializationSchemeTest$val scheme = object : AbstractAMQPSerializationScheme(emptySet(), emptySet(), backingMap, createSerializerFactoryFactory()) { override fun rpcClientSerializerFactory(context: SerializationContext): SerializerFactory { return factory } override fun rpcServerSerializerFactory(context: SerializationContext): SerializerFactory { return factory } override fun canDeserializeVersion(magic: CordaSerializationMagic, target: SerializationContext.UseCase): Boolean { return true } } - MaxLineLength:AbstractAMQPSerializationSchemeTest.kt$AbstractAMQPSerializationSchemeTest.<no name provided>$override - MaxLineLength:AbstractAttachment.kt$// We whitelist sources of transaction JARs for now as a temporary state until the DJVM and other security sandboxes // have been integrated, at which point we'll be able to run untrusted code downloaded over the network and this mechanism // can be removed. Because we ARE downloading attachments over the P2P network in anticipation of this upgrade, we // track the source of each attachment in our store. TestDSL is used by LedgerDSLInterpreter when custom attachments // are added in unit test code. val TRUSTED_UPLOADERS = listOf(DEPLOYED_CORDAPP_UPLOADER, RPC_UPLOADER, TESTDSL_UPLOADER) MaxLineLength:AbstractAttachment.kt$AbstractAttachment.Companion$ @DeleteForDJVM fun SerializeAsTokenContext.attachmentDataLoader(id: SecureHash): () -> ByteArray - MaxLineLength:AbstractCashFlow.kt$AbstractCashFlow$@Suspendable protected MaxLineLength:AbstractCashFlow.kt$CashException : FlowException - MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection - MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection$ @Suspendable fun unconsumedCashStatesForSpending(services: ServiceHub, amount: Amount<Currency>, onlyFromIssuerParties: Set<AbstractParty> = emptySet(), notary: Party? = null, lockId: UUID, withIssuerRefs: Set<OpaqueBytes> = emptySet()): List<StateAndRef<Cash.State>> MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection$ protected abstract fun executeQuery(connection: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, withResultSet: (ResultSet) -> Boolean): Boolean MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection$log.trace("Coin selection for $amount retrieved ${stateAndRefs.count()} states totalling $totalPennies pennies: $stateAndRefs") MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection$log.trace("Coin selection requested $amount but retrieved $totalPennies pennies with state refs: ${stateAndRefs.map { it.ref }}") MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection$onlyFromIssuerParties: Set<AbstractParty> MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection$private - MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection$val durationMillis = (minOf(retrySleep.shl(retryCount), retryCap / 2) * (1.0 + Math.random())).toInt() - MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection.Companion$"\nPlease specify an implementation in META-INF/services/${AbstractCashSelection::class.qualifiedName}." - MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection.Companion$val cashSelectionAlgos = ServiceLoader.load(AbstractCashSelection::class.java, this::class.java.classLoader).toList() MaxLineLength:AbstractCashSelection.kt$AbstractCashSelection.Companion${ instance.set(cashSelectionAlgo) cashSelectionAlgo } - MaxLineLength:AbstractNode.kt$AbstractNode$"match what's in the key store: $subject. You might need to adjust the configuration of `notary.serviceLegalName`." - MaxLineLength:AbstractNode.kt$AbstractNode$"or if you don't have one yet, fill out the config file and run corda.jar initial-registration. " - MaxLineLength:AbstractNode.kt$AbstractNode$( CertificateType.LEGAL_IDENTITY, nodeCaCert.subjectX500Principal, nodeCaCert.publicKey, cryptoService.getSigner(X509Utilities.CORDA_CLIENT_CA), nodeCaCert.subjectX500Principal, legalIdentityPublicKey, // TODO this might be smaller than DEFAULT_VALIDITY_WINDOW, shall we strictly apply DEFAULT_VALIDITY_WINDOW? X509Utilities.getCertificateValidityWindow( DEFAULT_VALIDITY_WINDOW.first, DEFAULT_VALIDITY_WINDOW.second, nodeCaCert) ) - MaxLineLength:AbstractNode.kt$AbstractNode$/** * Should be [rx.schedulers.Schedulers.io] for production, * or [rx.internal.schedulers.CachedThreadScheduler] (with shutdown registered with [runOnStop]) for shared-JVM testing. */ protected abstract val rxIoScheduler: Scheduler MaxLineLength:AbstractNode.kt$AbstractNode$// Ideally we should be disabling the FinalityHandler if it's not needed, to prevent any party from submitting transactions to us without // us checking. Previously this was gated on app target version and if there were no apps with target version <= 3 then the handler would // be disabled. However this prevents seemless rolling-upgrades and so it was removed until a better solution comes along. private fun installFinalityHandler() - MaxLineLength:AbstractNode.kt$AbstractNode$// TODO Cancelling parameters updates - if we do that, how we ensure that no one uses cancelled parameters in the transactions? val networkMapUpdater = NetworkMapUpdater( networkMapCache, NodeInfoWatcher( configuration.baseDirectory, @Suppress("LeakingThis") rxIoScheduler, Duration.ofMillis(configuration.additionalNodeInfoPollingFrequencyMsec) ), networkMapClient, configuration.baseDirectory, configuration.extraNetworkMapKeys, networkParametersStorage ).closeOnStop() MaxLineLength:AbstractNode.kt$AbstractNode$AllCertificateStores MaxLineLength:AbstractNode.kt$AbstractNode$CheckpointVerifier.verifyCheckpointsCompatible(checkpointStorage, cordappProvider.cordapps, versionInfo.platformVersion, services, tokenizableServices) - MaxLineLength:AbstractNode.kt$AbstractNode$ServiceInstantiationException : CordaException - MaxLineLength:AbstractNode.kt$AbstractNode$cordapp.initiatedFlows.groupBy { it.requireAnnotation<InitiatedBy>().value.java } MaxLineLength:AbstractNode.kt$AbstractNode$database.startHikariPool(props, configuration.database, schemaService.internalSchemas(), metricRegistry, this.cordappLoader, configuration.baseDirectory, configuration.myLegalName) MaxLineLength:AbstractNode.kt$AbstractNode$flowManager.registerInitiatedCoreFlowFactory(ContractUpgradeFlow.Initiate::class, NotaryChangeHandler::class, ::ContractUpgradeHandler) - MaxLineLength:AbstractNode.kt$AbstractNode$flowManager.registerInitiatedCoreFlowFactory(NotaryChangeFlow::class, NotaryChangeHandler::class, ::NotaryChangeHandler) - MaxLineLength:AbstractNode.kt$AbstractNode$flowManager.registerInitiatedCoreFlowFactory(SwapIdentitiesFlow::class, SwapIdentitiesHandler::class, ::SwapIdentitiesHandler) - MaxLineLength:AbstractNode.kt$AbstractNode$if (!cryptoService.containsKey(legalIdentityPrivateKeyAlias) && !signingCertificateStore.contains(legalIdentityPrivateKeyAlias)) { log.info("$legalIdentityPrivateKeyAlias not found in key store, generating fresh key!") createAndStoreLegalIdentity(legalIdentityPrivateKeyAlias) signingCertificateStore = configuration.signingCertificateStore.get() // We need to resync after [createAndStoreLegalIdentity]. } else { checkAliasMismatch(legalIdentityPrivateKeyAlias, signingCertificateStore) } - MaxLineLength:AbstractNode.kt$AbstractNode$log - MaxLineLength:AbstractNode.kt$AbstractNode$log.error("Corda service ${it.name} failed to instantiate. Reason was: ${e.cause?.rootMessage}", e.cause) - MaxLineLength:AbstractNode.kt$AbstractNode$log.error("Error while adding key fingerprint $it to cordappSignerKeyFingerprintBlacklist due to ${e.message}", e) MaxLineLength:AbstractNode.kt$AbstractNode$log.warn("Found more than one node registration with our legal name, this is only expected if our keypair has been regenerated") - MaxLineLength:AbstractNode.kt$AbstractNode$networkParametersStorage.setCurrentParameters(signedNetParams, trustRoot) identityService.loadIdentities(nodeInfo.legalIdentitiesAndCerts) attachments.start() cordappProvider.start() nodeProperties.start() // Place the long term identity key in the KMS. Eventually, this is likely going to be separated again because // the KMS is meant for derived temporary keys used in transactions, and we're not supposed to sign things with // the identity key. But the infrastructure to make that easy isn't here yet. keyManagementService.start(keyPairs) val notaryService = maybeStartNotaryService(myNotaryIdentity) installCordaServices() contractUpgradeService.start() vaultService.start() ScheduledActivityObserver.install(vaultService, schedulerService, flowLogicRefFactory) val frozenTokenizableServices = tokenizableServices!! tokenizableServices = null verifyCheckpointsCompatible(frozenTokenizableServices) smm.start(frozenTokenizableServices) // Shut down the SMM so no Fibers are scheduled. runOnStop += { smm.stop(acceptableLiveFiberCountOnStop()) } (smm as? StateMachineManagerInternal)?.let { val flowMonitor = FlowMonitor({ smm.snapshot().filter { flow -> flow !in smm.flowHospital }.toSet() }, configuration.flowMonitorPeriodMillis, configuration.flowMonitorSuspensionLoggingThresholdMillis) runOnStop += flowMonitor::stop flowMonitor.start() } schedulerService.start() createStartedNode(nodeInfo, rpcOps, notaryService).also { _started = it } MaxLineLength:AbstractNode.kt$AbstractNode$private - MaxLineLength:AbstractNode.kt$AbstractNode$protected open - MaxLineLength:AbstractNode.kt$AbstractNode$protected open fun generateKeyPair(alias: String) - MaxLineLength:AbstractNode.kt$AbstractNode$protected val cacheFactory = cacheFactoryPrototype.bindWithConfig(configuration).bindWithMetrics(metricRegistry).tokenize() - MaxLineLength:AbstractNode.kt$AbstractNode$return NodeVaultService(platformClock, keyManagementService, services, database, schemaService, cordappLoader.appClassLoader) - MaxLineLength:AbstractNode.kt$AbstractNode$signingCertificateStore = configuration.signingCertificateStore.get() MaxLineLength:AbstractNode.kt$AbstractNode$throw ConfigurationException("The name '$legalName' for $NODE_IDENTITY_ALIAS_PREFIX doesn't match what's in the key store: $subject") MaxLineLength:AbstractNode.kt$AbstractNode$throw ConfigurationException("The name of the notary service '$serviceLegalName' for $DISTRIBUTED_NOTARY_ALIAS_PREFIX doesn't " + "match what's in the key store: $subject. You might need to adjust the configuration of `notary.serviceLegalName`.") - MaxLineLength:AbstractNode.kt$AbstractNode$throw IllegalArgumentException("At least one of the keystores or truststore passwords does not match configuration.") MaxLineLength:AbstractNode.kt$AbstractNode$throw IllegalStateException("CryptoService and signingCertificateStore are not aligned, the entry for key-alias: $alias is only found in $keyExistsIn") - MaxLineLength:AbstractNode.kt$AbstractNode$val (netParams, signedNetParams) = NetworkParametersReader(trustRoot, networkMapClient, configuration.baseDirectory).read() - MaxLineLength:AbstractNode.kt$AbstractNode$val certificates = if (cryptoService.containsKey(compositeKeyAlias) && signingCertificateStore.contains(compositeKeyAlias)) { val certificate = signingCertificateStore[compositeKeyAlias] // We have to create the certificate chain for the composite key manually, this is because we don't have a keystore // provider that understand compositeKey-privateKey combo. The cert chain is created using the composite key certificate + // the tail of the private key certificates, as they are both signed by the same certificate chain. listOf(certificate) + privateKeyAliasCertChain.drop(1) } else { checkAliasMismatch(compositeKeyAlias, signingCertificateStore) // If [compositeKeyAlias] does not exist, we assume the notary is CFT, and each cluster member shares the same notary key pair. privateKeyAliasCertChain } - MaxLineLength:AbstractNode.kt$AbstractNode$val certificates: List<X509Certificate> = signingCertificateStore.query { getCertificateChain(legalIdentityPrivateKeyAlias) } MaxLineLength:AbstractNode.kt$AbstractNode$val cordappProvider = CordappProviderImpl(cordappLoader, CordappConfigFileProvider(configuration.cordappDirectories), attachments).tokenize() - MaxLineLength:AbstractNode.kt$AbstractNode$val extendedServiceConstructor = serviceClass.getDeclaredConstructor(AppServiceHub::class.java).apply { isAccessible = true } MaxLineLength:AbstractNode.kt$AbstractNode$val flowMonitor = FlowMonitor({ smm.snapshot().filter { flow -> flow !in smm.flowHospital }.toSet() }, configuration.flowMonitorPeriodMillis, configuration.flowMonitorSuspensionLoggingThresholdMillis) - MaxLineLength:AbstractNode.kt$AbstractNode$val keyExistsIn: String = if (cryptoService.containsKey(alias)) "CryptoService" else "signingCertificateStore" - MaxLineLength:AbstractNode.kt$AbstractNode$val networkMapClient: NetworkMapClient? = configuration.networkServices?.let { NetworkMapClient(it.networkMapURL, versionInfo) } - MaxLineLength:AbstractNode.kt$AbstractNode$val ops: CordaRPCOps = CordaRPCOpsImpl(services, smm, flowStarter) { shutdownExecutor.submit { stop() } }.also { it.closeOnStop() } MaxLineLength:AbstractNode.kt$AbstractNode$val servicesForResolution = ServicesForResolutionImpl(identityService, attachments, cordappProvider, networkParametersStorage, transactionStorage).also { attachments.servicesForResolution = it } - MaxLineLength:AbstractNode.kt$AbstractNode${ // The following will throw IOException if key file not found or KeyStoreException if keystore password is incorrect. val sslKeyStore = configuration.p2pSslOptions.keyStore.get() val signingCertificateStore = configuration.signingCertificateStore.get() val trustStore = configuration.p2pSslOptions.trustStore.get() AllCertificateStores(trustStore, sslKeyStore, signingCertificateStore) } - MaxLineLength:AbstractNode.kt$AbstractNode${ checkAliasMismatch(compositeKeyAlias, signingCertificateStore) // If [compositeKeyAlias] does not exist, we assume the notary is CFT, and each cluster member shares the same notary key pair. privateKeyAliasCertChain } - MaxLineLength:AbstractNode.kt$AbstractNode${ val certificate = signingCertificateStore[compositeKeyAlias] // We have to create the certificate chain for the composite key manually, this is because we don't have a keystore // provider that understand compositeKey-privateKey combo. The cert chain is created using the composite key certificate + // the tail of the private key certificates, as they are both signed by the same certificate chain. listOf(certificate) + privateKeyAliasCertChain.drop(1) } - MaxLineLength:AbstractNode.kt$AbstractNode${ val loadedServices = cordappLoader.cordapps.flatMap { it.services } // This sets the Cordapp classloader on the contextClassLoader of the current thread, prior to initializing services // Needed because of bug CORDA-2653 - some Corda services can utilise third-party libraries that require access to // the Thread context class loader val oldContextClassLoader : ClassLoader? = Thread.currentThread().contextClassLoader try { Thread.currentThread().contextClassLoader = cordappLoader.appClassLoader loadedServices.forEach { try { installCordaService(it) } catch (e: NoSuchMethodException) { log.error("${it.name}, as a Corda service, must have a constructor with a single parameter of type " + ServiceHub::class.java.name) } catch (e: ServiceInstantiationException) { if (e.cause != null) { log.error("Corda service ${it.name} failed to instantiate. Reason was: ${e.cause?.rootMessage}", e.cause) } else { log.error("Corda service ${it.name} failed to instantiate", e) } } catch (e: Exception) { log.error("Unable to install Corda service ${it.name}", e) } } } finally { Thread.currentThread().contextClassLoader = oldContextClassLoader } } MaxLineLength:AbstractNode.kt$AbstractNode.AppServiceHubImpl$private MaxLineLength:AbstractNode.kt$AbstractNode.AppServiceHubImpl$require(logicType.isAnnotationPresent(StartableByService::class.java)) { "${logicType.name} was not designed for starting by a CordaService" } - MaxLineLength:AbstractNode.kt$AbstractNode.ServiceHubInternalImpl$inner - MaxLineLength:AbstractNode.kt$AbstractNode.ServiceHubInternalImpl$override val networkParametersService: NetworkParametersStorage get() = this@AbstractNode.networkParametersStorage - MaxLineLength:AbstractNode.kt$AbstractNode.ServiceHubInternalImpl$override val transactionVerifierService: TransactionVerifierService get() = this@AbstractNode.transactionVerifierService - MaxLineLength:AbstractNode.kt$AbstractNode<S> : SingletonSerializeAsToken - MaxLineLength:AbstractNode.kt$FlowStarterImpl : FlowStarter - MaxLineLength:AbstractNode.kt$JavaTypeDescriptorRegistry.INSTANCE.addDescriptor(AbstractPartyDescriptor(wellKnownPartyFromX500Name, wellKnownPartyFromAnonymous)) MaxLineLength:AbstractNode.kt$ex is HikariPool.PoolInitializationException -> throw CouldNotCreateDataSourceException("Could not connect to the database. Please check your JDBC connection URL, or the connectivity to the database.", ex) MaxLineLength:AbstractNode.kt$ex.cause is ClassNotFoundException -> throw CouldNotCreateDataSourceException("Could not find the database driver class. Please add it to the 'drivers' folder. See: https://docs.corda.net/corda-configuration-file.html") MaxLineLength:AbstractNode.kt$fun CordaPersistence.startHikariPool(hikariProperties: Properties, databaseConfig: DatabaseConfig, schemas: Set<MappedSchema>, metricRegistry: MetricRegistry? = null, cordappLoader: CordappLoader? = null, currentDir: Path? = null, ourName: CordaX500Name) MaxLineLength:AbstractNode.kt$return ClientRpcSslOptions(trustStorePath = nodeRpcOptions.sslConfig!!.keyStorePath, trustStorePassword = nodeRpcOptions.sslConfig!!.keyStorePassword) - MaxLineLength:AbstractNode.kt$return CordaPersistence(databaseConfig, schemaService.schemaOptions.keys, jdbcUrl, cacheFactory, attributeConverters, customClassLoader) MaxLineLength:AbstractNode.kt$val attributeConverters = listOf(PublicKeyToTextConverter(), AbstractPartyToX500NameAsStringConverter(wellKnownPartyFromX500Name, wellKnownPartyFromAnonymous)) - MaxLineLength:AbstractNodeTests.kt$AbstractNodeTests$return "jdbc:h2:file:$baseDir/persistence;DB_CLOSE_ON_EXIT=FALSE;LOCK_TIMEOUT=10000;WRITE_DELAY=100;AUTO_SERVER_PORT=0" - MaxLineLength:AbstractNodeTests.kt$AbstractNodeTests${ // Note this test also covers a transaction that CordaPersistence does while it's instantiating: val database = configureDatabase(hikariProperties(freshURL()), DatabaseConfig(), { null }, { null }) val log = mock<Logger>() // Don't care what happens here. // Actually 10 is enough to reproduce old code hang, as pool size is 10 and we leaked 9 connections and 1 is in flight: repeat(100) { logVendorString(database, log) } } - MaxLineLength:AbstractParty.kt$AbstractParty$ override fun equals(other: Any?): Boolean MaxLineLength:AbstractPartyDescriptor.kt$AbstractPartyDescriptor$private val wellKnownPartyFromAnonymous: (AbstractParty) -> Party? MaxLineLength:AbstractPartyToX500NameAsStringConverter.kt$AbstractPartyToX500NameAsStringConverter$private val wellKnownPartyFromAnonymous: (AbstractParty) -> Party? MaxLineLength:AbstractRPCTest.kt$AbstractRPCTest$startInVmRpcServer(ops = ops, rpcUser = rpcUser, configuration = serverConfiguration, queueDrainTimeout = queueDrainTimeout) - MaxLineLength:AbstractRPCTest.kt$AbstractRPCTest$startRpcClient<I>(broker.hostAndPort!!, rpcUser.username, rpcUser.password, clientConfiguration) MaxLineLength:AbstractStateReplacementFlow.kt$AbstractStateReplacementFlow$Acceptor<in T> : FlowLogic MaxLineLength:AbstractStateReplacementFlow.kt$AbstractStateReplacementFlow$Instigator<out S : ContractState, out T : ContractState, out M> : FlowLogic - MaxLineLength:AbstractStateReplacementFlow.kt$AbstractStateReplacementFlow$Proposal<out M> - MaxLineLength:AbstractStateReplacementFlow.kt$AbstractStateReplacementFlow.Acceptor$ @Throws(StateReplacementException::class) protected abstract fun verifyProposal(stx: SignedTransaction, proposal: Proposal<T>) - MaxLineLength:AbstractStateReplacementFlow.kt$AbstractStateReplacementFlow.Acceptor$override val progressTracker: ProgressTracker = Acceptor.tracker() - MaxLineLength:AbstractStateReplacementFlow.kt$AbstractStateReplacementFlow.Acceptor$require(myKey in requiredKeys) { "Party is not a participant for any of the input states of transaction ${stx.id}" } MaxLineLength:AbstractStateReplacementFlow.kt$AbstractStateReplacementFlow.Instigator$@Suspendable private MaxLineLength:AbstractStateReplacementFlow.kt$AbstractStateReplacementFlow.Instigator$return excludeHostNode(serviceHub, groupAbstractPartyByWellKnownParty(serviceHub, originalState.state.data.participants)).map { initiateFlow(it.key) to it.value } - MaxLineLength:Action.kt$Action$RetryFlowFromSafePoint : Action - MaxLineLength:Action.kt$Action$ScheduleFlowTimeout : Action - MaxLineLength:Action.kt$Action.PersistCheckpoint$data - MaxLineLength:Action.kt$FlowRemovalReason${ data class OrderlyFinish(val flowReturnValue: Any?) : FlowRemovalReason() data class ErrorFinish(val flowErrors: List<FlowError>) : FlowRemovalReason() object SoftShutdown : FlowRemovalReason() { override fun toString() = "SoftShutdown" } // TODO Should we remove errored flows? How will the flow hospital work? Perhaps keep them in memory for a while, flush // them after a timeout, reload them on flow hospital request. In any case if we ever want to remove them // (e.g. temporarily) then add a case for that here. } MaxLineLength:ActionExecutorImpl.kt$ActionExecutorImpl$flowMessaging.sendSessionMessage(sessionState.peerParty, existingMessage, SenderDeduplicationId(deduplicationId, action.senderUUID)) MaxLineLength:ActionExecutorImpl.kt$ActionExecutorImpl$private val checkpointBandwidth = metrics.register("Flows.CheckpointVolumeBytesPerSecondCurrent", LatchedGauge(checkpointSizesThisSecond)) MaxLineLength:ActionExecutorImpl.kt$ActionExecutorImpl$private val checkpointBandwidthHist = metrics.register("Flows.CheckpointVolumeBytesPerSecondHist", Histogram(SlidingTimeWindowArrayReservoir(1, TimeUnit.DAYS))) - MaxLineLength:AdditionP2PAddressModeTest.kt$AdditionP2PAddressModeTest$driver - MaxLineLength:AdditionP2PAddressModeTest.kt$AdditionP2PAddressModeTest$haConfig["additionalP2PAddresses"] = ConfigValueFactory.fromIterable(listOf(altAddress)) - MaxLineLength:AdditionP2PAddressModeTest.kt$AdditionP2PAddressModeTest$startNode(providedName = DUMMY_BANK_A_NAME, rpcUsers = listOf(testUser), customOverrides = haConfig) MaxLineLength:AdditionP2PAddressModeTest.kt$AdditionP2PAddressModeTest$startNode(providedName = DUMMY_BANK_B_NAME, rpcUsers = listOf(testUser), customOverrides = mapOf("p2pAddress" to portAllocation.nextHostAndPort().toString())) - MaxLineLength:Address.kt$Address.Companion$return Validated.invalid(sequenceOf("Value format is \"<host(String)>:<port:(Int)>\"").map(mapError).toSet()) MaxLineLength:AddressBindingFailureTests.kt$AddressBindingFailureTests$@Test fun `H2 address`() - MaxLineLength:AddressBindingFailureTests.kt$AddressBindingFailureTests$@Test fun `rpc address`() MaxLineLength:AddressBindingFailureTests.kt$AddressBindingFailureTests$@Test fun `rpc admin address`() MaxLineLength:AddressBindingFailureTests.kt$AddressBindingFailureTests$assertThat(exception.addresses).contains(address).withFailMessage("Expected addresses to contain $address but was ${exception.addresses}.") MaxLineLength:AddressBindingFailureTests.kt$AddressBindingFailureTests$assertThatThrownBy { startNode(customOverrides = overrides(address)).getOrThrow() } MaxLineLength:AddressBindingFailureTests.kt$AddressBindingFailureTests$driver - MaxLineLength:AffinityExecutor.kt$AffinityExecutor$ fun executeASAP(runnable: () -> Unit) - MaxLineLength:AggregatedList.kt$AggregatedList<A, E : Any, K : Any> : TransformationList MaxLineLength:AliasPrivateKeyTest.kt$AliasPrivateKeyTest$signingCertStore.query { setPrivateKey(alias, aliasPrivateKey, listOf(NOT_YET_REGISTERED_MARKER_KEYS_AND_CERTS.ECDSAR1_CERT), "entrypassword") } MaxLineLength:AliasPrivateKeyTest.kt$AliasPrivateKeyTest$val signingCertStore = CertificateStoreStubs.Signing.withCertificatesDirectory(certificatesDirectory, "keystorepass").get(createNew = true) MaxLineLength:AliasPrivateKeyTest.kt$AliasPrivateKeyTest${ val alias = "01234567890" val aliasPrivateKey = AliasPrivateKey(alias) val certificatesDirectory = tempFolder.root.toPath() val signingCertStore = CertificateStoreStubs.Signing.withCertificatesDirectory(certificatesDirectory, "keystorepass").get(createNew = true) signingCertStore.query { setPrivateKey(alias, aliasPrivateKey, listOf(NOT_YET_REGISTERED_MARKER_KEYS_AND_CERTS.ECDSAR1_CERT), "entrypassword") } // We can retrieve the certificate. assertTrue { signingCertStore.contains(alias) } // We can retrieve the certificate. assertEquals(NOT_YET_REGISTERED_MARKER_KEYS_AND_CERTS.ECDSAR1_CERT, signingCertStore[alias]) // Although we can store an AliasPrivateKey, we cannot retrieve it. But, it's fine as we use certStore for storing/handling certs only. assertThatIllegalArgumentException().isThrownBy { signingCertStore.query { getPrivateKey(alias, "entrypassword") } }.withMessage("Unrecognised algorithm: 1.3.6.1.4.1.50530.1.2") } - MaxLineLength:AllButBlacklisted.kt$AllButBlacklisted : ClassWhitelist - MaxLineLength:AllButBlacklisted.kt$AllButBlacklisted$ override fun hasListed(type: Class<*>): Boolean MaxLineLength:AllButBlacklisted.kt$AllButBlacklisted$throw IllegalStateException("The $matchType $aMatch of ${type.name} is blacklisted, so it cannot be used in serialization.") - MaxLineLength:AllButBlacklisted.kt$AllButBlacklisted${ // TODO: blacklistedClasses += type.name // add it, so checking is faster next time we encounter this class. val matchType = if (Class.forName(aMatch).isInterface) "superinterface" else "superclass" throw IllegalStateException("The $matchType $aMatch of ${type.name} is blacklisted, so it cannot be used in serialization.") } - MaxLineLength:Amount.kt$Amount$Companion - MaxLineLength:Amount.kt$Amount$operator - MaxLineLength:Amount.kt$Amount$require(other.displayTokenSize == displayTokenSize) { "Token size mismatch: ${other.displayTokenSize} vs $displayTokenSize" } - MaxLineLength:Amount.kt$Amount${ // Amount represents a static balance of physical assets as managed by the distributed ledger and is not allowed // to become negative a rule further maintained by the Contract verify method. // N.B. If concepts such as an account overdraft are required this should be modelled separately via Obligations, // or similar second order smart contract concepts. require(quantity >= 0) { "Negative amounts are not allowed: $quantity" } } - MaxLineLength:Amount.kt$Amount.Companion$ @JvmStatic @JvmOverloads fun <T : Any> fromDecimal(displayQuantity: BigDecimal, token: T, rounding: RoundingMode = RoundingMode.FLOOR): Amount<T> - MaxLineLength:Amount.kt$Amount.Companion$ @JvmStatic fun <T : Any> Iterable<Amount<T>>.sumOrZero(token: T) MaxLineLength:Amount.kt$Amount<T : Any> : Comparable - MaxLineLength:Amount.kt$AmountTransfer$ @Suppress("UNUSED") fun novate(centralParty: P): List<AmountTransfer<T, P>> - MaxLineLength:Amount.kt$AmountTransfer$ fun apply(balances: List<SourceAndAmount<T, P>>, newRef: Any? = null): List<SourceAndAmount<T, P>> - MaxLineLength:Amount.kt$AmountTransfer$destination: P = this.destination MaxLineLength:Amount.kt$AmountTransfer$remaining = SourceAndAmount(payer, balance.amount.copy(quantity = Math.subtractExact(balance.amount.quantity, residual)), newRef) MaxLineLength:Amount.kt$AmountTransfer$result = 31 * result + (source.hashCode() xor destination.hashCode()) - MaxLineLength:Amount.kt$AmountTransfer.Companion$ @JvmStatic @JvmOverloads fun <T : Any, P : Any> fromDecimal(displayQuantityDelta: BigDecimal, token: T, source: P, destination: P, rounding: RoundingMode = RoundingMode.DOWN): AmountTransfer<T, P> - MaxLineLength:Amount.kt$AmountTransfer.Companion$destination: P - MaxLineLength:Amount.kt$AmountTransfer<T : Any, P : Any> MaxLineLength:Amount.kt$TokenizableAssetInfo$/** The nominal display unit size of a single token, potentially with trailing decimal display places if the scale parameter is non-zero. */ val displayTokenSize: BigDecimal - MaxLineLength:AmountTest.kt$AmountTest$assertThat(yamlMapper.valueToTree<TextNode>(Amount.parseCurrency("$250000"))).isEqualTo(TextNode("250000.00 USD")) - MaxLineLength:AmountTest.kt$AmountTest$assertThat(yamlMapper.valueToTree<TextNode>(Amount.parseCurrency("£25000000"))).isEqualTo(TextNode("25000000.00 GBP")) MaxLineLength:AmountTests.kt$AmountTests$val collector = Collectors.toMap<SourceAndAmount<Currency, String>, Pair<String, Currency>, BigDecimal>({ Pair(it.source, it.amount.token) }, { it.amount.toDecimal() }, { x, y -> x + y }) - MaxLineLength:AnalysisConfiguration.kt$AnalysisConfiguration.Companion$sourceClassLoaderFactory: (ClassResolver, BootstrapClassLoader?) -> SourceClassLoader = { classResolver, bootstrapCL -> SourceClassLoader(emptyList(), classResolver, bootstrapCL) } - MaxLineLength:AnalyticsEngine.kt$AnalyticsEngine$ratesProvider: ImmutableRatesProvider MaxLineLength:AnalyticsEngine.kt$OGSIMMAnalyticsEngine$ override fun calculateSensitivitiesBatch(trades: List<ResolvedSwapTrade>, pricer: DiscountingSwapProductPricer, ratesProvider: ImmutableRatesProvider): Map<ResolvedSwapTrade, CurrencyAmount> MaxLineLength:AnalyticsEngine.kt$OGSIMMAnalyticsEngine$override - MaxLineLength:AnalyticsEngine.kt$OGSIMMAnalyticsEngine$portfolioMargin: InitialMarginTriple - MaxLineLength:AnalyticsEngine.kt$OGSIMMAnalyticsEngine$ratesProvider: ImmutableRatesProvider - MaxLineLength:AnalyticsEngine.kt$OGSIMMAnalyticsEngine$val calculatorTotal = RwamBimmNotProductClassesCalculator(fxRateProvider, Currency.EUR, IsdaConfiguration.INSTANCE) MaxLineLength:AnalyticsEngine.kt$OGSIMMAnalyticsEngine$val t = BimmAnalysisUtils.computeMargin(combinedRatesProvider, normalizer, calculatorTotal, it.value.currencyParameterSensitivities, it.value.multiCurrencyAmount) MaxLineLength:AnotherDummyContract.kt$AnotherDummyContract$return TransactionBuilder(notary).withItems(StateAndContract(state, ANOTHER_DUMMY_PROGRAM_ID), Command(Commands.Create(), owner.party.owningKey)) - MaxLineLength:AppServiceHub.kt$AppServiceHub : ServiceHub - MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase$ fun addWithDuplicatesAllowed(key: K, value: V, logWarning: Boolean = true): Boolean MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase$ operator fun set(key: K, value: V) MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase$is Transactional.Committed<V> -> oldValueInCache MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase$log.warn("Double insert in ${this.javaClass.name} for entity class $persistentEntityClass key $key, not inserting the second time") MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase${ // IMPORTANT: The flush is needed because detach() makes the queue of unflushed entries invalid w.r.t. Hibernate internal state if the found entity is unflushed. // We want the detach() so that we rely on our cache memory management and don't retain strong references in the Hibernate session. session.flush() } - MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase${ // If someone is writing (but not us) // For those not writing, they need to re-load the value from the database (which their database transaction MIGHT see). // For those writing, they need to re-load the value from the database (which their database transaction CAN see). Transactional.InFlight(this, key, { loadValue(key) }, { loadValue(key)!! }) } - MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase${ // If we found a value already in the database, and we were not already writing, then it's already committed but got evicted. Transactional.Committed(oldValue) } MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase${ // 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, _readerValueLoader = { loadValue(key) }).apply { alsoWrite(value) } } - MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase.Transactional$InFlight<K, T> : Transactional - MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase.Transactional.InFlight$// The value from the perspective of the eviction algorithm of the cache. i.e. we want to reveal memory footprint to it etc. override val peekableValue: T? get() = if (writerValueLoader.get() != _writerValueLoader) writerValueLoader.get()() else if (readerValueLoader.get() != _writerValueLoader) readerValueLoader.get()() else null MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase.Transactional.InFlight$get() = if (isPresentAsWriter) loadAsWriter() else if (isPresentAsReader) loadAsReader()!! else throw NoSuchElementException("Not present") MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase.Transactional.InFlight$get() = if (writerValueLoader.get() != _writerValueLoader) writerValueLoader.get()() else if (readerValueLoader.get() != _writerValueLoader) readerValueLoader.get()() else null MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase.Transactional.InFlight$private val _writerValueLoader: () -> T = { throw IllegalAccessException("No value loader provided") } MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase.Transactional.InFlight${ // Make the lazy loader the writers see actually just return the value that has been set. 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. val tx = contextTransaction val strongKey = key val weakValue = WeakReference<T>(_value) val strongComitted = committed val strongMap = map if (map.addPendingKey(key, tx)) { // If the transaction commits, update cache to make globally visible if we're first for this key, // and then stop saying the transaction is writing the key. tx.onCommit { if (strongComitted.compareAndSet(false, true)) { val dereferencedValue = weakValue.get() if (dereferencedValue != null) { strongMap.cache.put(strongKey, Committed(dereferencedValue)) } } strongMap.removePendingKey(strongKey, tx) } // If the transaction rolls back, stop saying this transaction is writing the key. tx.onRollback { strongMap.removePendingKey(strongKey, tx) } } } - MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase.Transactional.Unknown$val readValue = _valueLoader() // We re-write the value into the cache so that any weigher can re-assess the weight based on the loaded value. map.cache.asMap().compute(key) { _, oldValue -> if (oldValue === this@Unknown) { if (readValue == null) Missing() else Committed(readValue) } else oldValue } readValue - MaxLineLength:AppendOnlyPersistentMap.kt$AppendOnlyPersistentMapBase<K, V, E, out EK> MaxLineLength:AppendOnlyPersistentMapNonConcurrentTest.kt$AppendOnlyPersistentMapNonConcurrentTest$NodeSchemaService(setOf(MappedSchema(AppendOnlyPersistentMapTest::class.java, 1, listOf(AppendOnlyPersistentMapNonConcurrentTest.PersistentMapEntry::class.java)))) - MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest$NodeSchemaService(setOf(MappedSchema(AppendOnlyPersistentMapTest::class.java, 1, listOf(PersistentMapEntry::class.java)))) MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest$Scenario(true, ReadOrWrite.Write, ReadOrWrite.Read, Outcome.SuccessButErrorOnCommit, Outcome.Success) to Scenario(true, ReadOrWrite.Write, ReadOrWrite.Read, Outcome.SuccessButErrorOnCommit, Outcome.SuccessButErrorOnCommit) MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest$val remapped = mapOf(Scenario(true, ReadOrWrite.Read, ReadOrWrite.Write, Outcome.Success, Outcome.Fail) to Scenario(true, ReadOrWrite.Read, ReadOrWrite.Write, Outcome.Success, Outcome.SuccessButErrorOnCommit)) MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest$val remapped = mapOf(Scenario(true, ReadOrWrite.Read, ReadOrWrite.Write, Outcome.Success, Outcome.Fail) to Scenario(true, ReadOrWrite.Read, ReadOrWrite.Write, Outcome.SuccessButErrorOnCommit, Outcome.SuccessButErrorOnCommit), Scenario(true, ReadOrWrite.Write, ReadOrWrite.Read, Outcome.SuccessButErrorOnCommit, Outcome.Success) to Scenario(true, ReadOrWrite.Write, ReadOrWrite.Read, Outcome.SuccessButErrorOnCommit, Outcome.SuccessButErrorOnCommit)) MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest${ // Writes intentionally do not check the database first, so purging between read and write changes behaviour // Also, a purge after write causes the subsequent read to flush to the database, causing the read to generate a constraint violation when single threaded (in same database transaction). val remapped = mapOf(Scenario(true, ReadOrWrite.Read, ReadOrWrite.Write, Outcome.Success, Outcome.Fail) to Scenario(true, ReadOrWrite.Read, ReadOrWrite.Write, Outcome.SuccessButErrorOnCommit, Outcome.SuccessButErrorOnCommit), Scenario(true, ReadOrWrite.Write, ReadOrWrite.Read, Outcome.SuccessButErrorOnCommit, Outcome.Success) to Scenario(true, ReadOrWrite.Write, ReadOrWrite.Read, Outcome.SuccessButErrorOnCommit, Outcome.SuccessButErrorOnCommit)) scenario = remapped[scenario] ?: scenario prepopulateIfRequired() val map = createMap() val a = TestThread("A", map, true).apply { phase1.countDown() phase3.countDown() } val b = TestThread("B", map, true).apply { phase1.countDown() phase3.countDown() } try { database.transaction { a.run() map.invalidate() b.run() } } catch (t: PersistenceException) { // This only helps if thrown on commit, otherwise other latches not counted down. assertEquals(t.message, Outcome.SuccessButErrorOnCommit, a.outcome) } a.await(a::phase4) b.await(b::phase4) assertTrue(map.pendingKeysIsEmpty()) } - MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest.Companion$Scenario(false, ReadOrWrite.WriteDuplicateAllowed, ReadOrWrite.Read, Outcome.Success, Outcome.Fail, Outcome.Success) MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest.Companion$Scenario(false, ReadOrWrite.WriteDuplicateAllowed, ReadOrWrite.WriteDuplicateAllowed, Outcome.Success, Outcome.SuccessButErrorOnCommit, Outcome.Fail) - MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest.Companion$Scenario(true, ReadOrWrite.Write, ReadOrWrite.Write, Outcome.SuccessButErrorOnCommit, Outcome.SuccessButErrorOnCommit) - MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest.Companion$Scenario(true, ReadOrWrite.WriteDuplicateAllowed, ReadOrWrite.WriteDuplicateAllowed, Outcome.Fail, Outcome.Fail) MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest.TestThread$inner MaxLineLength:AppendOnlyPersistentMapTest.kt$AppendOnlyPersistentMapTest.TestThread$val outcome = if (name == "A") scenario.aExpected else if (singleThreaded) scenario.bExpectedIfSingleThreaded else scenario.bExpected - MaxLineLength:ArgumentUnwrapper.kt$ArgumentUnwrapper$fun unwrapString() MaxLineLength:ArgumentUnwrapper.kt$ArgumentUnwrapper${ unwrapString() } - MaxLineLength:Arrangement.kt$And : Arrangement - MaxLineLength:Arrangement.kt$Obligation$data - MaxLineLength:Arrangement.kt$RollOut$data - MaxLineLength:ArraySerializer.kt$PrimBooleanArraySerializer : PrimArraySerializer MaxLineLength:ArtemisBroker.kt$fun java.io.IOException.isBindingError() - MaxLineLength:ArtemisMessagingClient.kt$ArtemisMessagingClient$val session = sessionFactory!!.createSession(NODE_P2P_USER, NODE_P2P_USER, false, true, true, false, DEFAULT_ACK_BATCH_SIZE) - MaxLineLength:ArtemisMessagingComponent.kt$ArtemisMessagingComponent.Companion$const val PEERS_PREFIX = "${INTERNAL_PREFIX}peers." //TODO Come up with better name for common peers/services queue - MaxLineLength:ArtemisMessagingComponent.kt$ArtemisMessagingComponent.Companion.P2PMessagingHeaders$/** * In the operation mode where we have an out of process bridge we cannot correctly populate the Artemis validated user header * as the TLS does not terminate directly onto Artemis. We therefore use this internal only header to forward * the equivalent information from the Float. */ val bridgedCertificateSubject = SimpleString("sender-subject-name") MaxLineLength:ArtemisMessagingComponent.kt$ArtemisMessagingComponent.RemoteInboxAddress.Companion$require(address.startsWith(PEERS_PREFIX)) { "Failed to map address: $address to a remote topic as it is not in the $PEERS_PREFIX namespace" } - MaxLineLength:ArtemisMessagingServer.kt$ArtemisMessagingServer$ private fun ConfigurationImpl.configureAddressSecurity(): Configuration MaxLineLength:ArtemisMessagingServer.kt$ArtemisMessagingServer$acceptorConfigurations = mutableSetOf(p2pAcceptorTcpTransport(NetworkHostAndPort(messagingServerAddress.host, messagingServerAddress.port), config.p2pSslOptions)) MaxLineLength:ArtemisMessagingServer.kt$ArtemisMessagingServer$deleteNonDurableQueue - MaxLineLength:ArtemisMessagingServer.kt$ArtemisMessagingServer$deleteNonDurableQueue: Boolean = false MaxLineLength:ArtemisMessagingServer.kt$ArtemisMessagingServer$journalBufferSize_AIO = maxMessageSize + JOURNAL_HEADER_SIZE MaxLineLength:ArtemisMessagingServer.kt$ArtemisMessagingServer$journalBufferSize_NIO = maxMessageSize + JOURNAL_HEADER_SIZE - MaxLineLength:ArtemisMessagingServer.kt$ArtemisMessagingServer$journalFileSize = maxMessageSize + JOURNAL_HEADER_SIZE - MaxLineLength:ArtemisMessagingServer.kt$ArtemisMessagingServer$private - MaxLineLength:ArtemisMessagingServer.kt$ArtemisMessagingServer$securityRoles["$INTERNAL_PREFIX#"] = setOf(nodeInternalRole) - MaxLineLength:ArtemisMessagingTest.kt$ArtemisMessagingTest$handle.afterDatabaseTransaction() - MaxLineLength:ArtemisMessagingTest.kt$ArtemisMessagingTest$networkMapCache = PersistentNetworkMapCache(TestingNamedCacheFactory(), database, rigorousMock()).apply { start(emptyList()) } MaxLineLength:ArtemisMessagingTest.kt$ArtemisMessagingTest$private MaxLineLength:ArtemisMessagingTest.kt$ArtemisMessagingTest$val (messagingClient, receivedMessages) = createAndStartClientAndServer(clientMaxMessageSize = 100_000, serverMaxMessageSize = 50_000) - MaxLineLength:ArtemisMessagingTest.kt$ArtemisMessagingTest${ val receivedMessages = LinkedBlockingQueue<ReceivedMessage>() createMessagingServer(maxMessageSize = serverMaxMessageSize).start() val messagingClient = createMessagingClient(platformVersion = platformVersion) messagingClient.addMessageHandler(TOPIC) { message, _, handle -> database.transaction { handle.insideDatabaseTransaction() } handle.afterDatabaseTransaction() // We ACK first so that if it fails we won't get a duplicate in [receivedMessages] receivedMessages.add(message) } startNodeMessagingClient(maxMessageSize = clientMaxMessageSize) // Run after the handlers are added, otherwise (some of) the messages get delivered and discarded / dead-lettered. thread(isDaemon = true) { messagingClient.run() } return Pair(messagingClient, receivedMessages) } - MaxLineLength:ArtemisRpcBroker.kt$ArtemisRpcBroker$throw AddressBindingException(adminAddressOptional?.let { setOf(it, addresses.primary) } ?: setOf(addresses.primary)) MaxLineLength:ArtemisRpcBroker.kt$ArtemisRpcBroker$val serverConfiguration = RpcBrokerConfiguration(baseDirectory, maxMessageSize, jmxEnabled, addresses.primary, adminAddressOptional, sslOptions, useSsl, nodeConfiguration, shouldStartLocalShell) - MaxLineLength:ArtemisRpcBroker.kt$ArtemisRpcBroker.<no name provided>$return arrayOf(AppConfigurationEntry(name, AppConfigurationEntry.LoginModuleControlFlag.REQUIRED, options)) MaxLineLength:ArtemisRpcBroker.kt$ArtemisRpcBroker.Companion$fun withSsl(configuration: MutualSslConfiguration, address: NetworkHostAndPort, adminAddress: NetworkHostAndPort, sslOptions: BrokerRpcSslOptions, securityManager: RPCSecurityManager, maxMessageSize: Int, jmxEnabled: Boolean, baseDirectory: Path, shouldStartLocalShell: Boolean): ArtemisBroker MaxLineLength:ArtemisRpcBroker.kt$ArtemisRpcBroker.Companion$fun withoutSsl(configuration: MutualSslConfiguration, address: NetworkHostAndPort, adminAddress: NetworkHostAndPort, securityManager: RPCSecurityManager, maxMessageSize: Int, jmxEnabled: Boolean, baseDirectory: Path, shouldStartLocalShell: Boolean): ArtemisBroker MaxLineLength:ArtemisRpcBroker.kt$ArtemisRpcBroker.Companion$return ArtemisRpcBroker(address, adminAddress, null, false, securityManager, maxMessageSize, jmxEnabled, baseDirectory, configuration, shouldStartLocalShell) @@ -4103,8 +2830,6 @@ MaxLineLength:ArtemisRpcTests.kt$ArtemisRpcTests$ArtemisRpcBroker.withoutSsl(nodeSSlconfig, address, adminAddress, securityManager, maxMessageSize, jmxEnabled, baseDirectory, false) MaxLineLength:ArtemisRpcTests.kt$ArtemisRpcTests$InternalRPCMessagingClient(nodeSSlconfig, adminAddress, maxMessageSize, CordaX500Name("MegaCorp", "London", "GB"), RPCServerConfiguration.DEFAULT) MaxLineLength:ArtemisRpcTests.kt$ArtemisRpcTests$private - MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport - MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$( // Basic TCP target details. TransportConstants.HOST_PROP_NAME to hostAndPort.host, TransportConstants.PORT_PROP_NAME to hostAndPort.port, // Turn on AMQP support, which needs the protocol jar on the classpath. // Unfortunately we cannot disable core protocol as artemis only uses AMQP for interop. // It does not use AMQP messages for its own messages e.g. topology and heartbeats. // TODO further investigate how to ensure we use a well defined wire level protocol for Node to Node communications. TransportConstants.PROTOCOLS_PROP_NAME to "CORE,AMQP", TransportConstants.USE_GLOBAL_WORKER_POOL_PROP_NAME to (nodeSerializationEnv != null), TransportConstants.REMOTING_THREADS_PROPNAME to (if (nodeSerializationEnv != null) -1 else 1), // turn off direct delivery in Artemis - this is latency optimisation that can lead to //hick-ups under high load (CORDA-1336) TransportConstants.DIRECT_DELIVER to false) MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$fun p2pAcceptorTcpTransport(hostAndPort: NetworkHostAndPort, config: MutualSslConfiguration?, enableSSL: Boolean = true): TransportConfiguration MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$fun p2pAcceptorTcpTransport(hostAndPort: NetworkHostAndPort, keyStore: FileBasedCertificateStoreSupplier?, trustStore: FileBasedCertificateStoreSupplier?, enableSSL: Boolean = true): TransportConfiguration MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$fun p2pConnectorTcpTransport(hostAndPort: NetworkHostAndPort, config: MutualSslConfiguration?, enableSSL: Boolean = true): TransportConfiguration @@ -4112,248 +2837,106 @@ MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$fun rpcAcceptorTcpTransport(hostAndPort: NetworkHostAndPort, config: BrokerRpcSslOptions?, enableSSL: Boolean = true): TransportConfiguration MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$fun rpcConnectorTcpTransport(hostAndPort: NetworkHostAndPort, config: ClientRpcSslOptions?, enableSSL: Boolean = true): TransportConfiguration MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$fun rpcConnectorTcpTransportsFromList(hostAndPortList: List<NetworkHostAndPort>, config: ClientRpcSslOptions?, enableSSL: Boolean = true): List<TransportConfiguration> - MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$fun rpcInternalAcceptorTcpTransport(hostAndPort: NetworkHostAndPort, config: SslConfiguration): TransportConfiguration - MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$fun rpcInternalClientTcpTransport(hostAndPort: NetworkHostAndPort, config: SslConfiguration): TransportConfiguration - MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$internal val acceptorFactoryClassName = "org.apache.activemq.artemis.core.remoting.impl.netty.NettyAcceptorFactory" MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$options[TransportConstants.HANDSHAKE_TIMEOUT] = 0 MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$private MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$return TransportConfiguration(acceptorFactoryClassName, defaultArtemisOptions(hostAndPort) + defaultSSLOptions + config.toTransportOptions() + (TransportConstants.HANDSHAKE_TIMEOUT to 0)) MaxLineLength:ArtemisTcpTransport.kt$ArtemisTcpTransport.Companion$return TransportConfiguration(connectorFactoryClassName, defaultArtemisOptions(hostAndPort) + defaultSSLOptions + config.toTransportOptions()) MaxLineLength:ArtemisUtils.kt$require(messageSize <= limit) { "Message exceeds maxMessageSize network parameter, maxMessageSize: [$limit], message size: [$messageSize]" } - MaxLineLength:AssociatedList.kt$AssociatedList<K, out A, B> : ReadOnlyBackedObservableMapBase MaxLineLength:AsyncLoggerContextSelectorNoThreadLocal.kt$AsyncLoggerContextSelectorNoThreadLocal.Companion$return AsyncLoggerContextSelectorNoThreadLocal::class.java.name == PropertiesUtil.getProperties().getStringProperty(Constants.LOG4J_CONTEXT_SELECTOR) MaxLineLength:Attachment.kt$Attachment$/** * The parties that have correctly signed the whole attachment. * Even though this returns a list of party objects, it is not required that these parties exist on the network, but rather they are a mapping from the signing key to the X.500 name. * * Note: Anyone can sign attachments, not only Corda parties. It's recommended to use [signerKeys]. */ @Deprecated("Use signerKeys. There is no requirement that attachment signers are Corda parties.") val signers: List<Party> - MaxLineLength:AttachmentConstraint.kt$AttachmentConstraint$ fun isSatisfiedBy(attachment: Attachment): Boolean - MaxLineLength:AttachmentConstraint.kt$AutomaticPlaceholderConstraint : AttachmentConstraint - MaxLineLength:AttachmentConstraint.kt$AutomaticPlaceholderConstraint$throw UnsupportedOperationException("Contracts cannot be satisfied by an AutomaticPlaceholderConstraint placeholder.") MaxLineLength:AttachmentConstraint.kt$HashAttachmentConstraint$log.warn("Hash constraint check failed: $attachmentId does not match contract attachment JAR ${attachment.id} or contract attachment JAR is untrusted") - MaxLineLength:AttachmentConstraint.kt$NoConstraintPropagation - MaxLineLength:AttachmentConstraint.kt$SignatureAttachmentConstraint$log.debug("Checking signature constraints: verifying $key in contract attachment signer keys: ${attachment.signerKeys}") - MaxLineLength:AttachmentContract.kt$AttachmentContract$require(tx.attachments.any { it.id == state.hash }) {"At least one attachment in transaction must match hash ${state.hash}"} - MaxLineLength:AttachmentDemo.kt$require - MaxLineLength:AttachmentDemo.kt$require(connection.contentType == APPLICATION_OCTET_STREAM) { "Content-Type header was ${connection.contentType}" } - MaxLineLength:AttachmentDemo.kt$val bankBParty = rpc.partiesFromName("Bank B", false).firstOrNull() ?: throw IllegalArgumentException("Couldn't find Bank B party") - MaxLineLength:AttachmentDemo.kt$val connection = URL("http://localhost:$webPort/attachments/${state.hash}").openConnection() as HttpURLConnection - MaxLineLength:AttachmentDemo.kt$val notaryParty = rpc.partiesFromName("Notary", false).firstOrNull() ?: throw IllegalArgumentException("Couldn't find notary party") - MaxLineLength:AttachmentDemoTest.kt$AttachmentDemoTest$// run with a 10,000,000 bytes in-memory zip file. In practice, a slightly bigger file will be used (~10,002,000 bytes). @Test fun `attachment demo using a 10MB zip file`() MaxLineLength:AttachmentDemoTest.kt$AttachmentDemoTest$cordappsForAllNodes = listOf(findCordapp("net.corda.attachmentdemo.contracts"), findCordapp("net.corda.attachmentdemo.workflows")) - MaxLineLength:AttachmentDownloadServlet.kt$AttachmentDownloadServlet$log.warn("404 Not Found whilst trying to handle attachment download request for ${servletContext.contextPath}/$reqPath") - MaxLineLength:AttachmentLoadingTests.kt$AttachmentLoadingTests$alice.rpc.startFlow(::ConsumeAndBroadcastFlow, stateRef, bob.nodeInfo.singleIdentity()).returnValue.getOrThrow() MaxLineLength:AttachmentLoadingTests.kt$AttachmentLoadingTests$assertThatThrownBy { alice.rpc.startFlow(::ConsumeAndBroadcastFlow, stateRef, bob.nodeInfo.singleIdentity()).returnValue.getOrThrow() } - MaxLineLength:AttachmentLoadingTests.kt$AttachmentLoadingTests$assertThatThrownBy { alice.rpc.startFlow(::ConsumeAndBroadcastFlow, stateRef, bob.nodeInfo.singleIdentity()).returnValue.getOrThrow() } // ConsumeAndBroadcastResponderFlow re-throws any non-FlowExceptions with just their class name in the message so that // we can verify here Bob threw the correct exception .hasMessage(TransactionVerificationException.UntrustedAttachmentsException::class.java.name) - MaxLineLength:AttachmentLoadingTests.kt$AttachmentLoadingTests.Companion$"contaminate the tests. This is a known issue with the driver and we must work around it until it's fixed." - MaxLineLength:AttachmentLoadingTests.kt$AttachmentLoadingTests.Companion$"isolated module cannot be on the classpath as otherwise it will be pulled into the nodes the driver creates and " MaxLineLength:AttachmentLoadingTests.kt$AttachmentLoadingTests.Companion$val issuanceFlowClass: Class<FlowLogic<StateRef>> = uncheckedCast(loadFromIsolated("net.corda.isolated.workflows.IsolatedIssuanceFlow")) - MaxLineLength:AttachmentLoadingTests.kt$AttachmentLoadingTests.ConsumeAndBroadcastFlow${ val notary = serviceHub.networkMapCache.notaryIdentities[0] val stateAndRef = serviceHub.toStateAndRef<ContractState>(stateRef) val stx = serviceHub.signInitialTransaction( TransactionBuilder(notary) .addInputState(stateAndRef) .addOutputState(ConsumeContract.State()) .addCommand(Command(ConsumeContract.Cmd, ourIdentity.owningKey)) ) stx.verify(serviceHub, checkSufficientSignatures = false) val session = initiateFlow(otherSide) subFlow(FinalityFlow(stx, session)) // It's important we wait on this dummy receive, as otherwise it's possible we miss any errors the other side throws session.receive<String>().unwrap { require(it == "OK") { "Not OK: $it"} } } - MaxLineLength:AttachmentSerializationTest.kt$Attachment - MaxLineLength:AttachmentSerializationTest.kt$AttachmentSerializationTest$assertEquals("hacked", rebootClientAndGetAttachmentContent(false)) MaxLineLength:AttachmentSerializationTest.kt$AttachmentSerializationTest$client.hackAttachment(attachmentId, "hacked") MaxLineLength:AttachmentSerializationTest.kt$AttachmentSerializationTest$client.internals.disableDBCloseOnStop() MaxLineLength:AttachmentSerializationTest.kt$AttachmentSerializationTest$return (client.smm.allStateMachines[0].stateMachine.resultFuture.apply { mockNet.runNetwork() }.getOrThrow() as ClientResult).attachmentContent - MaxLineLength:AttachmentSerializationTest.kt$AttachmentSerializationTest.<no name provided>$override fun start() MaxLineLength:AttachmentSerializationTest.kt$AttachmentSerializationTest.CustomAttachmentLogic$private - MaxLineLength:AttachmentSerializationTest.kt$AttachmentSerializationTest.FetchAttachmentLogic$private - MaxLineLength:AttachmentSerializationTest.kt$AttachmentSerializationTest.OpenAttachmentLogic$private - MaxLineLength:AttachmentSerializationTest.kt$AttachmentSerializationTest.ServerLogic$private MaxLineLength:AttachmentSerializationTest.kt$val attachment = session.get<NodeAttachmentService.DBAttachment>(NodeAttachmentService.DBAttachment::class.java, attachmentId.toString()) - MaxLineLength:AttachmentStorage.kt$AttachmentStorage$ @Deprecated("More attachment information is required", replaceWith = ReplaceWith("importAttachment(jar, uploader, filename)")) @Throws(FileAlreadyExistsException::class, IOException::class) fun importAttachment(jar: InputStream): AttachmentId - MaxLineLength:AttachmentStorage.kt$AttachmentStorage$ fun getLatestContractAttachments(contractClassName: String, minContractVersion: Int = DEFAULT_CORDAPP_VERSION): List<AttachmentId> - MaxLineLength:AttachmentStorage.kt$AttachmentStorage$@Deprecated("More attachment information is required", replaceWith = ReplaceWith("importAttachment(jar, uploader, filename)")) - MaxLineLength:AttachmentStorageInternal.kt$AttachmentStorageInternal$ fun privilegedImportAttachment(jar: InputStream, uploader: String, filename: String?): AttachmentId - MaxLineLength:AttachmentTests.kt$AttachmentTests$private MaxLineLength:AttachmentTests.kt$AttachmentTests$val corruptAttachment = NodeAttachmentService.DBAttachment(attId = id.toString(), content = attachment, version = DEFAULT_CORDAPP_VERSION) MaxLineLength:AttachmentTests.kt$AttachmentTests.InitiatingFetchAttachmentsFlow$@InitiatingFlow private MaxLineLength:AttachmentVersionNumberMigration.kt$AttachmentVersionNumberMigration$logger.error("$msg skipped, network parameters not retrieved, could not determine node base directory due to system property $NODE_BASE_DIR_KEY being not set.") - MaxLineLength:AttachmentVersionNumberMigration.kt$AttachmentVersionNumberMigration$logger.info("$msg skipped, network parameters not found in $path, but there are no available attachments to migrate.") MaxLineLength:AttachmentVersionNumberMigration.kt$AttachmentVersionNumberMigration$logger.info("$msg using network parameters from $path, whitelistedContractImplementations: ${networkParameters.whitelistedContractImplementations}.") MaxLineLength:AttachmentVersionNumberMigration.kt$AttachmentVersionNumberMigration$logger.warn("Several versions based on whitelistedContractImplementations position are available: ${versions.toSet()}. $msg") MaxLineLength:AttachmentVersionNumberMigration.kt$AttachmentVersionNumberMigration$val versions = networkParameters?.whitelistedContractImplementations?.values.mapNotNull { it.indexOfFirst { it.toString() == attachmentId } }.filter { it >= 0 } - MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader : URLClassLoader MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader$"Please follow the operational steps outlined in https://docs.corda.net/cordapp-build-systems.html#cordapp-contract-attachments to learn more and continue." MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader$(path == "meta-inf/services/net.corda.core.serialization.serializationwhitelist") -> false MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader$else -> false - MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader$if (!isZipOrJar(attachment)) throw TransactionVerificationException.InvalidAttachmentException(sampleTxId, attachment.id) - MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader$log MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader$path.startsWith("meta-inf/services") -> true MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader$targetPlatformVersion < 4 && ignoreDirectories.any { path.startsWith(it) } -> false MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader${ // Make some preliminary checks to ensure that we're not loading invalid attachments. // All attachments need to be valid JAR or ZIP files. for (attachment in attachments) { if (!isZipOrJar(attachment)) throw TransactionVerificationException.InvalidAttachmentException(sampleTxId, attachment.id) } // Until we have a sandbox to run untrusted code we need to make sure that any loaded class file was whitelisted by the node administrator. val untrusted = attachments .filter(::containsClasses) .filterNot { attachment -> when (attachment) { is ContractAttachment -> isUploaderTrusted(attachment.uploader) is AbstractAttachment -> isUploaderTrusted(attachment.uploader) else -> false // This should not happen on normal code paths. } } .map(Attachment::id) if (untrusted.isNotEmpty()) { log.warn("Cannot verify transaction $sampleTxId as the following attachment IDs are untrusted: $untrusted." + "You will need to manually install the CorDapp to whitelist it for use. " + "Please follow the operational steps outlined in https://docs.corda.net/cordapp-build-systems.html#cordapp-contract-attachments to learn more and continue.") throw TransactionVerificationException.UntrustedAttachmentsException(sampleTxId, untrusted) } // Enforce the no-overlap and package ownership rules. checkAttachments(attachments) } - MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader${ val entry = jar.nextJarEntry ?: break if (entry.isDirectory) continue // We already verified that paths are not strange/game playing when we inserted the attachment // into the storage service. So we don't need to repeat it here. // // We forbid files that differ only in case, or path separator to avoid issues for Windows/Mac developers where the // 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('\\', '/') // Namespace ownership. We only check class files: resources are loaded relative to a JAR anyway. if (path.endsWith(".class")) { // Get the package name from the file name. Inner classes separate their names with $ not / // in file names so they are not a problem. val pkgName = path .dropLast(".class".length) .replace('/', '.') .split('.') .dropLast(1) .joinToString(".") 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) // We need an additional . to avoid matching com.foo.Widget against com.foobar.Zap if (pkgName == ns || pkgName.startsWith("$ns.")) { if (pubkey !in signers) throw PackageOwnershipException(sampleTxId, attachment.id, path, pkgName) } } } // Some files don't need overlap checking because they don't affect the way the code runs. if (!shouldCheckForNoOverlap(path, targetPlatformVersion)) continue // If 2 entries have the same content hash, it means the same file is present in both attachments, so that is ok. if (path in classLoaderEntries.keys) { val contentHash = readAttachment(attachment, path).sha256() val originalAttachment = classLoaderEntries[path]!! val originalContentHash = readAttachment(originalAttachment, path).sha256() if (contentHash == originalContentHash) { log.debug { "Duplicate entry $path has same content hash $contentHash" } continue } else { log.debug { "Content hash differs for $path" } throw OverlappingAttachmentsException(sampleTxId, path) } } log.debug { "Adding new entry for $path" } classLoaderEntries[path] = attachment } - MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoader.Companion$log.warn("The URLStreamHandlerFactory was already set in the JVM. Please be aware that this is not recommended.") MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoaderBuilder$ fun <T> withAttachmentsClassloaderContext(attachments: List<Attachment>, params: NetworkParameters, txId: SecureHash, parent: ClassLoader = ClassLoader.getSystemClassLoader(), block: (ClassLoader) -> T): T - MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoaderBuilder$private - MaxLineLength:AttachmentsClassLoader.kt$AttachmentsClassLoaderBuilder$val serializers = createInstancesOfClassesImplementing(transactionClassLoader, SerializationCustomSerializer::class.java) - MaxLineLength:AttachmentsClassLoaderSerializationTests.kt$AttachmentsClassLoaderSerializationTests$val att2 = storage.importAttachment(fakeAttachment("file2.txt", "some other data").inputStream(), "app", "file2.jar") MaxLineLength:AttachmentsClassLoaderSerializationTests.kt$AttachmentsClassLoaderSerializationTests$val serialisedState = AttachmentsClassLoaderBuilder.withAttachmentsClassloaderContext(arrayOf(isolatedId, att1, att2).map { storage.openAttachment(it)!! }, testNetworkParameters(), SecureHash.zeroHash) { classLoader -> val contractClass = Class.forName(ISOLATED_CONTRACT_CLASS_NAME, true, classLoader) val contract = contractClass.newInstance() as Contract assertEquals("helloworld", contract.declaredField<Any?>("magicString").value) val txt = IOUtils.toString(classLoader.getResourceAsStream("file1.txt"), Charsets.UTF_8.name()) assertEquals("some data", txt) val state = (contract as DummyContractBackdoor).generateInitial(MEGA_CORP.ref(1), 1, DUMMY_NOTARY).outputStates().first() val serialisedState = state.serialize() val state1 = serialisedState.deserialize() assertEquals(state, state1) serialisedState } - MaxLineLength:AttachmentsClassLoaderSerializationTests.kt$AttachmentsClassLoaderSerializationTests$val state = (contract as DummyContractBackdoor).generateInitial(MEGA_CORP.ref(1), 1, DUMMY_NOTARY).outputStates().first() - MaxLineLength:AttachmentsClassLoaderSerializationTests.kt$AttachmentsClassLoaderSerializationTests.Companion$val ISOLATED_CONTRACTS_JAR_PATH: URL = AttachmentsClassLoaderSerializationTests::class.java.getResource("/isolated.jar") - MaxLineLength:AttachmentsClassLoaderStaticContractTests.kt$AttachmentsClassLoaderStaticContractTests$doReturn(it.cordappProvider.getContractAttachmentID(AttachmentDummyContract.ATTACHMENT_PROGRAM_ID)).whenever(attachment).id - MaxLineLength:AttachmentsClassLoaderStaticContractTests.kt$AttachmentsClassLoaderStaticContractTests$return JarScanningCordappLoader.fromJarUrls(listOf(cordappWithPackages(*packages.toTypedArray()).jarFile.toUri().toURL())) MaxLineLength:AttachmentsClassLoaderStaticContractTests.kt$AttachmentsClassLoaderStaticContractTests$val cordappProviderImpl = CordappProviderImpl(cordappLoaderForPackages(listOf("net.corda.nodeapi.internal")), MockCordappConfigProvider(), MockAttachmentStorage()) - MaxLineLength:AttachmentsClassLoaderStaticContractTests.kt$AttachmentsClassLoaderStaticContractTests.AttachmentDummyContract$TransactionBuilder(notary) .withItems(StateAndContract(state, ATTACHMENT_PROGRAM_ID), Command(Commands.Create(), owner.party.owningKey)) MaxLineLength:AttachmentsClassLoaderStaticContractTests.kt$AttachmentsClassLoaderStaticContractTests.AttachmentDummyContract.Companion$const val ATTACHMENT_PROGRAM_ID = "net.corda.nodeapi.internal.AttachmentsClassLoaderStaticContractTests\$AttachmentDummyContract" - MaxLineLength:AttachmentsClassLoaderStaticContractTests.kt$import net.corda.nodeapi.internal.AttachmentsClassLoaderStaticContractTests.AttachmentDummyContract.Companion.ATTACHMENT_PROGRAM_ID - MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$make(arrayOf(trustedResourceJar, untrustedResourceJar, trustedClassJar, untrustedClassJar).map { storage.openAttachment(it)!! }) MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$private fun make(attachments: List<Attachment>, params: NetworkParameters = networkParameters) - MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val att1 = importAttachment(fakeAttachment("/folder1/foldera/file1.txt", "some data").inputStream(), "app", "file1.jar") MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val att1 = importAttachment(fakeAttachment("meta-inf/services/com.example.something", "some data").inputStream(), "app", "file1.jar") MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val att1 = importAttachment(fakeAttachment("meta-inf/services/net.corda.core.serialization.SerializationWhitelist", "some data").inputStream(), "app", "file1.jar") - MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val att2 = importAttachment(fakeAttachment("\\folder1\\folderb\\file2.txt", "some other data").inputStream(), "app", "file2.jar") MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val att2 = importAttachment(fakeAttachment("meta-inf/services/com.example.something", "some other data").inputStream(), "app", "file2.jar") MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val att2 = importAttachment(fakeAttachment("meta-inf/services/net.corda.core.serialization.SerializationWhitelist", "some other data").inputStream(), "app", "file2.jar") MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val att2 = importAttachment(fakeAttachment("net/corda/finance/contracts/isolated/AnotherDummyContract\$State.class", "some attackdata").inputStream(), "app", "file2.jar") - MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val att2 = storage.importAttachment(fakeAttachment("file1.txt", "some other data").inputStream(), "app", "file2.jar") - MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val isolatedSignedId = importAttachment(signedJar.first.toUri().toURL().openStream(), "app", "isolated-signed.jar") MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val trustedClassJar = importAttachment(fakeAttachment("/com/example/something/VirtuousClass.class", "some other data").inputStream(), "app", "file3.jar") - MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val trustedResourceJar = importAttachment(fakeAttachment("file1.txt", "some data").inputStream(), "app", "file0.jar") MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val untrustedClassJar = importAttachment(fakeAttachment("/com/example/something/MaliciousClass.class", "some malicious data").inputStream(), "untrusted", "file2.jar") MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests$val untrustedResourceJar = importAttachment(fakeAttachment("file2.txt", "some malicious data").inputStream(), "untrusted", "file1.jar") - MaxLineLength:AttachmentsClassLoaderTests.kt$AttachmentsClassLoaderTests.Companion$val ISOLATED_CONTRACTS_JAR_PATH_V4: URL = AttachmentsClassLoaderTests::class.java.getResource("isolated-4.0.jar") - MaxLineLength:AuditService.kt$AuditEvent - MaxLineLength:AuditService.kt$FlowPermissionAuditEvent : AuditEventFlowAuditInfo - MaxLineLength:AuthDBTests.kt$"bar" to "\$shiro1\$SHA-256$500000\$Q6dmdY1uVMm0LYAWaOHtCA==\$u7NbFaj9tHf2RTW54jedLPiOiGjJv0RVEPIjVquJuYY=" - MaxLineLength:AuthDBTests.kt$"foo" to "\$shiro1\$SHA-256$500000\$WSiEVj6q8d02sFcCk1dkoA==\$MBkU/ghdD9ovoDerdzNfkXdP9Bdhmok7tidvVIqGzcA=" - MaxLineLength:AuthDBTests.kt$"test" to "\$shiro1\$SHA-256$500000\$F6CWSFDDxGTlzvREwih8Gw==\$DQhyAPoUw3RdvNYJ1aubCnzEIXm+szGQ3HplaG+euz8=" - MaxLineLength:AuthDBTests.kt$PasswordEncryption.SHIRO_1_CRYPT -> hashedPasswords[format]!![s] ?: DefaultPasswordService().encryptPassword(s.toCharArray()) MaxLineLength:AuthDBTests.kt$UsersDB$private - MaxLineLength:AuthenticatedRpcOpsProxy.kt$AuthenticatedRpcOpsProxy$/** * Returns the RPC protocol version, which is the same the node's Platform Version. Exists since version 1 so guaranteed * to be present. * * TODO: Why is this logic duplicated vs the actual implementation? */ override val protocolVersion: Int get() = delegate.nodeInfo().platformVersion - MaxLineLength:AuthenticatedRpcOpsProxy.kt$AuthenticatedRpcOpsProxy$internal MaxLineLength:AuthenticatedRpcOpsProxy.kt$AuthenticatedRpcOpsProxy$override - MaxLineLength:AuthenticatedRpcOpsProxy.kt$AuthenticatedRpcOpsProxy.Companion$return Proxy.newProxyInstance(delegate::class.java.classLoader, arrayOf(CordaRPCOps::class.java), handler) as CordaRPCOps MaxLineLength:AuthenticatedRpcOpsProxy.kt$AuthenticatedRpcOpsProxy.PermissionsEnforcingInvocationHandler$override fun invoke(proxy: Any, method: Method, arguments: Array<out Any?>?) MaxLineLength:AuthenticatedRpcOpsProxy.kt$AuthenticatedRpcOpsProxy.PermissionsEnforcingInvocationHandler$private - MaxLineLength:AuthenticatedRpcOpsProxy.kt$private MaxLineLength:AuthenticatedRpcOpsProxy.kt$private fun <RESULT> guard(methodName: String, context: () -> RpcAuthContext, action: () -> RESULT) - MaxLineLength:AutoAcceptable.kt$AutoAcceptable - MaxLineLength:AutoOfferFlow.kt$AutoOfferFlow$ReportToRegulatorFlow : FlowLogic MaxLineLength:AutoOfferFlow.kt$AutoOfferFlow.Requester$val notary = serviceHub.networkMapCache.notaryIdentities.first() // TODO We should pass the notary as a parameter to the flow, not leave it to random choice. MaxLineLength:AutoOfferFlow.kt$AutoOfferFlow.Requester$val otherParty = excludeHostNode(serviceHub, groupAbstractPartyByWellKnownParty(serviceHub, dealToBeOffered.participants)).keys.single() - MaxLineLength:AutoOfferFlow.kt$AutoOfferFlow.Requester.Companion$// We vend a progress tracker that already knows there's going to be a TwoPartyTradingFlow involved at some // point: by setting up the tracker in advance, the user can see what's coming in more detail, instead of being // surprised when it appears as a new set of tasks below the current one. fun tracker() - MaxLineLength:AzureBackend.kt$AzureBackend.Companion$azure.resourceGroups().define(resourceGroupName).withRegion(context.extraParams[Constants.REGION_ARG_NAME]).create() - MaxLineLength:AzureBackend.kt$AzureBackend.Companion$val azureInstantiatorFuture = azureNetworkStore.thenCombine(registryLocatorFuture) { azureVolume, registryLocator -> AzureInstantiator(azure, registryLocator.registry, azureVolume, resourceGroup) } - MaxLineLength:AzureBackend.kt$AzureBackend.Companion$val resourceGroupName = context.networkName.replace(Constants.ALPHA_NUMERIC_DOT_AND_UNDERSCORE_ONLY_REGEX, "") - MaxLineLength:AzureInstantiator.kt$AzureInstantiator.<no name provided>$LOG.info("Completed instantiation: $instanceName is running at $fqdn with port(s) $portsToOpen exposed") - MaxLineLength:AzureRegistryLocator.kt$RegistryLocator$LOG.info("Did not find existing container registry - creating new registry with name ${resourceGroup.restFriendlyName()}") - MaxLineLength:AzureRegistryLocator.kt$RegistryLocator$val found = azure.containerRegistries().getByResourceGroup(resourceGroup.name(), resourceGroup.restFriendlyName()) - MaxLineLength:AzureSmbVolume.kt$AzureSmbVolume$networkParamsFile.uploadFromByteArray(networkParameters.signWithCert(keyPair.private, networkMapCert).serialize().bytes) MaxLineLength:BCCryptoService.kt$BCCryptoService : CryptoService - MaxLineLength:BCCryptoService.kt$BCCryptoService$certificateStore.query { setPrivateKey(alias, keyPair.private, listOf(cert), certificateStore.entryPassword) } MaxLineLength:BCCryptoService.kt$BCCryptoService$return ContentSignerBuilder.build(signatureScheme, privateKey, Crypto.findProvider(signatureScheme.providerName), newSecureRandom()) MaxLineLength:BCCryptoService.kt$BCCryptoService$throw CryptoServiceException("Cannot generate key for alias $alias and signature scheme ${scheme.schemeCodeName} (id ${scheme.schemeNumberID})", e) - MaxLineLength:BCCryptoService.kt$BCCryptoService$throw CryptoServiceException("Cannot sign using the key with alias $alias. SHA256 of data to be signed: ${data.sha256()}", e) - MaxLineLength:BCCryptoService.kt$BCCryptoService${ // Store a self-signed certificate, as Keystore requires to store certificates instead of public keys. // We could probably add a null cert, but we store a self-signed cert that will be used to retrieve the public key. val cert = X509Utilities.createSelfSignedCACertificate(legalName, keyPair) certificateStore.query { setPrivateKey(alias, keyPair.private, listOf(cert), certificateStore.entryPassword) } } - MaxLineLength:BCCryptoServiceTests.kt$BCCryptoServiceTests$Crypto.supportedSignatureSchemes().filter { it != Crypto.COMPOSITE_KEY }.forEach { generateKeyAndSignForScheme(cryptoService, it) } MaxLineLength:BFTNotaryServiceTests.kt$BFTNotaryServiceTests$addOutputState(DummyContract.SingleOwnerState(owner = info.singleIdentity()), DummyContract.PROGRAM_ID, AlwaysAcceptAttachmentConstraint) - MaxLineLength:BFTNotaryServiceTests.kt$BFTNotaryServiceTests$private MaxLineLength:BFTNotaryServiceTests.kt$BFTNotaryServiceTests.Companion$fun startBftClusterAndNode(clusterSize: Int, mockNet: InternalMockNetwork, exposeRaces: Boolean = false): Pair<Party, TestStartedNode> - MaxLineLength:BFTNotaryServiceTests.kt$BFTNotaryServiceTests.Companion$val networkParameters = NetworkParametersCopier(testNetworkParameters(listOf(NotaryInfo(notaryIdentity, false)))) - MaxLineLength:BFTNotaryServiceTests.kt$BFTNotaryServiceTests.Companion${ (Paths.get("config") / "currentView").deleteIfExists() // XXX: Make config object warn if this exists? val replicaIds = (0 until clusterSize) val serviceLegalName = CordaX500Name("BFT", "Zurich", "CH") val notaryIdentity = DevIdentityGenerator.generateDistributedNotaryCompositeIdentity( replicaIds.map { mockNet.baseDirectory(mockNet.nextNodeId + it) }, serviceLegalName) val networkParameters = NetworkParametersCopier(testNetworkParameters(listOf(NotaryInfo(notaryIdentity, false)))) val clusterAddresses = replicaIds.map { NetworkHostAndPort("localhost", 11000 + it * 10) } val nodes = replicaIds.map { replicaId -> mockNet.createUnstartedNode(InternalMockNodeParameters(configOverrides = { val notary = NotaryConfig( validating = false, bftSMaRt = BFTSmartConfig(replicaId, clusterAddresses, exposeRaces = exposeRaces), serviceLegalName = serviceLegalName ) doReturn(notary).whenever(it).notary })) } + mockNet.createUnstartedNode() // MockNetwork doesn't support BFT clusters, so we create all the nodes we need unstarted, and then install the // network-parameters in their directories before they're started. val node = nodes.map { node -> networkParameters.install(mockNet.baseDirectory(node.id)) node.start() }.last() return Pair(notaryIdentity, node) } - MaxLineLength:BFTSmart.kt$BFTSmart MaxLineLength:BFTSmart.kt$BFTSmart$Client : SingletonSerializeAsToken - MaxLineLength:BFTSmart.kt$BFTSmart$ClusterResponse - MaxLineLength:BFTSmart.kt$BFTSmart.Client$ private fun buildExtractor(): Extractor - MaxLineLength:BFTSmart.kt$BFTSmart.Client$log.debug { "BFT Client $clientId: number of replicas accepted the commit: ${accepted.size}, rejected: ${rejected.size}" } MaxLineLength:BFTSmart.kt$BFTSmart.Client$private val sessionTable = (proxy.communicationSystem as NettyClientServerCommunicationSystemClientSide).declaredField<Map<Int, NettyClientServerSession>>("sessionTable").value MaxLineLength:BFTSmart.kt$BFTSmart.Client${ // TODO: Hopefully we only need to wait for the client's initial connection to the cluster, and this method can be moved to some startup code. // TODO: Investigate ConcurrentModificationException in this method. while (true) { val inactive = sessionTable.entries.mapNotNull { if (it.value.channel.isActive) null else it.key } if (inactive.isEmpty()) break log.info("Client-replica channels not yet active: $clientId to $inactive") Thread.sleep((inactive.size * 100).toLong()) } } MaxLineLength:BFTSmart.kt$BFTSmart.CordaServiceReplica$private - MaxLineLength:BFTSmart.kt$BFTSmart.Replica$checkConflict(conflictingStates, references, StateConsumptionDetails.ConsumedStateType.REFERENCE_INPUT_STATE) - MaxLineLength:BFTSmart.kt$BFTSmart.Replica$private MaxLineLength:BFTSmart.kt$BFTSmart.Replica$val (committedStates, requests) = bytes.deserialize<Pair<LinkedHashMap<StateRef, SecureHash>, List<PersistentUniquenessProvider.Request>>>() - MaxLineLength:BFTSmart.kt$BFTSmart.Replica$val criteriaQuery = session.criteriaBuilder.createQuery(PersistentUniquenessProvider.Request::class.java) - MaxLineLength:BFTSmart.kt$BFTSmart.Replica$val deleteQuery = session.criteriaBuilder.createCriteriaDelete(PersistentUniquenessProvider.Request::class.java) MaxLineLength:BFTSmart.kt$BFTSmart.Replica$val signableData = SignableData(txId, SignatureMetadata(services.myInfo.platformVersion, Crypto.findSignatureScheme(notaryIdentityKey).schemeNumberID)) MaxLineLength:BFTSmart.kt$BFTSmart.Replica.<no name provided>$if (exposeStartupRace) Thread.sleep(20000) MaxLineLength:BFTSmartConfigInternal.kt$BFTSmartConfigInternal : PathManager MaxLineLength:BFTSmartConfigInternal.kt$BFTSmartConfigInternal$val systemConfig = String.format(javaClass.getResource("system.config.printf").readText(), n, maxFaultyReplicas(n), if (debug) 1 else 0, (0 until n).joinToString(",")) - MaxLineLength:BFTSmartConfigTests.kt$BFTSmartConfigTests$assertThatThrownBy { config(11001, 11000).use {} } .isInstanceOf(IllegalArgumentException::class.java) .hasMessage(portIsClaimedFormat.format("localhost:11001", setOf("localhost:11001", "localhost:11002", "localhost:11000"))) - MaxLineLength:BFTSmartConfigTests.kt$BFTSmartConfigTests$fun config(vararg ports: Int) MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService$?: MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService$CommittedState : BaseComittedState - MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService$client - MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService$override fun createServiceFlow(otherPartySession: FlowSession): FlowLogic<Void?> - MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService.<no name provided>$log.warn("A BFT replica may still be initializing, in which case the upcoming consensus change may cause it to spin.") - MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService.Replica$createMap: () -> AppendOnlyPersistentMap<StateRef, SecureHash, CommittedState, PersistentStateRef> - MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService.Replica$notaryIdentityKey: PublicKey MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService.Replica$private MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService.Replica$val response = verifyAndCommitTx(commitRequest.payload.coreTransaction, commitRequest.callerIdentity, commitRequest.payload.requestSignature) - MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService.ServiceFlow$private - MaxLineLength:BFTSmartNotaryService.kt$BFTSmartNotaryService.ServiceFlow${ // TODO: here we assume that all error will be the same, but there might be invalid onces from mailicious nodes val responseError = response.errors.first().verified() throw NotaryException(responseError, payload.coreTransaction.id) } MaxLineLength:BackpressureAwareTimedFlow.kt$BackpressureAwareTimedFlow$else -> throw throw IllegalArgumentException("We were expecting a ${ReceiveType::class.java.name} or WaitTimeUpdate but we instead got a ${unwrapped.javaClass.name} ($unwrapped)") - MaxLineLength:BackpressureAwareTimedFlow.kt$BackpressureAwareTimedFlow$is ReceiveType MaxLineLength:BackpressureAwareTimedFlow.kt$BackpressureAwareTimedFlow$logger.info("Counterparty [${session.counterparty}] is busy - TimedFlow $runId has been asked to wait for an additional ${unwrapped.waitTime} seconds for completion.") - MaxLineLength:BackpressureAwareTimedFlow.kt$BackpressureAwareTimedFlow<ResultType> : FlowLogicTimedFlow MaxLineLength:BankOfCordaClientApi.kt$BankOfCordaClientApi$ fun requestRPCIssue(rpcAddress: NetworkHostAndPort, params: IssueRequestParams): SignedTransaction - MaxLineLength:BankOfCordaClientApi.kt$BankOfCordaClientApi$ fun requestRPCIssueHA(availableRpcServers: List<NetworkHostAndPort>, params: IssueRequestParams): SignedTransaction - MaxLineLength:BankOfCordaClientApi.kt$BankOfCordaClientApi$// DOCSTART rpcClientConnectionRecovery fun performRpcReconnect(nodeHostAndPorts: List<NetworkHostAndPort>, username: String, password: String): CordaRPCConnection - MaxLineLength:BankOfCordaClientApi.kt$BankOfCordaClientApi$// Terminate subscription such that nothing gets past this point to downstream Observables. retryableStateMachineUpdatesSubscription.get()?.unsubscribe() // It is good idea to close connection to properly mark the end of it. During re-connect we will create a new // client and a new connection, so no going back to this one. Also the server might be down, so we are // force closing the connection to avoid propagation of notification to the server side. connection.forceClose() // Perform re-connect. performRpcReconnect(nodeHostAndPorts, username, password) MaxLineLength:BankOfCordaClientApi.kt$BankOfCordaClientApi$private - MaxLineLength:BankOfCordaClientApi.kt$BankOfCordaClientApi$return rpc.startFlow(::CashIssueAndPaymentFlow, params.amount, issuerBankPartyRef, issueToParty, anonymous, notaryLegalIdentity) .returnValue.getOrThrow().stx MaxLineLength:BankOfCordaWebApi.kt$BankOfCordaWebApi$?: MaxLineLength:BankOfCordaWebApi.kt$BankOfCordaWebApi$rpc.startFlow(::CashIssueAndPaymentFlow, params.amount, issuerBankPartyRef, issueToParty, anonymous, notaryParty).returnValue.getOrThrow() MaxLineLength:BankOfCordaWebApi.kt$BankOfCordaWebApi$rpc.wellKnownPartyFromX500Name(params.issuerBankName) ?: return Response.status(Response.Status.FORBIDDEN).entity("Unable to locate ${params.issuerBankName} in identity service").build() - MaxLineLength:BaseTransaction.kt$BaseTransaction$ fun <T : ContractState> filterOutRefs(clazz: Class<T>, predicate: Predicate<T>): List<StateAndRef<T>> - MaxLineLength:BaseTransaction.kt$BaseTransaction$ fun <T : ContractState> filterOutputs(clazz: Class<T>, predicate: Predicate<T>): List<T> - MaxLineLength:BaseTransaction.kt$BaseTransaction$ fun <T : ContractState> outRef(index: Int): StateAndRef<T> - MaxLineLength:BaseTransaction.kt$BaseTransaction$ fun <T : ContractState> outputsOfType(clazz: Class<T>): List<T> - MaxLineLength:BaseTransaction.kt$BaseTransaction$/** * Helper property to return a list of [ContractState] objects, rather than the often less convenient [TransactionState] */ val outputStates: List<ContractState> get() = outputs.map { it.data } - MaxLineLength:BaseTransactions.kt$CoreTransaction$/** * Hash of the network parameters that were in force when the transaction was notarised. Null means, that the transaction * was created on older version of Corda (before 4), resolution will default to initial parameters. */ abstract val networkParametersHash: SecureHash? MaxLineLength:BaseTransactions.kt$FullTransaction$"Notary ($notaryParty) specified by the transaction is not on the network parameter whitelist: [${notaryWhitelist.joinToString()}]" MaxLineLength:BaseTransactions.kt$FullTransaction$/** * Network parameters that were in force when this transaction was created. Resolved from the hash of network parameters on the corresponding * wire transaction. */ abstract val networkParameters: NetworkParameters? - MaxLineLength:BaseTransactions.kt$FullTransaction$// Network parameters will never be null if the transaction is resolved from a CoreTransaction rather than constructed directly. networkParameters?.let { parameters -> val notaryWhitelist = parameters.notaries.map { it.identity } check(notaryParty in notaryWhitelist) { "Notary ($notaryParty) specified by the transaction is not on the network parameter whitelist: [${notaryWhitelist.joinToString()}]" } } - MaxLineLength:BaseTransactions.kt$FullTransaction$check(notaries.single() == notary) { "The specified notary must be the one specified by all inputs and input references" } - MaxLineLength:BasicHSMKeyManagementService.kt$BasicHSMKeyManagementService$"Metadata schemeCodeName: ${sigMetaData.schemeCodeName} is not aligned with the key type: ${sigKey.schemeCodeName}." - MaxLineLength:BasicHSMKeyManagementService.kt$BasicHSMKeyManagementService$// Get [KeyPair] for the input [publicKey]. This is used for fresh keys, in which we have access to the private key material. private fun getSigningKeyPair(publicKey: PublicKey): KeyPair - MaxLineLength:BasicHSMKeyManagementService.kt$BasicHSMKeyManagementService$override MaxLineLength:BasicHSMKeyManagementService.kt$BasicHSMKeyManagementService$override val keys: Set<PublicKey> get() = database.transaction { originalKeysMap.keys.plus(keysMap.allPersisted().map { it.first }.toSet()) } MaxLineLength:BasicHSMKeyManagementService.kt$BasicHSMKeyManagementService$private val database: CordaPersistence MaxLineLength:BasicHSMKeyManagementService.kt$BasicHSMKeyManagementService$require(it.private is AliasPrivateKey) { "${this.javaClass.name} supports AliasPrivateKeys only, but ${it.private.algorithm} key was found" } - MaxLineLength:BasicHSMKeyManagementService.kt$BasicHSMKeyManagementService.Companion$fun createKeyMap(cacheFactory: NamedCacheFactory): AppendOnlyPersistentMap<PublicKey, PrivateKey, PersistentKey, String> MaxLineLength:BitSetSerializer.kt$BitSetSerializer : Proxy - MaxLineLength:BlobInspector.kt$BlobInspector$?: MaxLineLength:BlobInspector.kt$BlobInspector$@Option(names = ["--input-format"], paramLabel = "type", description = ["Input format. If the file can't be decoded with the given value it's auto-detected, so you should never normally need to specify this. Possible values: [BINARY, HEX, BASE64]"]) - MaxLineLength:BlobInspector.kt$BlobInspector$@Parameters(index = "0", paramLabel = "SOURCE", description = ["URL or file path to the blob"], converter = [SourceConverter::class]) - MaxLineLength:BlobInspector.kt$BlobInspector$description = ["Display the owningKey and certPath properties of Party and PartyAndReference objects respectively"] - MaxLineLength:BlobInspector.kt$BlobInspector$val envelope = DeserializationInput.getEnvelope(bytes.sequence(), SerializationDefaults.STORAGE_CONTEXT.encodingWhitelist) - MaxLineLength:BlobInspectorTest.kt$BlobInspectorTest$assertThat(output) .startsWith(SignedDataWithCert::class.java.name) .contains(NetworkParameters::class.java.name) .contains(CordaX500Name("Notary Service", "Zurich", "CH").toString()) - MaxLineLength:BootTests.kt$BootTests$assertThatThrownBy { devModeNode.attemptJavaDeserialization() }.isInstanceOf(CordaRuntimeException::class.java) MaxLineLength:BootTests.kt$BootTests$val logFile = logFolder.list { it.filter { a -> a.isRegularFile() && a.fileName.toString().startsWith("node") }.findFirst().get() } - MaxLineLength:BootTests.kt$BootTests$val numberOfNodesThatLogged = logFile.readLines { it.filter { NodeStartup.LOGS_CAN_BE_FOUND_IN_STRING in it }.count() } - MaxLineLength:BootTests.kt$ObjectInputStreamFlow$val data = ByteArrayOutputStream().apply { ObjectOutputStream(this).use { it.writeObject(object : Serializable {}) } }.toByteArray() - MaxLineLength:BootstrapperView.kt$BootstrapperView$nodeAdder.addNode(context, nodeToAdd, x500ToUse?.let { CordaX500Name.parse(it) }) MaxLineLength:BootstrapperView.kt$BootstrapperView$return Pair(mapOf(Constants.REGION_ARG_NAME to ChoiceDialog<Region>(Region.EUROPE_WEST, Region.values().toList().sortedBy { it.name() }).showAndWait().get().name()), networkName1) - MaxLineLength:BootstrapperView.kt$BootstrapperView.State$var hasNodesOrNotaries = Bindings.size(foundNotaries).greaterThan(0).or(Bindings.size(foundNotaries).greaterThan(0)) MaxLineLength:BridgeControlListener.kt$BridgeControlListener$bridgeManager.deployBridge(controlMessage.bridgeInfo.queueName, controlMessage.bridgeInfo.targets, controlMessage.bridgeInfo.legalNames.toSet()) MaxLineLength:BridgeControlListener.kt$BridgeControlListener$crlCheckSoftFail: Boolean - MaxLineLength:BridgeControlListener.kt$BridgeControlListener$return queueName.startsWith(P2P_PREFIX) && artemis!!.started!!.session.queueQuery(SimpleString(queueName)).isExists - MaxLineLength:BridgeControlListener.kt$BridgeControlListener$return queueName.startsWith(PEERS_PREFIX) && artemis!!.started!!.session.queueQuery(SimpleString(queueName)).isExists MaxLineLength:BridgeControlListener.kt$BridgeControlListener$val startupMessage = BridgeControl.BridgeToNodeSnapshotRequest(bridgeId).serialize(context = SerializationDefaults.P2P_CONTEXT).bytes - MaxLineLength:BridgeControlMessages.kt$BridgeControl$Create : BridgeControl MaxLineLength:BridgeControlMessages.kt$BridgeControl$Delete : BridgeControl MaxLineLength:BridgeControlMessages.kt$BridgeControl$NodeToBridgeSnapshot : BridgeControl MaxLineLength:BridgeControlMessages.kt$BridgeControl.NodeToBridgeSnapshot$@CordaSerializable data MaxLineLength:BridgeControlMessages.kt$BridgeEntry - MaxLineLength:BridgeControlMessages.kt$BridgeEntry$@CordaSerializable data - MaxLineLength:BrokerJaasLoginModule.kt$BaseBrokerJaasLoginModule$override MaxLineLength:BrokerJaasLoginModule.kt$BrokerJaasLoginModule : BaseBrokerJaasLoginModule MaxLineLength:BrokerJaasLoginModule.kt$BrokerJaasLoginModule$CertificateChainCheckPolicy.LeafMustMatch.createCheck(nodeJaasConfig.keyStore, nodeJaasConfig.trustStore).checkCertificateChain(certificates!!) MaxLineLength:BrokerJaasLoginModule.kt$BrokerJaasLoginModule$CertificateChainCheckPolicy.RootMustMatch.createCheck(p2pJaasConfig!!.keyStore, p2pJaasConfig!!.trustStore).checkCertificateChain(certificates!!) - MaxLineLength:BrokerJaasLoginModule.kt$BrokerJaasLoginModule$Pair(username, listOf(RolePrincipal(RPC_ROLE), RolePrincipal("${RPCApi.RPC_CLIENT_QUEUE_NAME_PREFIX}.$username"))) - MaxLineLength:BrokerJaasLoginModule.kt$BrokerJaasLoginModule$fun requireTls(certificates: Array<X509Certificate>?) MaxLineLength:BrokerJaasLoginModule.kt$BrokerJaasLoginModule$if (e is IllegalArgumentException && e.stackTrace.any { it.className == "org.apache.activemq.artemis.protocol.amqp.sasl.PlainSASL" }) { log.trace("SASL Login failed.") } else { log.warn("Login failed: ${e.message}") } - MaxLineLength:BrokerJaasLoginModule.kt$BrokerJaasLoginModule$override MaxLineLength:BrokerJaasLoginModule.kt$BrokerJaasLoginModule$private MaxLineLength:BrokerJaasLoginModule.kt$BrokerJaasLoginModule${ // This is a known problem, so we swallow this exception. A peer will attempt to connect without presenting client certificates during SASL if (e is IllegalArgumentException && e.stackTrace.any { it.className == "org.apache.activemq.artemis.protocol.amqp.sasl.PlainSASL" }) { log.trace("SASL Login failed.") } else { log.warn("Login failed: ${e.message}") } if (e is LoginException) { throw e } else { throw FailedLoginException(e.message) } } - MaxLineLength:BrokerJaasLoginModule.kt$RPCJaasConfig$val loginListener: LoginListener - MaxLineLength:BuiltNode.kt$BuiltNode$return PushedNode(configFile, baseDirectory, copiedNodeConfig, copiedNodeDir, nodeConfig, localImageId, remoteImageName) MaxLineLength:BuiltNode.kt$BuiltNode$val nodeConfig: NodeConfiguration - MaxLineLength:BusinessCalendar.kt$BusinessCalendar$operator fun plus(other: BusinessCalendar): BusinessCalendar MaxLineLength:BusinessCalendar.kt$BusinessCalendar.Companion$dcbDay == DayCountBasisDay.D30 && dcbYear == DayCountBasisYear.Y360 -> ((endDate.year - startDate.year) * 360.0 + (endDate.monthValue - startDate.monthValue) * 30.0 + endDate.dayOfMonth - startDate.dayOfMonth).toInt() - MaxLineLength:ByteArrays.kt$ByteSequence$ @Suppress("MemberVisibilityCanBePrivate") fun subSequence(offset: Int, size: Int): ByteSequence - MaxLineLength:ByteArrays.kt$ByteSequence$ fun slice(start: Int = 0, end: Int = size): ByteBuffer MaxLineLength:ByteArrays.kt$OpaqueBytes$/** * The bytes are always cloned so that this object becomes immutable. This has been done * to prevent tampering with entities such as [net.corda.core.crypto.SecureHash] and [net.corda.core.contracts.PrivacySalt], as well as * preserve the integrity of our hash constants [net.corda.core.crypto.SecureHash.zeroHash] and [net.corda.core.crypto.SecureHash.allOnesHash]. * * Cloning like this may become a performance issue, depending on whether or not the JIT * compiler is ever able to optimise away the clone. In which case we may need to revisit * this later. */ final override val bytes: ByteArray = bytes get() = field.clone() - MaxLineLength:ByteArrays.kt$OpaqueBytesSubSequence : ByteSequence MaxLineLength:ByteArrays.kt$OpaqueBytesSubSequence$require(offset >= 0 && offset < bytes.size) { "Offset must be greater than or equal to 0, and less than the size of the backing array" } MaxLineLength:ByteArrays.kt$OpaqueBytesSubSequence$require(size >= 0 && offset + size <= bytes.size) { "Sub-sequence size must be greater than or equal to 0, and less than the size of the backing array" } - MaxLineLength:ByteBufferStreams.kt$ByteBufferOutputStream.Companion$private MaxLineLength:Cap.kt$Cap$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBOR", BusinessCalendar.parseDateFromString("2017-03-01"), Tenor("3M")), 1.0.bd)))) MaxLineLength:Cap.kt$Cap$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBOR", BusinessCalendar.parseDateFromString("2017-03-01"), Tenor("3M")), 1.5.bd)))) MaxLineLength:Cap.kt$Cap$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBOR", BusinessCalendar.parseDateFromString("2017-03-01"), Tenor("9M")), 1.0.bd)))) @@ -4364,119 +2947,55 @@ MaxLineLength:Cap.kt$Cap$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBOR", tradeDate.plusYears(1), Tenor("3M")), 1.0.bd)))) MaxLineLength:Cap.kt$Cap$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBORx", BusinessCalendar.parseDateFromString("2017-03-01"), Tenor("3M")), 1.0.bd)))) MaxLineLength:Cap.kt$Cap$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBORx", tradeDate, Tenor("3M")), 1.0.bd)))) - MaxLineLength:Cap.kt$Cap$val floating = interest(notional, "act/365", fix("LIBOR", start, Tenor("3M")), start, end) MaxLineLength:Caplet.kt$Caplet$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBOR", tradeDate, Tenor("3M")), 1.0.bd)))) MaxLineLength:Caplet.kt$Caplet$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBOR", tradeDate, Tenor("6M")), 1.0.bd)))) MaxLineLength:Caplet.kt$Caplet$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBOR", tradeDate, Tenor("6M")), 1.5.bd)))) MaxLineLength:Caplet.kt$Caplet$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBOR", tradeDate.plusYears(1), Tenor("6M")), 1.0.bd)))) MaxLineLength:Caplet.kt$Caplet$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBORx", tradeDate, Tenor("6M")), 1.0.bd)))) - MaxLineLength:Caplet.kt$Caplet$val floating = interest(notional, "act/365", fix("LIBOR", tradeDate, Tenor("6M")), "2016-04-01", "2016-10-01") - MaxLineLength:CarpentryDependencyGraph.kt$CarpentryDependencyGraph$/** * A map of inbound edges by node. * * A [RemoteTypeInformation] map key is a type that requires other types to have been constructed before it can be * constructed. * * Each [RemoteTypeInformation] in the corresponding [Set] map value is one of the types that the key-type depends on. * * No key ever maps to an empty set: types with no dependencies are not included in this map. */ private val dependencies = mutableMapOf<RemoteTypeInformation, MutableSet<RemoteTypeInformation>>() - MaxLineLength:CarpentryDependencyGraph.kt$CarpentryDependencyGraph$if (dependencies.isEmpty()) newlyIndependent.asSequence() else topologicalSort(remaining, newlyIndependent) - MaxLineLength:CarpentryDependencyGraph.kt$CarpentryDependencyGraph${ // Types which still have dependencies. val remaining = dependencies.keys.toSet() // Remove the types which have no dependencies from the dependencies of the remaining types, and identify // those types which have no dependencies left after we've done this. val newlyIndependent = dependencies.asSequence().mapNotNull { (dependent, dependees) -> dependees.removeAll(noDependencies) if (dependees.isEmpty()) dependent else null }.toSet() // If there are still types with dependencies, and we have no dependencies we can remove, then we can't continue. if (newlyIndependent.isEmpty() && dependencies.isNotEmpty()) { throw NotSerializableException( "Cannot build dependencies for " + dependencies.keys.map { it.typeIdentifier.prettyPrint(false) }) } // Remove the types which have no dependencies remaining, maintaining the invariant that no key maps to an // empty set. dependencies.keys.removeAll(newlyIndependent) // Return the types that had no dependencies, then recurse to process the remainder. return noDependencies.asSequence() + if (dependencies.isEmpty()) newlyIndependent.asSequence() else topologicalSort(remaining, newlyIndependent) } MaxLineLength:Cash.kt$ @Throws(IllegalArgumentException::class) internal inline fun <reified T : MoveCommand> verifyFlattenedMoveCommand(inputs: List<OwnableState>, commands: List<CommandWithParties<CommandData>>) : MoveCommand - MaxLineLength:Cash.kt$Cash$ fun generateIssue(tx: TransactionBuilder, tokenDef: Issued<Currency>, pennies: Long, owner: AbstractParty, notary: Party) MaxLineLength:Cash.kt$Cash$"for reference ${issuer.reference} at issuer ${issuer.party} the amounts balance: ${inputAmount.quantity} - ${amountExitingLedger.quantity} != ${outputAmount.quantity}" MaxLineLength:Cash.kt$Cash$it.wellKnownPartyFromX500Name(sendToX500Name) ?: throw IllegalStateException("Unable to locate $sendToX500Name in Network Map Service") - MaxLineLength:Cash.kt$Cash$override MaxLineLength:Cash.kt$Cash$return@withClient it.startFlow(::CashIssueFlow, Amount(amount, Currency.getInstance(currency)), OpaqueBytes.of(1), notaryParty).returnValue.getOrThrow().stx MaxLineLength:Cash.kt$Cash$return@withClient it.startFlow(::CashPaymentFlow, Amount(amount, Currency.getInstance(currency)), sendToParty).returnValue.getOrThrow().stx MaxLineLength:Cash.kt$Cash$val exitCommand = tx.commands.select<Commands.Exit>(parties = null, signers = exitKeys).singleOrNull { it.value.amount.token == key } MaxLineLength:Cash.kt$Cash$val inputAmount = inputs.sumCashOrNull() ?: throw IllegalArgumentException("there is at least one cash input for this group") - MaxLineLength:Cash.kt$Cash${ val inputAmount = inputs.sumCashOrNull() ?: throw IllegalArgumentException("there is at least one cash input for this group") val outputAmount = outputs.sumCashOrZero(Issued(issuer, currency)) // If we want to remove cash from the ledger, that must be signed for by the issuer. // A mis-signed or duplicated exit command will just be ignored here and result in the exit amount being zero. val exitKeys: Set<PublicKey> = inputs.flatMap { it.exitKeys }.toSet() val exitCommand = tx.commands.select<Commands.Exit>(parties = null, signers = exitKeys).singleOrNull { it.value.amount.token == key } val amountExitingLedger = exitCommand?.value?.amount ?: Amount(0, Issued(issuer, currency)) requireThat { "there are no zero sized inputs" using inputs.none { it.amount.quantity == 0L } "for reference ${issuer.reference} at issuer ${issuer.party} the amounts balance: ${inputAmount.quantity} - ${amountExitingLedger.quantity} != ${outputAmount.quantity}" using (inputAmount == outputAmount + amountExitingLedger) } verifyFlattenedMoveCommand<Commands.Move>(inputs, tx.commands) } - MaxLineLength:Cash.kt$Cash.State$infix fun issuedBy(deposit: PartyAndReference) MaxLineLength:Cash.kt$Cash.State$infix fun issuedBy(party: AbstractParty) MaxLineLength:Cash.kt$Cash.State$infix fun withDeposit(deposit: PartyAndReference): Cash.State - MaxLineLength:Cash.kt$Cash.State$override - MaxLineLength:Cash.kt$commands: List<CommandWithParties<CommandData>> MaxLineLength:Cash.kt$internal - MaxLineLength:Cash.kt$internal inline - MaxLineLength:CashConfigDataFlowTest.kt$CashConfigDataFlowTest$additionalCordapps = listOf(FINANCE_WORKFLOWS_CORDAPP.withConfig(mapOf("issuableCurrencies" to listOf("EUR", "USD")))) - MaxLineLength:CashExceptionSerialisationTest.kt$CashExceptionSerialisationTest$val action = { node.rpc.startFlow(CashExceptionSerialisationTest::CashExceptionThrowingFlow).returnValue.getOrThrow() } MaxLineLength:CashExitFlow.kt$CashExitFlow$AbstractCashSelection .getInstance { serviceHub.jdbcSession().metaData } .unconsumedCashStatesForSpending(serviceHub, amount, setOf(issuer.party), builder.notary, builder.lockId, setOf(issuer.reference)) MaxLineLength:CashExitFlow.kt$CashExitFlow$val changeOwner = exitStates.asSequence().map { it.state.data.owner }.toSet().firstOrNull() ?: throw InsufficientBalanceException(amount) - MaxLineLength:CashExitFlow.kt$CashExitFlow$val inputStates = serviceHub.vaultService.queryBy<Cash.State>(VaultQueryCriteria(stateRefs = builder.inputStates()), PageSpecification(pageNumber = DEFAULT_PAGE_NUM, pageSize = builder.inputStates().size)).states - MaxLineLength:CashExitFlow.kt$CashExitFlow${ progressTracker.currentStep = GENERATING_TX val builder = TransactionBuilder(notary = null) val issuer = ourIdentity.ref(issuerRef) val exitStates = AbstractCashSelection .getInstance { serviceHub.jdbcSession().metaData } .unconsumedCashStatesForSpending(serviceHub, amount, setOf(issuer.party), builder.notary, builder.lockId, setOf(issuer.reference)) val signers = try { val changeOwner = exitStates.asSequence().map { it.state.data.owner }.toSet().firstOrNull() ?: throw InsufficientBalanceException(amount) Cash().generateExit( builder, amount.issuedBy(issuer), exitStates, changeOwner) } catch (e: InsufficientBalanceException) { throw CashException("Exiting more cash than exists", e) } // Work out who the owners of the burnt states were (specify page size so we don't silently drop any if > DEFAULT_PAGE_SIZE) val inputStates = serviceHub.vaultService.queryBy<Cash.State>(VaultQueryCriteria(stateRefs = builder.inputStates()), PageSpecification(pageNumber = DEFAULT_PAGE_NUM, pageSize = builder.inputStates().size)).states val participantSessions = inputStates .asSequence() .mapNotNull { serviceHub.identityService.wellKnownPartyFromAnonymous(it.state.data.owner) } .filterNot(serviceHub.myInfo::isLegalIdentity) .distinct() .map(::initiateFlow) .toList() // Sign transaction progressTracker.currentStep = SIGNING_TX val tx = serviceHub.signInitialTransaction(builder, signers) // Commit the transaction progressTracker.currentStep = FINALISING_TX val notarised = finaliseTx(tx, participantSessions, "Unable to notarise exit") return Result(notarised, null) } - MaxLineLength:CashExitFlowTests.kt$CashExitFlowTests$mockNet = MockNetwork(MockNetworkParameters(servicePeerAllocationStrategy = RoundRobin(), cordappsForAllNodes = FINANCE_CORDAPPS)) MaxLineLength:CashIssueAndPaymentFlow.kt$CashIssueAndPaymentFlow$constructor(request: IssueAndPaymentRequest) : this(request.amount, request.issueRef, request.recipient, request.anonymous, request.notary, tracker()) - MaxLineLength:CashIssueAndPaymentFlow.kt$CashIssueAndPaymentFlow$progressTracker: ProgressTracker - MaxLineLength:CashIssueFlowTests.kt$CashIssueFlowTests$mockNet = MockNetwork(MockNetworkParameters(servicePeerAllocationStrategy = RoundRobin(), cordappsForAllNodes = FINANCE_CORDAPPS)) - MaxLineLength:CashPaymentFlow.kt$CashPaymentFlow$/** A straightforward constructor that constructs spends using cash states of any issuer. */ constructor(amount: Amount<Currency>, recipient: Party, anonymous: Boolean) : this(amount, recipient, anonymous, tracker()) MaxLineLength:CashPaymentFlow.kt$CashPaymentFlow$constructor(amount: Amount<Currency>, recipient: Party, anonymous: Boolean, notary: Party) : this(amount, recipient, anonymous, tracker(), notary = notary) MaxLineLength:CashPaymentFlow.kt$CashPaymentFlow$constructor(request: PaymentRequest) : this(request.amount, request.recipient, request.anonymous, tracker(), request.issuerConstraint, request.notary) - MaxLineLength:CashPaymentFlow.kt$CashPaymentFlow$val sessionsForFinality = if (serviceHub.myInfo.isLegalIdentity(recipient)) emptyList() else listOf(recipientSession) - MaxLineLength:CashPaymentFlowTests.kt$CashPaymentFlowTests$mockNet = MockNetwork(MockNetworkParameters(servicePeerAllocationStrategy = RoundRobin(), cordappsForAllNodes = FINANCE_CORDAPPS)) MaxLineLength:CashSchemaV1.kt$CashSchemaV1 : MappedSchema MaxLineLength:CashSchemaV1.kt$CashSchemaV1.PersistentCashState$@Table(name = "contract_cash_states", indexes = [Index(name = "ccy_code_idx", columnList = "ccy_code"), Index(name = "pennies_idx", columnList = "pennies")]) - MaxLineLength:CashSelectionH2Impl.kt$CashSelectionH2Impl$ SELECT vs.transaction_id, vs.output_index, ccs.pennies, SET(@t, ifnull(@t,0)+ccs.pennies) total_pennies, vs.lock_id - MaxLineLength:CashSelectionH2Impl.kt$CashSelectionH2Impl$// We are using an H2 specific means of selecting a minimum set of rows that match a request amount of coins: // 1) There is no standard SQL mechanism of calculating a cumulative total on a field and restricting row selection on the // running total of such an accumulator // 2) H2 uses session variables to perform this accumulator function: // http://www.h2database.com/html/functions.html#set // 3) H2 does not support JOIN's in FOR UPDATE (hence we are forced to execute 2 queries) override fun executeQuery(connection: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, withResultSet: (ResultSet) -> Boolean): Boolean MaxLineLength:CashSelectionH2Impl.kt$CashSelectionH2Impl$override - MaxLineLength:CashSelectionH2Impl.kt$CashSelectionH2Impl${ connection.createStatement().use { it.execute("CALL SET(@t, CAST(0 AS BIGINT));") } // state_status = 0 -> UNCONSUMED. // is_relevant = 0 -> RELEVANT. val selectJoin = """ SELECT vs.transaction_id, vs.output_index, ccs.pennies, SET(@t, ifnull(@t,0)+ccs.pennies) total_pennies, vs.lock_id FROM vault_states AS vs, contract_cash_states AS ccs WHERE vs.transaction_id = ccs.transaction_id AND vs.output_index = ccs.output_index AND vs.state_status = 0 AND vs.relevancy_status = 0 AND ccs.ccy_code = ? and @t < ? AND (vs.lock_id = ? OR vs.lock_id is null) """ + (if (notary != null) " AND vs.notary_name = ?" else "") + (if (onlyFromIssuerParties.isNotEmpty()) { val repeats = generateSequence { "?" }.take(onlyFromIssuerParties.size).joinToString(",") " AND ccs.issuer_key_hash IN ($repeats)" } else "") + (if (withIssuerRefs.isNotEmpty()) { val repeats = generateSequence { "?" }.take(withIssuerRefs.size).joinToString(",") " AND ccs.issuer_ref IN ($repeats)" } else "") // Use prepared statement for protection against SQL Injection (http://www.h2database.com/html/advanced.html#sql_injection) connection.prepareStatement(selectJoin).use { psSelectJoin -> var pIndex = 0 psSelectJoin.setString(++pIndex, amount.token.currencyCode) psSelectJoin.setLong(++pIndex, amount.quantity) psSelectJoin.setString(++pIndex, lockId.toString()) if (notary != null) psSelectJoin.setString(++pIndex, notary.name.toString()) onlyFromIssuerParties.forEach { psSelectJoin.setString(++pIndex, it.owningKey.toStringShort()) } withIssuerRefs.forEach { psSelectJoin.setBytes(++pIndex, it.bytes) } log.debug { psSelectJoin.toString() } psSelectJoin.executeQuery().use { rs -> return withResultSet(rs) } } } - MaxLineLength:CashSelectionH2ImplTest.kt$CashSelectionH2ImplTest$( // Tweak connections to be minimal to make this easier (1 results in a hung node during start up, so use 2 connections). configOverrides = MockNodeConfigOverrides(extraDataSourceProperties = mapOf("maximumPoolSize" to "2")) ) - MaxLineLength:CashSelectionH2ImplTest.kt$CashSelectionH2ImplTest$private val mockNet = MockNetwork(MockNetworkParameters(threadPerNode = true, cordappsForAllNodes = FINANCE_CORDAPPS)) - MaxLineLength:CashSelectionH2ImplTest.kt$CashSelectionH2ImplTest$val paymentResult = node.startFlow(CashPaymentFlow(999.POUNDS, node.info.legalIdentities[0], false)).getOrThrow() MaxLineLength:CashSelectionH2ImplTest.kt$CashSelectionH2ImplTest$val request = CashPaymentFlow.PaymentRequest(1.POUNDS, node.info.legalIdentities[0], true, setOf(node.info.legalIdentities[0], mockNet.defaultNotaryIdentity)) - MaxLineLength:CashSelectionH2ImplTest.kt$CashSelectionH2ImplTest${ val bankA = mockNet.createNode(MockNodeParameters( // Tweak connections to be minimal to make this easier (1 results in a hung node during start up, so use 2 connections). configOverrides = MockNodeConfigOverrides(extraDataSourceProperties = mapOf("maximumPoolSize" to "2")) )) val notary = mockNet.defaultNotaryIdentity // Start more cash spends than we have connections. If spend leaks a connection on retry, we will run out of connections. val flow1 = bankA.startFlow(CashPaymentFlow(amount = 100.DOLLARS, anonymous = false, recipient = notary)) val flow2 = bankA.startFlow(CashPaymentFlow(amount = 100.DOLLARS, anonymous = false, recipient = notary)) val flow3 = bankA.startFlow(CashPaymentFlow(amount = 100.DOLLARS, anonymous = false, recipient = notary)) assertThatThrownBy { flow1.getOrThrow() }.isInstanceOf(CashException::class.java) assertThatThrownBy { flow2.getOrThrow() }.isInstanceOf(CashException::class.java) assertThatThrownBy { flow3.getOrThrow() }.isInstanceOf(CashException::class.java) } - MaxLineLength:CashSelectionH2ImplTest.kt$CashSelectionH2ImplTest${ val node = mockNet.createNode() // The amount has to split across at least two states, probably to trigger the H2 accumulator variable during the // spend operation below. // Issuing Integer.MAX_VALUE will not cause an exception since PersistentCashState.pennies is a long nCopies(2, Integer.MAX_VALUE).map { issueAmount -> node.startFlow(CashIssueFlow(issueAmount.POUNDS, OpaqueBytes.of(1), mockNet.defaultNotaryIdentity)) }.transpose().getOrThrow() // The spend must be more than the size of a single cash state to force the accumulator onto the second state. node.startFlow(CashPaymentFlow((Integer.MAX_VALUE + 1L).POUNDS, node.info.legalIdentities[0])).getOrThrow() } - MaxLineLength:CashSelectionPostgreSQLImpl.kt$CashSelectionPostgreSQLImpl$ coalesce((SUM(ccs.pennies) OVER (PARTITION BY 1 ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING)), 0) - MaxLineLength:CashSelectionPostgreSQLImpl.kt$CashSelectionPostgreSQLImpl$// This is using PostgreSQL window functions for selecting a minimum set of rows that match a request amount of coins: // 1) This may also be possible with user-defined functions (e.g. using PL/pgSQL) // 2) The window function accumulated column (`total`) does not include the current row (starts from 0) and cannot // appear in the WHERE clause, hence restricting row selection and adjusting the returned total in the outer query. // 3) Currently (version 9.6), FOR UPDATE cannot be specified with window functions override fun executeQuery(connection: Connection, amount: Amount<Currency>, lockId: UUID, notary: Party?, onlyFromIssuerParties: Set<AbstractParty>, withIssuerRefs: Set<OpaqueBytes>, withResultSet: (ResultSet) -> Boolean): Boolean MaxLineLength:CashSelectionPostgreSQLImpl.kt$CashSelectionPostgreSQLImpl$override MaxLineLength:CashSelectionSQLServerImpl.kt$CashSelectionSQLServerImpl$override MaxLineLength:CashSelectionTest.kt$CashSelectionTest$AbstractCashSelection .getInstance { node.services.jdbcSession().metaData } .unconsumedCashStatesForSpending(node.services, exitedAmount, setOf(issuer.party), builder.notary, builder.lockId, setOf(issuer.reference)) - MaxLineLength:CashSelectionTest.kt$CashSelectionTest$issuance.addOutputState(TransactionState(Cash.State(coin, nodeIdentity), Cash.PROGRAM_ID, mockNet.defaultNotaryIdentity)) MaxLineLength:CashSelectionTest.kt$CashSelectionTest$issuance.addOutputState(TransactionState(Cash.State(it, nodeIdentity), "net.corda.finance.contracts.asset.Cash", mockNet.defaultNotaryIdentity)) - MaxLineLength:CashSelectionTest.kt$CashSelectionTest$node.services.startFlow(CashIssueFlow(issuedAmount, issuerRef, mockNet.defaultNotaryIdentity)).resultFuture.getOrThrow() - MaxLineLength:CashSteps.kt$CashSteps$Then - MaxLineLength:CashTests.kt$CashTests$Cash().generateExit(tx, Amount(amount.quantity, Issued(issuer.ref(depositRef), amount.token)), cashStates, payChangeTo) - MaxLineLength:CashTests.kt$CashTests$Cash().generateIssue(ptx, 100.DOLLARS `issued by` miniCorp.ref(12, 34), owner = miniCorp.party, notary = dummyNotary.party) MaxLineLength:CashTests.kt$CashTests$Cash().generateIssue(this, 100.DOLLARS `issued by` miniCorp.ref(12, 34), owner = AnonymousParty(alice.publicKey), notary = dummyNotary.party) MaxLineLength:CashTests.kt$CashTests$CashUtils.generateSpend(ourServices, tx, 80.DOLLARS, ourServices.myInfo.singleIdentityAndCert(), alice.party, setOf(miniCorp.party)) MaxLineLength:CashTests.kt$CashTests$TransactionState(Cash.State(amount `issued by` issuer.ref(depositRef), ourIdentity), Cash.PROGRAM_ID, dummyNotary.party, constraint = AlwaysAcceptAttachmentConstraint) - MaxLineLength:CashTests.kt$CashTests$amount = Amount(amount.quantity, token = amount.token.copy(amount.token.issuer.copy(reference = OpaqueBytes.of(ref)))) MaxLineLength:CashTests.kt$CashTests$assertEquals(vaultState.state.data.copy(owner = miniCorpAnonymised, amount = 10.DOLLARS `issued by` defaultIssuer), wtx.outputs[0].data) MaxLineLength:CashTests.kt$CashTests$assertEquals(vaultState0.state.data.copy(owner = miniCorpAnonymised, amount = 500.DOLLARS `issued by` defaultIssuer), wtx.getOutput(0)) MaxLineLength:CashTests.kt$CashTests$assertEquals(vaultState0.state.data.copy(owner = miniCorpAnonymised, amount = 500.DOLLARS `issued by` defaultIssuer), wtx.outputs[1].data) - MaxLineLength:CashTests.kt$CashTests$assertNotEquals((fiveThousandDollarsFromMega withDeposit defaultIssuer).amount.token, fiveThousandDollarsFromMega.amount.token) - MaxLineLength:CashTests.kt$CashTests$assertNotEquals(fiveThousandDollarsFromMega.amount.token, (fiveThousandDollarsFromMega withDeposit defaultIssuer).amount.token) MaxLineLength:CashTests.kt$CashTests$makeTestIdentityService(megaCorp.identity, miniCorp.identity, dummyCashIssuer.identity, dummyNotary.identity, myself.identity) MaxLineLength:CashTests.kt$CashTests$output(Cash.PROGRAM_ID, "MEGA_CORP cash 2", "MEGA_CORP cash".output<Cash.State>().copy(owner = AnonymousParty(alice.publicKey))) - MaxLineLength:CashTests.kt$CashTests$output(Cash.PROGRAM_ID, "MEGA_CORP cash 3", "MEGA_CORP cash".output<Cash.State>().copy(owner = alice.party)) MaxLineLength:CashTests.kt$CashTests$output(Cash.PROGRAM_ID, inState.copy(owner = AnonymousParty(bob.publicKey), amount = 2000.DOLLARS `issued by` defaultIssuer)) MaxLineLength:CashTests.kt$CashTests$output(Cash.PROGRAM_ID, issuerInState.copy(amount = issuerInState.amount - (200.DOLLARS `issued by` defaultIssuer)) issuedBy miniCorp.party) - MaxLineLength:CashTests.kt$CashTests$output(Cash.PROGRAM_ID, issuerInState.copy(amount = issuerInState.amount - (200.DOLLARS `issued by` defaultIssuer))) MaxLineLength:CashTests.kt$CashTests$output(Cash.PROGRAM_ID, issuerInState.copy(owner = miniCorp.party, amount = issuerInState.amount - (200.DOLLARS `issued by` defaultIssuer))) - MaxLineLength:CashTests.kt$CashTests$private MaxLineLength:CashTests.kt$CashTests$val expectedChange = cashStates[0].state.data.copy(amount = cashStates[0].state.data.amount.copy(quantity = expectedChangeAmount), owner = actualChange.owner) MaxLineLength:CashUtils.kt$CashUtils$@Deprecated("Our identity should be specified", replaceWith = ReplaceWith("generateSpend(services, tx, amount, to, ourIdentity, onlyFromParties)")) MaxLineLength:CashUtils.kt$CashUtils$fun deriveState(txState: TransactionState<Cash.State>, amt: Amount<Issued<Currency>>, owner: AbstractParty): TransactionState<Cash.State> MaxLineLength:CashUtils.kt$CashUtils$return generateSpend(services, tx, listOf(PartyAndAmount(to, amount)), services.myInfo.legalIdentitiesAndCerts.single(), onlyFromParties) - MaxLineLength:CashUtils.kt$CashUtils$val acceptableCoins = cashSelection.unconsumedCashStatesForSpending(services, totalAmount, onlyFromParties, tx.notary, tx.lockId) - MaxLineLength:CashViewer.kt$CashViewer$"Issuer" to { state, text -> state.resolveIssuer().value?.name?.organisation?.contains(text, true) == true } MaxLineLength:CashViewer.kt$CashViewer$/** * Assemble the Issuer node. */ val treeItem = TreeItem(ViewerNode.IssuerNode(issuer.owningKey.toKnownParty().value ?: issuer, equivSumAmount, memberStates)) MaxLineLength:CashViewer.kt$CashViewer$/** * Next we create subgroups based on currency. [memberStates] here is all states holding currency [currency] issued by [issuer] above. * Note that these states will not be displayed in the TreeTable, but rather in the side pane if the user clicks on the row. */ val currencyNodes = AggregatedList(memberStates, { it.state.data.amount.token.product }) { currency, groupedMemberStates -> /** * We sum the states in the subgroup, to be displayed in the "Local Currency" column */ val amounts = groupedMemberStates.map { it.state.data.amount.withoutIssuer() } val sumAmount = amounts.foldObservable(Amount(0, currency), Amount<Currency>::plus) /** * We exchange the sum to the reporting currency, to be displayed in the "<currency> Equiv" column. */ val equivSumAmount = EasyBind.combine(sumAmount, reportingExchange) { sum, exchange -> exchange.second(sum) } /** * Finally assemble the actual TreeTable Currency node. */ TreeItem(ViewerNode.CurrencyNode(sumAmount, equivSumAmount, groupedMemberStates)) } - MaxLineLength:CashViewer.kt$CashViewer$/** * Next we create subgroups based on currency. [memberStates] here is all states holding currency [currency] issued by [issuer] above. * Note that these states will not be displayed in the TreeTable, but rather in the side pane if the user clicks on the row. */ val currencyNodes = AggregatedList(memberStates, { it.state.data.amount.token.product }) { currency, groupedMemberStates -> /** * We sum the states in the subgroup, to be displayed in the "Local Currency" column */ val amounts = groupedMemberStates.map { it.state.data.amount.withoutIssuer() } val sumAmount = amounts.foldObservable(Amount(0, currency), Amount<Currency>::plus) /** * We exchange the sum to the reporting currency, to be displayed in the "<currency> Equiv" column. */ val equivSumAmount = EasyBind.combine(sumAmount, reportingExchange) { sum, exchange -> exchange.second(sum) } /** * Finally assemble the actual TreeTable Currency node. */ TreeItem(ViewerNode.CurrencyNode(sumAmount, equivSumAmount, groupedMemberStates)) } /** * Now that we have all nodes per currency, we sum the exchanged amounts, to be displayed in the * "<currency> Equiv" column, this time on the issuer level. */ val equivAmounts = currencyNodes.map { it.value.equivAmount }.flatten() val equivSumAmount = reportingCurrency.bind { currency -> equivAmounts.foldObservable(Amount(0, currency), Amount<Currency>::plus) } /** * Assemble the Issuer node. */ val treeItem = TreeItem(ViewerNode.IssuerNode(issuer.owningKey.toKnownParty().value ?: issuer, equivSumAmount, memberStates)) /** * Bind the children in the TreeTable structure. * * TODO Perhaps we shouldn't do this here, but rather have a generic way of binding nodes to the treetable once. */ treeItem.isExpanded = true val children: List<TreeItem<out ViewerNode.IssuerNode>> = treeItem.children Bindings.bindContent(children, currencyNodes) treeItem - MaxLineLength:CashViewer.kt$CashViewer$/** * This is where we aggregate the list of cash states into the TreeTable structure. */ val cashViewerIssueNodes: ObservableList<TreeItem<out ViewerNode.IssuerNode>> = /** * First we group the states based on the issuer. [memberStates] is all states holding currency issued by [issuer] */ AggregatedList(searchField.filteredData, { it.state.data.amount.token.issuer.party }) { issuer, memberStates -> /** * Next we create subgroups based on currency. [memberStates] here is all states holding currency [currency] issued by [issuer] above. * Note that these states will not be displayed in the TreeTable, but rather in the side pane if the user clicks on the row. */ val currencyNodes = AggregatedList(memberStates, { it.state.data.amount.token.product }) { currency, groupedMemberStates -> /** * We sum the states in the subgroup, to be displayed in the "Local Currency" column */ val amounts = groupedMemberStates.map { it.state.data.amount.withoutIssuer() } val sumAmount = amounts.foldObservable(Amount(0, currency), Amount<Currency>::plus) /** * We exchange the sum to the reporting currency, to be displayed in the "<currency> Equiv" column. */ val equivSumAmount = EasyBind.combine(sumAmount, reportingExchange) { sum, exchange -> exchange.second(sum) } /** * Finally assemble the actual TreeTable Currency node. */ TreeItem(ViewerNode.CurrencyNode(sumAmount, equivSumAmount, groupedMemberStates)) } /** * Now that we have all nodes per currency, we sum the exchanged amounts, to be displayed in the * "<currency> Equiv" column, this time on the issuer level. */ val equivAmounts = currencyNodes.map { it.value.equivAmount }.flatten() val equivSumAmount = reportingCurrency.bind { currency -> equivAmounts.foldObservable(Amount(0, currency), Amount<Currency>::plus) } /** * Assemble the Issuer node. */ val treeItem = TreeItem(ViewerNode.IssuerNode(issuer.owningKey.toKnownParty().value ?: issuer, equivSumAmount, memberStates)) /** * Bind the children in the TreeTable structure. * * TODO Perhaps we shouldn't do this here, but rather have a generic way of binding nodes to the treetable once. */ treeItem.isExpanded = true val children: List<TreeItem<out ViewerNode.IssuerNode>> = treeItem.children Bindings.bindContent(children, currencyNodes) treeItem } - MaxLineLength:CashViewer.kt$CashViewer$/** * We allow filtering by both issuer and currency. We do this by filtering by both at the same time and picking the * one which produces more results, which seems to work, as the set of currency strings don't really overlap with * issuer strings. */ val searchField = SearchField(cashStates, "Currency" to { state, text -> state.state.data.amount.token.product.toString().contains(text, true) }, "Issuer" to { state, text -> state.resolveIssuer().value?.name?.organisation?.contains(text, true) == true } ) - MaxLineLength:CashViewer.kt$CashViewer$/** * We exchange the sum to the reporting currency, to be displayed in the "<currency> Equiv" column. */ val equivSumAmount = EasyBind.combine(sumAmount, reportingExchange) { sum, exchange -> exchange.second(sum) } - MaxLineLength:CashViewer.kt$CashViewer$AggregatedList MaxLineLength:CashViewer.kt$CashViewer$is ViewerNode.IssuerNode -> SimpleStringProperty(node.issuer.nameOrNull()?.let { PartyNameFormatter.short.format(it) } ?: "Anonymous") MaxLineLength:CashViewer.kt$CashViewer$itemsProperty().bind(selectedNode.map { it?.states?.map { StateRow(LocalDateTime.now(), it) } ?: ObservableListWrapper(emptyList()) }) - MaxLineLength:CashViewer.kt$CashViewer$setCellValueFactory { val node = it.value.value when (node) { is ViewerNode.IssuerNode -> null.lift() is ViewerNode.CurrencyNode -> node.amount.map { it } } } cellFactory = currencyCellFactory /** * We must set this, otherwise on sort an exception will be thrown, as it will try to compare Amounts of differing currency */ isSortable = false - MaxLineLength:CashViewer.kt$CashViewer.CashWidget$if(lastTimeStamp != null && currentTimeStamp - lastTimeStamp.toLong() < 1.seconds.toMillis()) { data.safelyTransition { remove(size - 1, size) } } - MaxLineLength:CashViewer.kt$CashViewer.CashWidget$private MaxLineLength:CashViewer.kt$CashViewer.CashWidget${ // If update arrived in very close succession to the previous one - kill the last point received to eliminate un-necessary noise on the graph. if(lastTimeStamp != null && currentTimeStamp - lastTimeStamp.toLong() < 1.seconds.toMillis()) { data.safelyTransition { remove(size - 1, size) } } // Add a new data point. data(currentTimeStamp, currAmount) // Limit population of data points to make graph painting faster. data.safelyTransition { if (size > 300) remove(0, 1) } } - MaxLineLength:CashViewer.kt$CashViewer.StateRowGraphic$issuerValueLabel.apply { tooltip(resolvedIssuer.nameOrNull()?.let { PartyNameFormatter.full.format(it) } ?: "Anonymous") } MaxLineLength:CashViewer.kt$CashViewer.StateRowGraphic$val resolvedIssuer: AbstractParty = stateRow.stateAndRef.resolveIssuer().value ?: stateRow.stateAndRef.state.data.amount.token.issuer.party - MaxLineLength:CertPathSerializer.kt$CertPathSerializer : Proxy - MaxLineLength:CertRole.kt$CertRole : ASN1Encodable - MaxLineLength:CertRole.kt$CertRole$enum - MaxLineLength:CertRoleTests.kt$CertRoleTests$assertFalse { confidentialCertRole.isValidParent(doormanCertRole) } - MaxLineLength:CertRoleTests.kt$CertRoleTests$assertFalse { confidentialCertRole.isValidParent(nodeCACertRole) } - MaxLineLength:CertRoleTests.kt$CertRoleTests$assertFalse { legalIDCertFromDoormanRole.isValidParent(tlsCertFromDoormanRole) } - MaxLineLength:CertRoleTests.kt$CertRoleTests$assertFalse { tlsCertFromNodeCARole.isValidParent(legalIDCertFromNodeCARole) } - MaxLineLength:CertRoleTests.kt$CertRoleTests$assertTrue { confidentialCertRole.isValidParent(legalIDCertFromNodeCARole) } - MaxLineLength:CertRoleTests.kt$CertRoleTests$assertTrue { doormanCertRole.isValidParent(intermediateRootCertRole) } - MaxLineLength:CertRoleTests.kt$CertRoleTests$assertTrue { legalIDCertFromDoormanRole.isValidParent(doormanCertRole) } MaxLineLength:CertRoleTests.kt$CertRoleTests$val confidentialCert = X509Utilities.createCertificate(CertificateType.CONFIDENTIAL_LEGAL_IDENTITY, legalIDCertFromNodeCA, legalIDKeyPairFromNodeCA, nodeSubject, confidentialKeyPair.public) MaxLineLength:CertRoleTests.kt$CertRoleTests$val doormanCert = X509Utilities.createCertificate(CertificateType.INTERMEDIATE_CA, intermediateRootCert, intermediateRootKeyPair, doormanSubject, doormanKeyPair.public) MaxLineLength:CertRoleTests.kt$CertRoleTests$val intermediateRootCert = X509Utilities.createCertificate(CertificateType.ROOT_CA, rootCert, rootKeyPair, intermediateRootSubject, intermediateRootKeyPair.public) @@ -4485,273 +3004,112 @@ MaxLineLength:CertRoleTests.kt$CertRoleTests$val nodeCACert = X509Utilities.createCertificate(CertificateType.NODE_CA, doormanCert, doormanKeyPair, nodeSubject, nodeCAKeyPair.public) MaxLineLength:CertRoleTests.kt$CertRoleTests$val tlsCertFromDoorman = X509Utilities.createCertificate(CertificateType.TLS, doormanCert, doormanKeyPair, nodeSubject, tlsKeyPairFromDoorman.public) MaxLineLength:CertRoleTests.kt$CertRoleTests$val tlsCertFromNodeCA = X509Utilities.createCertificate(CertificateType.TLS, nodeCACert, nodeCAKeyPair, nodeSubject, tlsKeyPairFromNodeCA.public) - MaxLineLength:CertRoleTests.kt$CertRoleTests${ // Testing for various certificate hierarchies (with or without NodeCA). // ROOT -> Intermediate Root -> Doorman -> NodeCA -> Legal Identity cert -> Confidential key cert // -> NodeCA -> TLS // -> Legal Identity cert -> Confidential key cert // -> TLS val rootSubject = X500Principal("CN=Root,O=R3 Ltd,L=London,C=GB") val intermediateRootSubject = X500Principal("CN=Intermediate Root,O=R3 Ltd,L=London,C=GB") val doormanSubject = X500Principal("CN=Doorman,O=R3 Ltd,L=London,C=GB") val nodeSubject = X500Principal("CN=Node,O=R3 Ltd,L=London,C=GB") val rootKeyPair = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) val rootCert = X509Utilities.createSelfSignedCACertificate(rootSubject, rootKeyPair) val rootCertRole = CertRole.extract(rootCert) val intermediateRootKeyPair = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) // Note that [CertificateType.ROOT_CA] is used for both root and intermediate root. val intermediateRootCert = X509Utilities.createCertificate(CertificateType.ROOT_CA, rootCert, rootKeyPair, intermediateRootSubject, intermediateRootKeyPair.public) val intermediateRootCertRole = CertRole.extract(intermediateRootCert) val doormanKeyPair = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) // Note that [CertificateType.INTERMEDIATE_CA] has actually role = CertRole.DOORMAN_CA, see [CertificateType] in [X509Utilities]. val doormanCert = X509Utilities.createCertificate(CertificateType.INTERMEDIATE_CA, intermediateRootCert, intermediateRootKeyPair, doormanSubject, doormanKeyPair.public) val doormanCertRole = CertRole.extract(doormanCert)!! val nodeCAKeyPair = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) val nodeCACert = X509Utilities.createCertificate(CertificateType.NODE_CA, doormanCert, doormanKeyPair, nodeSubject, nodeCAKeyPair.public) val nodeCACertRole = CertRole.extract(nodeCACert)!! val tlsKeyPairFromNodeCA = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) val tlsCertFromNodeCA = X509Utilities.createCertificate(CertificateType.TLS, nodeCACert, nodeCAKeyPair, nodeSubject, tlsKeyPairFromNodeCA.public) val tlsCertFromNodeCARole = CertRole.extract(tlsCertFromNodeCA)!! val tlsKeyPairFromDoorman = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) val tlsCertFromDoorman = X509Utilities.createCertificate(CertificateType.TLS, doormanCert, doormanKeyPair, nodeSubject, tlsKeyPairFromDoorman.public) val tlsCertFromDoormanRole = CertRole.extract(tlsCertFromDoorman)!! val legalIDKeyPairFromNodeCA = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) val legalIDCertFromNodeCA = X509Utilities.createCertificate(CertificateType.LEGAL_IDENTITY, nodeCACert, nodeCAKeyPair, nodeSubject, legalIDKeyPairFromNodeCA.public) val legalIDCertFromNodeCARole = CertRole.extract(legalIDCertFromNodeCA)!! val legalIDKeyPairFromDoorman = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) val legalIDCertFromDoorman = X509Utilities.createCertificate(CertificateType.LEGAL_IDENTITY, doormanCert, doormanKeyPair, nodeSubject, legalIDKeyPairFromDoorman.public) val legalIDCertFromDoormanRole = CertRole.extract(legalIDCertFromDoorman)!! val confidentialKeyPair = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) val confidentialCert = X509Utilities.createCertificate(CertificateType.CONFIDENTIAL_LEGAL_IDENTITY, legalIDCertFromNodeCA, legalIDKeyPairFromNodeCA, nodeSubject, confidentialKeyPair.public) val confidentialCertRole = CertRole.extract(confidentialCert)!! assertNull(rootCertRole) assertNull(intermediateRootCertRole) assertEquals(tlsCertFromNodeCARole, tlsCertFromDoormanRole) assertEquals(legalIDCertFromNodeCARole, legalIDCertFromDoormanRole) assertTrue { doormanCertRole.isValidParent(intermediateRootCertRole) } // Doorman is signed by Intermediate Root. assertTrue { nodeCACertRole.isValidParent(doormanCertRole) } // NodeCA is signed by Doorman. assertTrue { tlsCertFromNodeCARole.isValidParent(nodeCACertRole) } // TLS is signed by NodeCA. assertTrue { tlsCertFromDoormanRole.isValidParent(doormanCertRole) } // TLS can also be signed by Doorman. assertTrue { legalIDCertFromNodeCARole.isValidParent(nodeCACertRole) } // Legal Identity is signed by NodeCA. assertTrue { legalIDCertFromDoormanRole.isValidParent(doormanCertRole) } // Legal Identity can also be signed by Doorman. assertTrue { confidentialCertRole.isValidParent(legalIDCertFromNodeCARole) } // Confidential key cert is signed by Legal Identity. assertFalse { legalIDCertFromDoormanRole.isValidParent(tlsCertFromDoormanRole) } // Legal Identity cannot be signed by TLS. assertFalse { tlsCertFromNodeCARole.isValidParent(legalIDCertFromNodeCARole) } // TLS cannot be signed by Legal Identity. assertFalse { confidentialCertRole.isValidParent(nodeCACertRole) } // Confidential key cert cannot be signed by NodeCA. assertFalse { confidentialCertRole.isValidParent(doormanCertRole) } // Confidential key cert cannot be signed by Doorman. } - MaxLineLength:CertificateChainCheckPolicy.kt$CertificateChainCheckPolicy.UsernameMustMatchCommonNameCheck$if (!theirChain.any { certificate -> CordaX500Name.parse(certificate.subjectDN.name).commonName == username }) { throw CertificateException("Client certificate does not match login username.") } - MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$Pair(Date(System.currentTimeMillis() - 5.minutes.toMillis()), Date(System.currentTimeMillis() + 10.days.toMillis())) MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$private MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val (nodeCert, nodeKeys) = nodeKeyStore.query { getCertificateAndKeyPair(X509Utilities.CORDA_CLIENT_CA, nodeKeyStore.entryPassword) } - MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val (tlsCert, tlsKeys) = sslKeyStore.query { getCertificateAndKeyPair(X509Utilities.CORDA_CLIENT_TLS, sslKeyStore.entryPassword) } - MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val distPointName = DistributionPointName(GeneralNames(GeneralName(GeneralName.uniformResourceIdentifier, it))) - MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val newNodeCert = replaceCrlDistPointCaCertificate(nodeCert, CertificateType.NODE_CA, INTERMEDIATE_CA.keyPair, nodeCaCrlDistPoint) MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val newTlsCert = replaceCrlDistPointCaCertificate(tlsCert, CertificateType.TLS, nodeKeys, tlsCrlDistPoint, X500Name.getInstance(ROOT_CA.certificate.subjectX500Principal.encoded)) - MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val nodeCert = (signingCertificateStore to p2pSslConfiguration).recreateNodeCaAndTlsCertificates(nodeCrlDistPoint, tlsCrlDistPoint) MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val nodeCertChain = listOf(newNodeCert, INTERMEDIATE_CA.certificate, *nodeKeyStore.query { getCertificateChain(X509Utilities.CORDA_CLIENT_CA) }.drop(2).toTypedArray()) MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val sslCertChain = listOf(newTlsCert, newNodeCert, INTERMEDIATE_CA.certificate, *sslKeyStore.query { getCertificateChain(X509Utilities.CORDA_CLIENT_TLS) }.drop(3).toTypedArray()) - MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests.Companion$builder.addCRLEntry(it, Date(System.currentTimeMillis() - 10.minutes.toMillis()), ReasonFlags.certificateHold) - MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests.Companion$val builder = JcaX509v2CRLBuilder(caCertificate.subjectX500Principal, Date(System.currentTimeMillis() - 1.minutes.toMillis())) - MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests.Companion$val issuingDistPoint = IssuingDistributionPoint(DistributionPointName(GeneralNames(issuingDistPointName)), indirect, false) - MaxLineLength:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests.Companion$val signer = JcaContentSignerBuilder(signatureAlgorithm).setProvider(Crypto.findProvider("BC")).build(caPrivateKey) - MaxLineLength:CertificateStore.kt$CertificateStore$ operator fun get(alias: String): X509Certificate MaxLineLength:CertificateStore.kt$CertificateStore.Companion$fun fromFile(storePath: Path, password: String, entryPassword: String, createNew: Boolean): CertificateStore MaxLineLength:CertificateStore.kt$CertificateStore.Companion$fun fromInputStream(stream: InputStream, password: String, entryPassword: String): CertificateStore MaxLineLength:CertificateStore.kt$CertificateStore.Companion$fun fromResource(storeResourceName: String, password: String, entryPassword: String, classLoader: ClassLoader = Thread.currentThread().contextClassLoader): CertificateStore MaxLineLength:CertificateStore.kt$CertificateStore.Companion$fun of(store: X509KeyStore, password: String, entryPassword: String): CertificateStore MaxLineLength:CertificateStore.kt$DelegatingCertificateStore : CertificateStore - MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.Companion$@JvmStatic fun withBaseDirectory(baseDirectory: Path, certificatesDirectoryName: String = DEFAULT_CERTIFICATES_DIRECTORY_NAME, keyStoreFileName: String = KeyStore.DEFAULT_STORE_FILE_NAME, keyStorePassword: String = KeyStore.DEFAULT_STORE_PASSWORD, keyPassword: String = keyStorePassword, trustStoreFileName: String = TrustStore.DEFAULT_STORE_FILE_NAME, trustStorePassword: String = TrustStore.DEFAULT_STORE_PASSWORD): MutualSslConfiguration - MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.Companion$@JvmStatic fun withCertificatesDirectory(certificatesDirectory: Path, keyStoreFileName: String = KeyStore.DEFAULT_STORE_FILE_NAME, keyStorePassword: String = KeyStore.DEFAULT_STORE_PASSWORD, keyPassword: String = keyStorePassword, trustStoreFileName: String = TrustStore.DEFAULT_STORE_FILE_NAME, trustStorePassword: String = TrustStore.DEFAULT_STORE_PASSWORD, trustStoreKeyPassword: String = TrustStore.DEFAULT_KEY_PASSWORD, useOpenSsl: Boolean = false): MutualSslConfiguration - MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.Companion$keyPassword: String = keyStorePassword MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.Companion$keyStoreFileName: String = KeyStore.DEFAULT_STORE_FILE_NAME MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.Companion$keyStorePassword: String = KeyStore.DEFAULT_STORE_PASSWORD MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.Companion$return withCertificatesDirectory(baseDirectory / certificatesDirectoryName, keyStoreFileName, keyStorePassword, keyPassword, trustStoreFileName, trustStorePassword) MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.Companion$trustStoreFileName: String = TrustStore.DEFAULT_STORE_FILE_NAME - MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.Companion$trustStorePassword: String = TrustStore.DEFAULT_STORE_PASSWORD - MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.Companion$val keyStore = FileBasedCertificateStoreSupplier(certificatesDirectory / keyStoreFileName, keyStorePassword, keyPassword) MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.Companion$val trustStore = FileBasedCertificateStoreSupplier(certificatesDirectory / trustStoreFileName, trustStorePassword, trustStoreKeyPassword) - MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.KeyStore.Companion$@JvmStatic fun withBaseDirectory(baseDirectory: Path, password: String = DEFAULT_STORE_PASSWORD, keyPassword: String = password, certificatesDirectoryName: String = DEFAULT_CERTIFICATES_DIRECTORY_NAME, certificateStoreFileName: String = DEFAULT_STORE_FILE_NAME): FileBasedCertificateStoreSupplier MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.KeyStore.Companion$@JvmStatic fun withCertificatesDirectory(certificatesDirectory: Path, password: String = DEFAULT_STORE_PASSWORD, keyPassword: String = password, certificateStoreFileName: String = DEFAULT_STORE_FILE_NAME): FileBasedCertificateStoreSupplier MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.KeyStore.Companion$certificateStoreFileName: String = DEFAULT_STORE_FILE_NAME MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.KeyStore.Companion$certificatesDirectoryName: String = DEFAULT_CERTIFICATES_DIRECTORY_NAME MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.KeyStore.Companion$return FileBasedCertificateStoreSupplier(baseDirectory / certificatesDirectoryName / certificateStoreFileName, password, keyPassword) - MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.KeyStore.Companion$return FileBasedCertificateStoreSupplier(certificatesDirectory / certificateStoreFileName, password, keyPassword) MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.TrustStore.Companion$@JvmStatic fun withBaseDirectory(baseDirectory: Path, password: String = DEFAULT_STORE_PASSWORD, keyPassword: String = DEFAULT_KEY_PASSWORD, certificatesDirectoryName: String = DEFAULT_CERTIFICATES_DIRECTORY_NAME, certificateStoreFileName: String = DEFAULT_STORE_FILE_NAME): FileBasedCertificateStoreSupplier MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.TrustStore.Companion$certificatesDirectoryName: String = DEFAULT_CERTIFICATES_DIRECTORY_NAME MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.TrustStore.Companion$keyPassword: String = DEFAULT_KEY_PASSWORD MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.TrustStore.Companion$return FileBasedCertificateStoreSupplier(baseDirectory / certificatesDirectoryName / certificateStoreFileName, password, keyPassword) - MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.P2P.TrustStore.Companion$return FileBasedCertificateStoreSupplier(certificatesDirectory / certificateStoreFileName, password, keyPassword) - MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.Signing.Companion$@JvmStatic fun withBaseDirectory(baseDirectory: Path, password: String = DEFAULT_STORE_PASSWORD, keyPassword: String = password, certificatesDirectoryName: String = DEFAULT_CERTIFICATES_DIRECTORY_NAME, certificateStoreFileName: String = DEFAULT_STORE_FILE_NAME): FileBasedCertificateStoreSupplier MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.Signing.Companion$certificatesDirectoryName: String = DEFAULT_CERTIFICATES_DIRECTORY_NAME MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.Signing.Companion$keyPassword: String = password MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.Signing.Companion$return FileBasedCertificateStoreSupplier(baseDirectory / certificatesDirectoryName / certificateStoreFileName, password, keyPassword) - MaxLineLength:CertificateStoreStubs.kt$CertificateStoreStubs.Signing.Companion$return FileBasedCertificateStoreSupplier(certificatesDirectory / certificateStoreFileName, password, keyPassword) MaxLineLength:CertificateStoreSupplier.kt$FileBasedCertificateStoreSupplier : CertificateStoreSupplier MaxLineLength:CertificatesUtils.kt$fun saveToKeyStore(keyStorePath: Path, rpcKeyPair: KeyPair, selfSignCert: X509Certificate, password: String = "password", alias: String = "Key"): Path - MaxLineLength:CertificatesUtils.kt$fun saveToTrustStore(trustStorePath: Path, selfSignCert: X509Certificate, password: String = "password", alias: String = "Key"): Path - MaxLineLength:CertificatesUtils.kt$validityWindow: Pair<Duration, Duration> = X509Utilities.DEFAULT_VALIDITY_WINDOW - MaxLineLength:CheatingSecurityProvider.kt$CheatingSecurityProvider : ProviderAutoCloseable - MaxLineLength:CheatingSecurityProvider.kt$CheatingSecurityProvider$CheatingSecureRandomService : Service - MaxLineLength:CheckCommand.kt$CheckCommand$description - MaxLineLength:CheckpointSerializationAPI.kt$CheckpointSerializationContext$/** * A whitelist that determines (mostly for security purposes) whether a particular encoding may be used when deserializing. */ val encodingWhitelist: EncodingWhitelist - MaxLineLength:CheckpointSerializationScheme.kt$CheckpointSerializationContextImpl$override fun withEncodingWhitelist(encodingWhitelist: EncodingWhitelist) MaxLineLength:CheckpointSerializationScheme.kt$CheckpointSerializationContextImpl$override val encodingWhitelist: EncodingWhitelist = NullEncodingWhitelist - MaxLineLength:CheckpointSerializationTestHelpers.kt$CheckpointSerializationEnvironmentRule.Companion$Executors.newCachedThreadPool(testThreadFactory(true)) // Close enough to what InVMConnector makes normally. - MaxLineLength:CheckpointSerializationTestHelpers.kt$CheckpointSerializationEnvironmentRule.Companion$InVMConnector::class.staticField<ExecutorService>("threadPoolExecutor").value MaxLineLength:CheckpointVerifier.kt$CheckpointIncompatibleException$FlowVersionIncompatibleException : CheckpointIncompatibleException MaxLineLength:CheckpointVerifier.kt$CheckpointIncompatibleException$SubFlowCoreVersionIncompatibleException : CheckpointIncompatibleException MaxLineLength:CheckpointVerifier.kt$CheckpointIncompatibleException.CannotBeDeserialisedException$"Found checkpoint that cannot be deserialised using the current Corda version. Please revert to the previous version of Corda, " - MaxLineLength:CheckpointVerifier.kt$CheckpointIncompatibleException.CannotBeDeserialisedException$"drain your node (see https://docs.corda.net/upgrading-cordapps.html#flow-drains), and try again. Cause: ${e.message}" MaxLineLength:CheckpointVerifier.kt$CheckpointIncompatibleException.CordappNotInstalledException$"Found checkpoint for CorDapp that is no longer installed. Specifically, could not find class $classNotFound. Please install the " - MaxLineLength:CheckpointVerifier.kt$CheckpointIncompatibleException.CordappNotInstalledException$"missing CorDapp, drain your node (see https://docs.corda.net/upgrading-cordapps.html#flow-drains), and try again." - MaxLineLength:CheckpointVerifier.kt$CheckpointIncompatibleException.FlowVersionIncompatibleException$"Found checkpoint for flow: $flowClass that is incompatible with the current installed version of ${cordapp.name}. " - MaxLineLength:CheckpointVerifier.kt$CheckpointIncompatibleException.SubFlowCoreVersionIncompatibleException$"Found checkpoint for flow: $flowClass that is incompatible with the current Corda platform. Please revert to the previous " MaxLineLength:CheckpointVerifier.kt$CheckpointIncompatibleException.SubFlowCoreVersionIncompatibleException$"version of Corda (version $oldVersion), drain your node (see https://docs.corda.net/upgrading-cordapps.html#flow-drains), and try again." - MaxLineLength:CheckpointVerifier.kt$CheckpointVerifier$private MaxLineLength:CheckpointVerifier.kt$CheckpointVerifier$throw CheckpointIncompatibleException.FlowVersionIncompatibleException(subFlow.flowClass, matchingCordapp, subFlowVersion.corDappHash) - MaxLineLength:CheckpointVerifier.kt$CheckpointVerifier$throw CheckpointIncompatibleException.SubFlowCoreVersionIncompatibleException(subFlow.flowClass, subFlowVersion.platformVersion) - MaxLineLength:CheckpointVerifier.kt$CheckpointVerifier${ // If we don't then see if the flow exists in any of the CorDapps so that we can give the user a more useful error message val matchingCordapp = currentCordappsByHash.values.find { subFlow.flowClass in it.allFlows } if (matchingCordapp != null) { throw CheckpointIncompatibleException.FlowVersionIncompatibleException(subFlow.flowClass, matchingCordapp, subFlowVersion.corDappHash) } else { throw CheckpointIncompatibleException.CordappNotInstalledException(subFlow.flowClass.name) } } - MaxLineLength:ChosenList.kt$ChosenList<E> : ObservableListBase - MaxLineLength:ClassAndMemberVisitor.kt$ClassAndMemberVisitor.ClassVisitorImpl$ClassRepresentation(version, access, name, superClassName, interfaceNames, genericsDetails = signature ?: "") - MaxLineLength:ClassCarpenter.kt$ClassCarpenterImpl$/** Returns a snapshot of the currently loaded classes as a map of full class name (package names+dots) -> class object */ val loaded: Map<String, Class<*>> = HashMap(_loaded) - MaxLineLength:ClassCarpenter.kt$ClassCarpenterImpl$if (fieldNameFromItf.isEmpty() && SimpleFieldAccess::class.java in schema.interfaces) continue@methodLoop - MaxLineLength:ClassCarpenter.kt$ClassCarpenterImpl$visitMethodInsn(INVOKEVIRTUAL, toStringHelper, "add", "(L$jlString;${field.type})L$toStringHelper;", false) - MaxLineLength:ClassCarpenter.kt$InterfaceMismatchMissingAMQPFieldException$"Interface ${clazz.name} requires a field named $field but that isn't found in the schema or any superclass schemas" MaxLineLength:ClassCarpenterTest.kt$ClassCarpenterTest$ @Test fun `superclasses with double-size primitive constructor parameters`() - MaxLineLength:ClassCarpenterTestUtils.kt$AmqpCarpenterBase$properties = properties.mapValues { (_, property) -> property.copy(type = property.type.rename(from, to)) } - MaxLineLength:ClassCarpenterTestUtils.kt$AmqpCarpenterBase$protected - MaxLineLength:ClassCarpentingTypeLoaderTests.kt$ClassCarpentingTypeLoaderTests$is TypeIdentifier.Unparameterised -> RemoteTypeInformation.Unparameterised(typeIdentifier.prettyPrint(), typeIdentifier) - MaxLineLength:ClassCommand.kt$ClassCommand$throw Exception("Could not find any classes implementing ${java.util.function.Function::class.java.simpleName} " + "whose name matches '${applicableFilters.joinToString(" ")}'") - MaxLineLength:ClassGraphUtils.kt$ fun ClassGraph.pooledScan(): ScanResult - MaxLineLength:ClassHierarchyTest.kt$ClassHierarchyTest$private - MaxLineLength:ClassLoadingUtils.kt$ @StubOutForDJVM fun <T: Any> createInstancesOfClassesImplementing(classloader: ClassLoader, clazz: Class<T>): Set<T> - MaxLineLength:ClassLoadingUtilsTest.kt$ClassLoadingUtilsTest$val classes = createInstancesOfClassesImplementing(BaseInterface::class.java.classLoader, BaseInterface2::class.java) - MaxLineLength:ClassLoadingUtilsTest.kt$ClassLoadingUtilsTest$val classes = createInstancesOfClassesImplementing(BaseInterface::class.java.classLoader, BaseInterface::class.java) MaxLineLength:ClassRewriter.kt$ClassRewriter.ClassExceptionRemapper$override - MaxLineLength:ClassRewriter.kt$ClassRewriter.ClassExceptionRemapper$val mappedExceptions = exceptions?.map(analysisConfig.exceptionResolver::getThrowableOwnerName)?.toTypedArray() MaxLineLength:ClassRewriter.kt$ClassRewriter.SandboxStitcher$override - MaxLineLength:ClassRewriter.kt$ClassRewriter.SandboxStitcher$visitMethod(access, memberName, signature, genericsDetails.emptyAsNull, exceptions.toTypedArray()) - MaxLineLength:ClassRule.kt$ClassRule$final override MaxLineLength:ClassWhitelists.kt$AbstractMutableClassWhitelist$sealed - MaxLineLength:ClassWhitelists.kt$AbstractMutableClassWhitelist${ /** * There are certain delegates like [net.corda.serialization.internal.AllButBlacklisted] * which may throw when asked whether the type is listed. * In such situations - it may be a good idea to ask [delegate] first before making a check against own [whitelist]. */ return delegate.hasListed(type) || (type.name in whitelist) } MaxLineLength:ClassWhitelists.kt$TransientClassWhiteList : AbstractMutableClassWhitelist MaxLineLength:ClearNetworkCacheCli.kt$ClearNetworkCacheCli : NodeCliCommand - MaxLineLength:ClientCacheFactory.kt$ClientCacheFactory$override MaxLineLength:ClientRPCInfrastructureTests.kt$ClientRPCInfrastructureTests$assertEquals("Quote by Mark Twain: Clothes make the man. Naked people have little or no influence on society.", clientQuotes.take()) - MaxLineLength:ClientRPCInfrastructureTests.kt$ClientRPCInfrastructureTests$assertEquals("Quote by Mark Twain: I have never let my schooling interfere with my education.", clientQuotes.take()) - MaxLineLength:ClientRPCInfrastructureTests.kt$ClientRPCInfrastructureTests$assertEquals("Quote by Oscar Wilde: Always forgive your enemies - nothing annoys them so much.", clientQuotes.take()) - MaxLineLength:ClientRPCInfrastructureTests.kt$ClientRPCInfrastructureTests$assertThat(clientQuotes.take()).isEqualTo("Quote by Mark Twain: I have never let my schooling interfere with my education.") - MaxLineLength:ClientRelevantException.kt$ClientRelevantException : CordaRuntimeExceptionClientRelevantError - MaxLineLength:ClientRpcSslOptions.kt$ClientRpcSslOptions - MaxLineLength:ClientRpcSslOptions.kt$ClientRpcSslOptions$data - MaxLineLength:ClientRpcTutorial.kt$PrintOrVisualise - MaxLineLength:ClientRpcTutorial.kt$driver MaxLineLength:ClientRpcTutorial.kt$val (transactions: List<SignedTransaction>, futureTransactions: Observable<SignedTransaction>) = proxy.internalVerifiedTransactionsFeed() - MaxLineLength:ClockUtilsTest.kt$ClockUtilsTest$assertFalse(NodeSchedulerService.awaitWithDeadline(stoppedClock, stoppedClock.instant()), "Should have reached deadline") - MaxLineLength:ClockUtilsTest.kt$ClockUtilsTest$assertFalse(NodeSchedulerService.awaitWithDeadline(stoppedClock, stoppedClock.instant(), future), "Should have reached deadline") MaxLineLength:ClockUtilsTest.kt$ClockUtilsTest$assertFalse(NodeSchedulerService.awaitWithDeadline(stoppedClock, stoppedClock.instant().minus(1.hours)), "Should have reached deadline") MaxLineLength:ClockUtilsTest.kt$ClockUtilsTest$assertFalse(NodeSchedulerService.awaitWithDeadline(stoppedClock, stoppedClock.instant().minus(1.hours), future), "Should have reached deadline") - MaxLineLength:ClockUtilsTest.kt$ClockUtilsTest$assertFalse(NodeSchedulerService.awaitWithDeadline(testClock, advancedClock.instant()), "Should have reached deadline") - MaxLineLength:ClockUtilsTest.kt$ClockUtilsTest$assertFalse(NodeSchedulerService.awaitWithDeadline(testClock, advancedClock.instant(), future), "Should have reached deadline") MaxLineLength:ClockUtilsTest.kt$ClockUtilsTest$assertTrue(NodeSchedulerService.awaitWithDeadline(stoppedClock, advancedClock.instant(), future), "Should not have reached deadline") - MaxLineLength:ClockUtilsTest.kt$ClockUtilsTest$assertTrue(NodeSchedulerService.awaitWithDeadline(testClock, advancedClock.instant(), future), "Should not have reached deadline") MaxLineLength:CollectSignaturesFlow.kt$CollectSignatureFlow : FlowLogic - MaxLineLength:CollectSignaturesFlow.kt$CollectSignaturesFlow : FlowLogic MaxLineLength:CollectSignaturesFlow.kt$CollectSignaturesFlow$@JvmOverloads constructor(partiallySignedTx: SignedTransaction, sessionsToCollectFrom: Collection<FlowSession>, progressTracker: ProgressTracker = CollectSignaturesFlow.tracker()) : this(partiallySignedTx, sessionsToCollectFrom, null, progressTracker) MaxLineLength:CollectSignaturesFlow.kt$CollectSignaturesFlow$override val progressTracker: ProgressTracker = CollectSignaturesFlow.tracker() MaxLineLength:CollectSignaturesFlow.kt$SignTransactionFlow$"The Initiator of CollectSignaturesFlow must have signed the transaction. Found $signingWellKnownIdentities, expected $otherSideSession" MaxLineLength:CollectSignaturesFlow.kt$SignTransactionFlow$override val progressTracker: ProgressTracker = SignTransactionFlow.tracker() - MaxLineLength:CollectSignaturesFlow.kt$SignTransactionFlow$val signingWellKnownIdentities = groupPublicKeysByWellKnownParty(serviceHub, stx.sigs.map(TransactionSignature::by), true) - MaxLineLength:CollectSignaturesFlow.kt$SignTransactionFlow${ progressTracker.currentStep = RECEIVING // Receive transaction and resolve dependencies, check sufficient signatures is disabled as we don't have all signatures. val stx = subFlow(ReceiveTransactionFlow(otherSideSession, checkSufficientSignatures = false)) // Receive the signing key that the party requesting the signature expects us to sign with. Having this provided // means we only have to check we own that one key, rather than matching all keys in the transaction against all // keys we own. val signingKeys = otherSideSession.receive<List<PublicKey>>().unwrap { keys -> // TODO: We should have a faster way of verifying we own a single key serviceHub.keyManagementService.filterMyKeys(keys) } progressTracker.currentStep = VERIFYING // Check that the Responder actually needs to sign. checkMySignaturesRequired(stx, signingKeys) // Check the signatures which have already been provided. Usually the Initiators and possibly an Oracle's. checkSignatures(stx) stx.tx.toLedgerTransaction(serviceHub).verify() // Perform some custom verification over the transaction. try { checkTransaction(stx) } catch (e: Exception) { if (e is IllegalStateException || e is IllegalArgumentException || e is AssertionError) throw FlowException(e) else throw e } // Sign and send back our signature to the Initiator. progressTracker.currentStep = SIGNING val mySignatures = signingKeys.map { key -> serviceHub.createSignature(stx, key) } otherSideSession.send(mySignatures) // Return the additionally signed transaction. return stx + mySignatures } - MaxLineLength:CollectSignaturesFlowTests.kt$CollectSignaturesFlowTests.Companion$private val classMockNet = InternalMockNetwork(cordappsForAllNodes = listOf(DUMMY_CONTRACTS_CORDAPP, enclosedCordapp())) - MaxLineLength:CollectSignaturesFlowTests.kt$CollectSignaturesFlowTests.Companion$private val miniCorpServices = MockServices(listOf("net.corda.testing.contracts"), miniCorp, rigorousMock<IdentityService>()) - MaxLineLength:CollectSignaturesFlowTests.kt$CollectSignaturesFlowTests.TestFlow$Initiator : FlowLogic - MaxLineLength:CollectSignaturesFlowTests.kt$CollectSignaturesFlowTests.TestFlow.Initiator$val builder = TransactionBuilder(notary).withItems(StateAndContract(state, DummyContract.PROGRAM_ID), command) MaxLineLength:CollectSignaturesFlowTests.kt$CollectSignaturesFlowTests.TestFlow.Initiator$val sessions = excludeHostNode(serviceHub, groupAbstractPartyByWellKnownParty(serviceHub, state.owners)).map { initiateFlow(it.key) } - MaxLineLength:CollectionSerializer.kt$CollectionSerializer : AMQPSerializer MaxLineLength:CollectionSerializer.kt$CollectionSerializer$private val typeNotation: TypeNotation = RestrictedType(AMQPTypeIdentifiers.nameForType(declaredType), null, emptyList(), "list", Descriptor(typeDescriptor), emptyList()) - MaxLineLength:CollectionSerializer.kt$CollectionSerializer.Companion$ fun resolveDeclared(declaredTypeInformation: LocalTypeInformation.ACollection): LocalTypeInformation.ACollection MaxLineLength:CollectionSerializer.kt$CollectionSerializer.Companion$fun resolveActual(actualClass: Class<*>, declaredTypeInformation: LocalTypeInformation.ACollection): LocalTypeInformation.ACollection - MaxLineLength:CollectionSerializer.kt$CollectionSerializer.Companion$is TypeIdentifier.Parameterised -> erasedInformation.withElementType(declaredTypeInformation.elementType) - MaxLineLength:CollectionSerializer.kt$CollectionSerializer.Companion$private - MaxLineLength:CollectionSerializer.kt$CollectionSerializer.Companion$private val supportedTypeIdentifiers = supportedTypes.keys.asSequence().map { TypeIdentifier.forClass(it) }.toSet() - MaxLineLength:CommandLineCompatibilityCheckerTest.kt$CommandLineCompatibilityCheckerTest$val breaks = CommandLineCompatibilityChecker().checkBackwardsCompatibility(CommandLine(Dummy()), CommandLine(Dummy2())) - MaxLineLength:CommandLineCompatibilityCheckerTest.kt$CommandLineCompatibilityCheckerTest$val breaks = CommandLineCompatibilityChecker().checkBackwardsCompatibility(CommandLine(value1), CommandLine(value2)) MaxLineLength:CommandLineCompatibilityUtils.kt$CommandDescription - MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$?: MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$EnumOptionsChangedError(it.key + " on command ${old.commandName} previously accepted: $oldEnums, and now is missing $toPrint}") MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$PositionalArgumentsChangedError("Positional Parameter [ ${it.parameterName} ] has been removed from subcommand: ${old.commandName}") MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$fun checkAllCommandsArePresent(old: List<CommandDescription>, new: List<CommandDescription>): List<CliBackwardsCompatibilityValidationCheck> - MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$fun checkAllOptionsArePresent(old: CommandDescription, new: CommandDescription): List<CliBackwardsCompatibilityValidationCheck> - MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$fun checkAllParamsAreOfTheSameType(old: CommandDescription, new: CommandDescription): List<CliBackwardsCompatibilityValidationCheck> MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$fun checkAllPositionalCharactersArePresent(old: CommandDescription, new: CommandDescription): List<CliBackwardsCompatibilityValidationCheck> - MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$fun checkBackwardsCompatibility(old: CommandLine, new: CommandLine): List<CliBackwardsCompatibilityValidationCheck> - MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$fun checkCommandLineIsBackwardsCompatible(commandLineToCheck: Class<*>): List<CliBackwardsCompatibilityValidationCheck> MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$private - MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$return objectMapper.readValue<List<CommandDescription>>(inputStream, object : TypeReference<List<CommandDescription>>() {}) MaxLineLength:CommandLineCompatibilityUtils.kt$CommandLineCompatibilityChecker$val potentiallyChanged = oldAcceptableTypes.filter { newAcceptableTypes[it.key] != null && newAcceptableTypes[it.key]!!.toSet() != it.value.toSet() } MaxLineLength:CommandLineCompatibilityUtils.kt$ParameterDescription - MaxLineLength:CommandLineInterface.kt$CommandLineInterface$"${instance.reachableAddress} {ssh:${instance.portMapping[Constants.NODE_SSHD_PORT]}, " - MaxLineLength:CommandLineInterface.kt$CommandLineInterface$NetworkBuilder.instance() .withBasedir(baseDir) .withNetworkName(networkName) .onNodeBuild { builtNode -> println("Built node: ${builtNode.name} to image: ${builtNode.localImageId}") } - MaxLineLength:CommandLineInterface.kt$CommandLineInterface$NetworkBuilder.instance() .withBasedir(baseDir) .withNetworkName(networkName) .onNodeBuild { builtNode -> println("Built node: ${builtNode.name} to image: ${builtNode.localImageId}") } .onNodePushed { pushedNode -> println("Pushed node: ${pushedNode.name} to: ${pushedNode.remoteImageName}") } MaxLineLength:CommandLineInterface.kt$CommandLineInterface$nodeAdder.addNode(context, Constants.ALPHA_NUMERIC_ONLY_REGEX.replace(it.key.toLowerCase(), ""), CordaX500Name.parse(it.value)) MaxLineLength:CommandParsers.kt$CliParser$@Option(names = ["--add"], split = ":", description = ["The node to add. Format is <Name>:<X500>. Eg; \"Node1:O=Bank A, L=New York, C=US, OU=Org Unit, CN=Service Name\""]) MaxLineLength:CommandParsers.kt$CliParser$@Option(names = ["-b", "--backend"], description = ["The backend to use when instantiating nodes. Valid values: LOCAL_DOCKER and AZURE."]) - MaxLineLength:CommercialPaper.kt$CommercialPaper : Contract - MaxLineLength:CommercialPaper.kt$CommercialPaper$"the transaction is signed by the owner of the CP" using (input.owner.owningKey in command.signers) - MaxLineLength:CommercialPaper.kt$CommercialPaper$val time = timeWindow?.fromTime ?: throw IllegalArgumentException("Redemptions must have a time-window") - MaxLineLength:CommercialPaper.kt$CommercialPaper.Commands$Issue : TypeOnlyCommandDataCommands MaxLineLength:CommercialPaper.kt$CommercialPaper.State$// Although kotlin is smart enough not to need these, as we are using the ICommercialPaperState, we need to declare them explicitly for use later, override fun withOwner(newOwner: AbstractParty): ICommercialPaperState MaxLineLength:CommercialPaper.kt$CommercialPaper.State$override fun toString() - MaxLineLength:CommercialPaper.kt$CommercialPaper.State$override fun withFaceValue(newFaceValue: Amount<Issued<Currency>>): ICommercialPaperState - MaxLineLength:CommercialPaper.kt$CommercialPaper.State$override fun withMaturityDate(newMaturityDate: Instant): ICommercialPaperState MaxLineLength:CommercialPaperIssueFlow.kt$CommercialPaperIssueFlow$constructor(amount: Amount<Currency>, issueRef: OpaqueBytes, recipient: Party, notary: Party) : this(amount, issueRef, recipient, notary, tracker()) - MaxLineLength:CommercialPaperIssueFlow.kt$CommercialPaperIssueFlow$val tx = CommercialPaperUtils.generateIssue(ourIdentity.ref(issueRef), amount `issued by` ourIdentity.ref(issueRef), Instant.now() + 10.days, notary) MaxLineLength:CommercialPaperSchemaV1.kt$CommercialPaperSchemaV1 : MappedSchema MaxLineLength:CommercialPaperSchemaV1.kt$CommercialPaperSchemaV1.PersistentCommercialPaperState$@Table(name = "cp_states", indexes = [Index(name = "ccy_code_index", columnList = "ccy_code"), Index(name = "maturity_index", columnList = "maturity_instant"), Index(name = "face_value_index", columnList = "face_value")]) - MaxLineLength:CommercialPaperTests.kt$CommercialPaperTestsGeneric$CashUtils.generateSpend(aliceServices, builder, 9000.DOLLARS, alice.identity, AnonymousParty(megaCorp.publicKey)) MaxLineLength:CommercialPaperTests.kt$CommercialPaperTestsGeneric$CommercialPaperUtils.generateRedeem(builder, moveTX.tx.outRef(1), megaCorpServices, megaCorpServices.myInfo.singleIdentityAndCert()) - MaxLineLength:CommercialPaperTests.kt$CommercialPaperTestsGeneric$VaultFiller(aliceServices, dummyNotary).fillWithSomeTestCash(9000.DOLLARS, issuerServices, 1, dummyCashIssuer.ref(1)) - MaxLineLength:CommercialPaperTests.kt$CommercialPaperTestsGeneric$VaultFiller(megaCorpServices, dummyNotary).fillWithSomeTestCash(13000.DOLLARS, issuerServices, 1, dummyCashIssuer.ref(1)) - MaxLineLength:CommercialPaperTests.kt$CommercialPaperTestsGeneric$aliceServices.recordTransactions(bigCorpCash.states.map { megaCorpServices.validatedTransactions.getTransaction(it.ref.txhash)!! }) - MaxLineLength:CommercialPaperTests.kt$CommercialPaperTestsGeneric$megaCorpServices.recordTransactions(aliceCash.states.map { aliceServices.validatedTransactions.getTransaction(it.ref.txhash)!! }) - MaxLineLength:CommercialPaperTests.kt$CommercialPaperTestsGeneric$output(thisTest.getContract(), "alice's paper", "paper".output<ICommercialPaperState>().withOwner(alice.party)) - MaxLineLength:CommercialPaperTests.kt$CommercialPaperTestsGeneric$val issueBuilder = CommercialPaperUtils.generateIssue(issuance, faceValue, TEST_TX_TIME + 30.days, dummyNotary.party) MaxLineLength:CommercialPaperTests.kt$CommercialPaperTestsGeneric.<no name provided>$override fun loadState(stateRef: StateRef): TransactionState<*> MaxLineLength:CommercialPaperUtils.kt$CommercialPaperUtils$ @JvmStatic fun generateIssue(issuance: PartyAndReference, faceValue: Amount<Issued<Currency>>, maturityDate: Instant, notary: Party): TransactionBuilder MaxLineLength:CommercialPaperUtils.kt$CommercialPaperUtils$ @Throws(InsufficientBalanceException::class) @JvmStatic @Suspendable fun generateRedeem(tx: TransactionBuilder, paper: StateAndRef<CommercialPaper.State>, services: ServiceHub, ourIdentity: PartyAndCertificate) - MaxLineLength:CommercialPaperUtils.kt$CommercialPaperUtils$CashUtils.generateSpend(services, tx, paper.state.data.faceValue.withoutIssuer(), ourIdentity, paper.state.data.owner) - MaxLineLength:CommonSerializationTestHelpers.kt$fun <T> SerializationEnvironment.asContextEnv(inheritable: Boolean = false, callable: (SerializationEnvironment) -> T): T - MaxLineLength:CompatibilityTest.kt$CompatibilityTest$fail - MaxLineLength:CompatibilityTest.kt$CompatibilityTest$val (serializedBytes, schema) = output.serializeAndReturnSchema(transaction, SerializationDefaults.STORAGE_CONTEXT) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$ComponentGroup(SIGNERS_GROUP.ordinal, twoCommandsforKey1.map { it.signers.serialize() }.subList(0, 1)) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$allCommandsNoKey1Ftx.checkCommandVisibility(DUMMY_KEY_1.public) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(1, ftxInputs.filteredComponentGroups.size) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(1, ftxOneInput.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.components.size) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(1, ftxOneInput.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.nonces.size) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(1, ftxOneInput.filteredComponentGroups.size) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(3, ftxCompatible.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.components.size) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(3, ftxCompatible.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.nonces.size) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(3, ftxInputs.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.components.size) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(3, ftxInputs.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.nonces.size) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(wireTransactionA, WireTransaction(componentGroups = shuffledComponentGroupsA, privacySalt = privacySalt)) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(wireTransactionA.groupsMerkleRoots[NOTARY_GROUP.ordinal], wireTransaction1ShuffledInputs.groupsMerkleRoots[NOTARY_GROUP.ordinal]) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(wireTransactionA.groupsMerkleRoots[OUTPUTS_GROUP.ordinal], wireTransaction1ShuffledInputs.groupsMerkleRoots[OUTPUTS_GROUP.ordinal]) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(wireTransactionCompatibleA.availableComponentGroups, wireTransactionA.availableComponentGroups) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(wireTransactionCompatibleA.componentGroups.map { it.groupIndex }.max()!!, ftxCompatibleNoInputs.groupHashes.size - 1) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertEquals(wireTransactionCompatibleA.componentGroups.size - 1, ftxCompatibleNoInputs.filteredComponentGroups.size) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertFails { ftxConstructor.invoke(key1CommandsFtx.id, updatedFilteredComponentsNoSignersKey1SamePMT, key1CommandsFtx.groupHashes) } - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertFailsWith<ComponentVisibilityException> { ftxNoLastCommandAndSigners.checkCommandVisibility(DUMMY_KEY_1.public) } MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertFailsWith<ComponentVisibilityException> { noCommandsFtx.checkAllComponentsVisible(SIGNERS_GROUP) } - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertFailsWith<IllegalStateException> { WireTransaction(componentGroups = componentGroupsCompatible, privacySalt = PrivacySalt()) } MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertFailsWith<IllegalStateException> { WireTransaction(componentGroups = componentGroupsLessSigners, privacySalt = PrivacySalt()) } MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertNotEquals(wireTransactionA.groupsMerkleRoots[INPUTS_GROUP.ordinal], wireTransaction1ShuffledInputs.groupsMerkleRoots[INPUTS_GROUP.ordinal]) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertNotEquals(wireTransactionCompatibleA, wireTransactionA) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertNotNull(ftxCompatible.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.partialMerkleTree) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertNotNull(ftxInputs.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.partialMerkleTree) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$assertNotNull(ftxOneInput.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.partialMerkleTree) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$is Command<*> -> elem.signers.size == 1 - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$key1CommandsFtx.checkAllComponentsVisible(SIGNERS_GROUP) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$key1CommandsFtx.filteredComponentGroups[1].partialMerkleTree - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$oneKey1CommandFtxA.checkAllComponentsVisible(SIGNERS_GROUP) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$oneKey1CommandFtxB.checkAllComponentsVisible(SIGNERS_GROUP) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$private val attachmentGroup by lazy { ComponentGroup(ATTACHMENTS_GROUP.ordinal, attachments.map { it.serialize() }) } // The list is empty. - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$private val newUnknownComponentGroup = ComponentGroup(100, listOf(OpaqueBytes(secureRandomBytes(4)), OpaqueBytes(secureRandomBytes(8)))) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$private val wireTransactionA by lazy { WireTransaction(componentGroups = componentGroupsA, privacySalt = privacySalt) } MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val alterSignerComponents = signerComponents.subList(0, 2) + signerComponents[1] // Third one is removed and the 2nd command is added twice. MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val alterSignersHashes = wtx.availableComponentHashes[ComponentGroupEnum.SIGNERS_GROUP.ordinal]!!.subList(0, 2) + componentHash(key1CommandsFtx.filteredComponentGroups[1].nonces[2], alterSignerComponents[2]) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val attachments = ComponentGroup(ATTACHMENTS_GROUP.ordinal, listOf(paramsHash.serialize())) // Same hash as network parameters - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val ftxAlterSigner = ftxConstructor.invoke(key1CommandsFtx.id, alterFilteredComponents, key1CommandsFtx.groupHashes) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val ftxAlterSignerB = ftxConstructor.invoke(key1CommandsFtx.id, alterFilteredComponents, key1CommandsFtx.groupHashes.subList(0, 6) + alterMTree.hash) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val ftxCompatibleAll = wireTransactionCompatibleA.buildFilteredTransaction(Predicate { true }) // All filtered, including the unknown component. MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val ftxNoLastCommandAndSigners = ftxConstructor.invoke(key1CommandsFtx.id, updatedFilteredComponentsNoLastCommandAndSigners, key1CommandsFtx.groupHashes) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val ftxNoLastSigner = ftxConstructor.invoke(key2CommandsFtx.id, updatedFilteredComponentsNoSignersKey2SamePMT, key2CommandsFtx.groupHashes) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val ftxNoLastSignerB = ftxConstructor.invoke(key2CommandsFtx.id, updatedFilteredComponentsNoSignersKey2, key2CommandsFtx.groupHashes) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val ftxOneInput = wireTransactionA.buildFilteredTransaction(Predicate(::filteringOneInput)) // First input only filtered. - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val groups = createComponentGroups(inputs, outputs, commands, attachments, notary, timeWindow, emptyList(), null) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val twoCommandsforKey1 = listOf(dummyCommand(DUMMY_KEY_1.public, DUMMY_KEY_2.public), dummyCommand(DUMMY_KEY_2.public), dummyCommand(DUMMY_KEY_1.public)) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val updatedFilteredComponentsNoSignersKey1SamePMT = listOf(key1CommandsFtx.filteredComponentGroups[0], noLastSignerGroupSamePartialTree) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val updatedFilteredComponentsNoSignersKey2 = listOf(key2CommandsFtx.filteredComponentGroups[0], noLastSignerGroup) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val updatedFilteredComponentsNoSignersKey2SamePMT = listOf(key2CommandsFtx.filteredComponentGroups[0], noLastSignerGroupSamePartialTree) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val wireTransaction1ShuffledInputs = WireTransaction(componentGroups = componentGroupsB, privacySalt = privacySalt) - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests$val wireTransactionOtherPrivacySalt = WireTransaction(componentGroups = componentGroupsA, privacySalt = PrivacySalt()) MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests${ // Filter out all of the components. val ftxNothing = wireTransactionA.buildFilteredTransaction(Predicate { false }) // Nothing filtered. // Although nothing filtered, we still receive the group hashes for the top level Merkle tree. // Note that attachments are not sent, but group hashes include the allOnesHash flag for the attachment group hash; that's why we expect +1 group hashes. assertEquals(wireTransactionA.componentGroups.size + 1, ftxNothing.groupHashes.size) ftxNothing.verify() // Include all of the components. val ftxAll = wireTransactionA.buildFilteredTransaction(Predicate { true }) // All filtered. ftxAll.verify() ftxAll.checkAllComponentsVisible(INPUTS_GROUP) ftxAll.checkAllComponentsVisible(OUTPUTS_GROUP) ftxAll.checkAllComponentsVisible(COMMANDS_GROUP) ftxAll.checkAllComponentsVisible(ATTACHMENTS_GROUP) ftxAll.checkAllComponentsVisible(NOTARY_GROUP) ftxAll.checkAllComponentsVisible(TIMEWINDOW_GROUP) ftxAll.checkAllComponentsVisible(SIGNERS_GROUP) ftxAll.checkAllComponentsVisible(PARAMETERS_GROUP) // Filter inputs only. fun filtering(elem: Any): Boolean { return when (elem) { is StateRef -> true else -> false } } val ftxInputs = wireTransactionA.buildFilteredTransaction(Predicate(::filtering)) // Inputs only filtered. ftxInputs.verify() ftxInputs.checkAllComponentsVisible(INPUTS_GROUP) assertEquals(1, ftxInputs.filteredComponentGroups.size) // We only add component groups that are not empty, thus in this case: the inputs only. assertEquals(3, ftxInputs.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.components.size) // All 3 inputs are present. assertEquals(3, ftxInputs.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.nonces.size) // And their corresponding nonces. assertNotNull(ftxInputs.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.partialMerkleTree) // And the Merkle tree. // Filter one input only. fun filteringOneInput(elem: Any) = elem == inputs[0] val ftxOneInput = wireTransactionA.buildFilteredTransaction(Predicate(::filteringOneInput)) // First input only filtered. ftxOneInput.verify() assertFailsWith<ComponentVisibilityException> { ftxOneInput.checkAllComponentsVisible(INPUTS_GROUP) } assertEquals(1, ftxOneInput.filteredComponentGroups.size) // We only add component groups that are not empty, thus in this case: the inputs only. assertEquals(1, ftxOneInput.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.components.size) // 1 input is present. assertEquals(1, ftxOneInput.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.nonces.size) // And its corresponding nonce. assertNotNull(ftxOneInput.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.partialMerkleTree) // And the Merkle tree. // The old client (receiving more component types than expected) is still compatible. val componentGroupsCompatibleA = listOf( inputGroup, outputGroup, commandGroup, notaryGroup, timeWindowGroup, signersGroup, newUnknownComponentGroup // A new unknown component with ordinal 100 that we cannot process. ) val wireTransactionCompatibleA = WireTransaction(componentGroupsCompatibleA, privacySalt) val ftxCompatible = wireTransactionCompatibleA.buildFilteredTransaction(Predicate(::filtering)) ftxCompatible.verify() assertEquals(ftxInputs.inputs, ftxCompatible.inputs) assertEquals(wireTransactionCompatibleA.id, ftxCompatible.id) assertEquals(1, ftxCompatible.filteredComponentGroups.size) assertEquals(3, ftxCompatible.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.components.size) assertEquals(3, ftxCompatible.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.nonces.size) assertNotNull(ftxCompatible.filteredComponentGroups.firstOrNull { it.groupIndex == INPUTS_GROUP.ordinal }!!.partialMerkleTree) assertNull(wireTransactionCompatibleA.networkParametersHash) assertNull(ftxCompatible.networkParametersHash) // Now, let's allow everything, including the new component type that we cannot process. val ftxCompatibleAll = wireTransactionCompatibleA.buildFilteredTransaction(Predicate { true }) // All filtered, including the unknown component. ftxCompatibleAll.verify() assertEquals(wireTransactionCompatibleA.id, ftxCompatibleAll.id) // Check we received the last element that we cannot process (backwards compatibility). assertEquals(wireTransactionCompatibleA.componentGroups.size, ftxCompatibleAll.filteredComponentGroups.size) // Hide one component group only. // Filter inputs only. fun filterOutInputs(elem: Any): Boolean { return when (elem) { is StateRef -> false else -> true } } val ftxCompatibleNoInputs = wireTransactionCompatibleA.buildFilteredTransaction(Predicate(::filterOutInputs)) ftxCompatibleNoInputs.verify() assertFailsWith<ComponentVisibilityException> { ftxCompatibleNoInputs.checkAllComponentsVisible(INPUTS_GROUP) } assertEquals(wireTransactionCompatibleA.componentGroups.size - 1, ftxCompatibleNoInputs.filteredComponentGroups.size) assertEquals(wireTransactionCompatibleA.componentGroups.map { it.groupIndex }.max()!!, ftxCompatibleNoInputs.groupHashes.size - 1) } - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests${ // Merkle tree computation is deterministic if the same salt and ordering are used. val wireTransactionB = WireTransaction(componentGroups = componentGroupsA, privacySalt = privacySalt) assertEquals(wireTransactionA, wireTransactionB) // Merkle tree computation will change if privacy salt changes. val wireTransactionOtherPrivacySalt = WireTransaction(componentGroups = componentGroupsA, privacySalt = PrivacySalt()) assertNotEquals(wireTransactionA, wireTransactionOtherPrivacySalt) // Full Merkle root is computed from the list of Merkle roots of each component group. assertEquals(wireTransactionA.merkleTree.hash, MerkleTree.getMerkleTree(wireTransactionA.groupHashes).hash) // Trying to add an empty component group (not allowed), e.g. the empty attachmentGroup. val componentGroupsEmptyAttachment = listOf( inputGroup, outputGroup, commandGroup, attachmentGroup, notaryGroup, timeWindowGroup, signersGroup ) assertFails { WireTransaction(componentGroups = componentGroupsEmptyAttachment, privacySalt = privacySalt) } // Ordering inside a component group matters. val inputsShuffled = listOf(stateRef2, stateRef1, stateRef3) val inputShuffledGroup = ComponentGroup(INPUTS_GROUP.ordinal, inputsShuffled.map { it -> it.serialize() }) val componentGroupsB = listOf( inputShuffledGroup, outputGroup, commandGroup, notaryGroup, timeWindowGroup, signersGroup ) val wireTransaction1ShuffledInputs = WireTransaction(componentGroups = componentGroupsB, privacySalt = privacySalt) // The ID has changed due to change of the internal ordering in inputs. assertNotEquals(wireTransaction1ShuffledInputs, wireTransactionA) // Inputs group Merkle roots are not equal. assertNotEquals(wireTransactionA.groupsMerkleRoots[INPUTS_GROUP.ordinal], wireTransaction1ShuffledInputs.groupsMerkleRoots[INPUTS_GROUP.ordinal]) // But outputs group Merkle leaf (and the rest) remained the same. assertEquals(wireTransactionA.groupsMerkleRoots[OUTPUTS_GROUP.ordinal], wireTransaction1ShuffledInputs.groupsMerkleRoots[OUTPUTS_GROUP.ordinal]) assertEquals(wireTransactionA.groupsMerkleRoots[NOTARY_GROUP.ordinal], wireTransaction1ShuffledInputs.groupsMerkleRoots[NOTARY_GROUP.ordinal]) assertNull(wireTransactionA.groupsMerkleRoots[ATTACHMENTS_GROUP.ordinal]) assertNull(wireTransaction1ShuffledInputs.groupsMerkleRoots[ATTACHMENTS_GROUP.ordinal]) // Group leaves (components) ordering does not affect the id. In this case, we added outputs group before inputs. val shuffledComponentGroupsA = listOf( outputGroup, inputGroup, commandGroup, notaryGroup, timeWindowGroup, signersGroup ) assertEquals(wireTransactionA, WireTransaction(componentGroups = shuffledComponentGroupsA, privacySalt = privacySalt)) } - MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests${ // Required to call the private constructor. val ftxConstructor = ::FilteredTransaction // 1st and 3rd commands require a signature from KEY_1. val twoCommandsforKey1 = listOf(dummyCommand(DUMMY_KEY_1.public, DUMMY_KEY_2.public), dummyCommand(DUMMY_KEY_2.public), dummyCommand(DUMMY_KEY_1.public)) val componentGroups = listOf( inputGroup, outputGroup, ComponentGroup(COMMANDS_GROUP.ordinal, twoCommandsforKey1.map { it.value.serialize() }), notaryGroup, timeWindowGroup, ComponentGroup(SIGNERS_GROUP.ordinal, twoCommandsforKey1.map { it.signers.serialize() }) ) val wtx = WireTransaction(componentGroups = componentGroups, privacySalt = PrivacySalt()) // Filter KEY_1 commands (commands 1 and 3). fun filterKEY1Commands(elem: Any): Boolean { return when (elem) { is Command<*> -> DUMMY_KEY_1.public in elem.signers else -> false } } // Filter KEY_2 commands (commands 1 and 2). fun filterKEY2Commands(elem: Any): Boolean { return when (elem) { is Command<*> -> DUMMY_KEY_2.public in elem.signers else -> false } } val key1CommandsFtx = wtx.buildFilteredTransaction(Predicate(::filterKEY1Commands)) val key2CommandsFtx = wtx.buildFilteredTransaction(Predicate(::filterKEY2Commands)) // val commandDataComponents = key1CommandsFtx.filteredComponentGroups[0].components val commandDataHashes = wtx.availableComponentHashes[ComponentGroupEnum.COMMANDS_GROUP.ordinal]!! val noLastCommandDataPMT = PartialMerkleTree.build( MerkleTree.getMerkleTree(commandDataHashes), commandDataHashes.subList(0, 1) ) val noLastCommandDataComponents = key1CommandsFtx.filteredComponentGroups[0].components.subList(0, 1) val noLastCommandDataNonces = key1CommandsFtx.filteredComponentGroups[0].nonces.subList(0, 1) val noLastCommandDataGroup = FilteredComponentGroup( ComponentGroupEnum.COMMANDS_GROUP.ordinal, noLastCommandDataComponents, noLastCommandDataNonces, noLastCommandDataPMT ) val signerComponents = key1CommandsFtx.filteredComponentGroups[1].components val signerHashes = wtx.availableComponentHashes[ComponentGroupEnum.SIGNERS_GROUP.ordinal]!! val noLastSignerPMT = PartialMerkleTree.build( MerkleTree.getMerkleTree(signerHashes), signerHashes.subList(0, 2) ) val noLastSignerComponents = key1CommandsFtx.filteredComponentGroups[1].components.subList(0, 2) val noLastSignerNonces = key1CommandsFtx.filteredComponentGroups[1].nonces.subList(0, 2) val noLastSignerGroup = FilteredComponentGroup( ComponentGroupEnum.SIGNERS_GROUP.ordinal, noLastSignerComponents, noLastSignerNonces, noLastSignerPMT ) val noLastSignerGroupSamePartialTree = FilteredComponentGroup( ComponentGroupEnum.SIGNERS_GROUP.ordinal, noLastSignerComponents, noLastSignerNonces, key1CommandsFtx.filteredComponentGroups[1].partialMerkleTree) // We don't update that, so we can catch the index mismatch. val updatedFilteredComponentsNoSignersKey2 = listOf(key2CommandsFtx.filteredComponentGroups[0], noLastSignerGroup) val updatedFilteredComponentsNoSignersKey2SamePMT = listOf(key2CommandsFtx.filteredComponentGroups[0], noLastSignerGroupSamePartialTree) // There are only two components in key1CommandsFtx (commandData and signers). assertEquals(2, key1CommandsFtx.componentGroups.size) // Remove last signer for which there is a pointer from a visible commandData. This is the case of Key1. // This will result to an invalid transaction. // A command with no corresponding signer detected // because the pointer of CommandData (3rd leaf) cannot find a corresponding (3rd) signer. val updatedFilteredComponentsNoSignersKey1SamePMT = listOf(key1CommandsFtx.filteredComponentGroups[0], noLastSignerGroupSamePartialTree) assertFails { ftxConstructor.invoke(key1CommandsFtx.id, updatedFilteredComponentsNoSignersKey1SamePMT, key1CommandsFtx.groupHashes) } // Remove both last signer (KEY1) and related command. // Update partial Merkle tree for signers. val updatedFilteredComponentsNoLastCommandAndSigners = listOf(noLastCommandDataGroup, noLastSignerGroup) val ftxNoLastCommandAndSigners = ftxConstructor.invoke(key1CommandsFtx.id, updatedFilteredComponentsNoLastCommandAndSigners, key1CommandsFtx.groupHashes) // verify() will pass as the transaction is well-formed. ftxNoLastCommandAndSigners.verify() // checkCommandVisibility() will not pass, because checkAllComponentsVisible(ComponentGroupEnum.SIGNERS_GROUP) will fail. assertFailsWith<ComponentVisibilityException> { ftxNoLastCommandAndSigners.checkCommandVisibility(DUMMY_KEY_1.public) } // Remove last signer for which there is no pointer from a visible commandData. This is the case of Key2. // Do not change partial Merkle tree for signers. // This time the object can be constructed as there is no pointer mismatch. val ftxNoLastSigner = ftxConstructor.invoke(key2CommandsFtx.id, updatedFilteredComponentsNoSignersKey2SamePMT, key2CommandsFtx.groupHashes) // verify() will fail as we didn't change the partial Merkle tree. assertFailsWith<FilteredTransactionVerificationException> { ftxNoLastSigner.verify() } // checkCommandVisibility() will not pass. assertFailsWith<ComponentVisibilityException> { ftxNoLastSigner.checkCommandVisibility(DUMMY_KEY_2.public) } // Remove last signer for which there is no pointer from a visible commandData. This is the case of Key2. // Update partial Merkle tree for signers. val ftxNoLastSignerB = ftxConstructor.invoke(key2CommandsFtx.id, updatedFilteredComponentsNoSignersKey2, key2CommandsFtx.groupHashes) // verify() will pass, the transaction is well-formed. ftxNoLastSignerB.verify() // But, checkAllComponentsVisible() will not pass. assertFailsWith<ComponentVisibilityException> { ftxNoLastSignerB.checkCommandVisibility(DUMMY_KEY_2.public) } // Modify last signer (we have a pointer from commandData). // Update partial Merkle tree for signers. val alterSignerComponents = signerComponents.subList(0, 2) + signerComponents[1] // Third one is removed and the 2nd command is added twice. val alterSignersHashes = wtx.availableComponentHashes[ComponentGroupEnum.SIGNERS_GROUP.ordinal]!!.subList(0, 2) + componentHash(key1CommandsFtx.filteredComponentGroups[1].nonces[2], alterSignerComponents[2]) val alterMTree = MerkleTree.getMerkleTree(alterSignersHashes) val alterSignerPMTK = PartialMerkleTree.build( alterMTree, alterSignersHashes ) val alterSignerGroup = FilteredComponentGroup( ComponentGroupEnum.SIGNERS_GROUP.ordinal, alterSignerComponents, key1CommandsFtx.filteredComponentGroups[1].nonces, alterSignerPMTK ) val alterFilteredComponents = listOf(key1CommandsFtx.filteredComponentGroups[0], alterSignerGroup) // Do not update groupHashes. val ftxAlterSigner = ftxConstructor.invoke(key1CommandsFtx.id, alterFilteredComponents, key1CommandsFtx.groupHashes) // Visible components in signers group cannot be verified against their partial Merkle tree. assertFailsWith<FilteredTransactionVerificationException> { ftxAlterSigner.verify() } // Also, checkAllComponentsVisible() will not pass (groupHash matching will fail). assertFailsWith<ComponentVisibilityException> { ftxAlterSigner.checkCommandVisibility(DUMMY_KEY_1.public) } // Update groupHashes. val ftxAlterSignerB = ftxConstructor.invoke(key1CommandsFtx.id, alterFilteredComponents, key1CommandsFtx.groupHashes.subList(0, 6) + alterMTree.hash) // Visible components in signers group cannot be verified against their partial Merkle tree. assertFailsWith<FilteredTransactionVerificationException> { ftxAlterSignerB.verify() } // Also, checkAllComponentsVisible() will not pass (top level Merkle tree cannot be verified against transaction's id). assertFailsWith<ComponentVisibilityException> { ftxAlterSignerB.checkCommandVisibility(DUMMY_KEY_1.public) } } MaxLineLength:CompatibleTransactionTests.kt$CompatibleTransactionTests${ val groups = createComponentGroups(inputs, outputs, commands, attachments, notary, timeWindow, emptyList(), null) val wireTransactionOldConstructor = WireTransaction(groups, privacySalt) assertEquals(wireTransactionA, wireTransactionOldConstructor) // Malformed tx - attachments is not List<SecureHash>. For this example, we mistakenly added input-state (StateRef) serialised objects with ATTACHMENTS_GROUP.ordinal. val componentGroupsB = listOf( inputGroup, outputGroup, commandGroup, ComponentGroup(ATTACHMENTS_GROUP.ordinal, inputGroup.components), notaryGroup, timeWindowGroup, signersGroup ) assertFails { WireTransaction(componentGroupsB, privacySalt).attachments.toList() } // Malformed tx - duplicated component group detected. val componentGroupsDuplicatedCommands = listOf( inputGroup, outputGroup, commandGroup, // First commandsGroup. commandGroup, // Second commandsGroup. notaryGroup, timeWindowGroup, signersGroup ) assertFails { WireTransaction(componentGroupsDuplicatedCommands, privacySalt) } // Malformed tx - inputs is not a serialised object at all. val componentGroupsC = listOf( ComponentGroup(INPUTS_GROUP.ordinal, listOf(OpaqueBytes(ByteArray(8)))), outputGroup, commandGroup, notaryGroup, timeWindowGroup, signersGroup ) assertFails { WireTransaction(componentGroupsC, privacySalt) } val componentGroupsCompatibleA = listOf( inputGroup, outputGroup, commandGroup, notaryGroup, timeWindowGroup, signersGroup, newUnknownComponentGroup // A new unknown component with ordinal 100 that we cannot process. ) // The old client (receiving more component types than expected) is still compatible. val wireTransactionCompatibleA = WireTransaction(componentGroupsCompatibleA, privacySalt) assertEquals(wireTransactionCompatibleA.availableComponentGroups, wireTransactionA.availableComponentGroups) // The known components are the same. assertNotEquals(wireTransactionCompatibleA, wireTransactionA) // But obviously, its Merkle root has changed Vs wireTransactionA (which doesn't include this extra component). // The old client will throw if receiving an empty component (even if this is unknown). val componentGroupsCompatibleEmptyNew = listOf( inputGroup, outputGroup, commandGroup, notaryGroup, timeWindowGroup, signersGroup, newUnknownComponentEmptyGroup // A new unknown component with ordinal 101 that we cannot process. ) assertFails { WireTransaction(componentGroupsCompatibleEmptyNew, privacySalt) } } - MaxLineLength:ComposableTypePropertySerializer.kt$AMQPPropertyReadStrategy$override - MaxLineLength:ComposableTypePropertySerializer.kt$ComposableTypePropertySerializer.Companion$ fun make(name: String, propertyInformation: LocalPropertyInformation, factory: LocalSerializerFactory): PropertySerializer - MaxLineLength:ComposableTypePropertySerializer.kt$ComposableTypePropertySerializer.Companion$ fun makeForEvolution(name: String, isCalculated: Boolean, typeIdentifier: TypeIdentifier, type: Type): PropertySerializer - MaxLineLength:ComposableTypePropertySerializer.kt$ComposableTypePropertySerializer.Companion$PropertyReadStrategy.make(name, propertyInformation.type.typeIdentifier, propertyInformation.type.observedType) - MaxLineLength:ComposableTypePropertySerializer.kt$DescribedTypeReadStrategy : PropertyReadStrategy - MaxLineLength:ComposableTypePropertySerializer.kt$DescribedTypeReadStrategy$override - MaxLineLength:ComposableTypePropertySerializer.kt$EvolutionPropertyWriteStrategy$override - MaxLineLength:ComposableTypePropertySerializer.kt$PropertyReadStrategy$ fun readProperty(obj: Any?, schemas: SerializationSchemas, input: DeserializationInput, context: SerializationContext): Any? - MaxLineLength:ComposableTypePropertySerializer.kt$PropertyReader - MaxLineLength:ComposableTypePropertySerializer.kt$PropertyReader.Companion$is LocalPropertyInformation.PrivateConstructorPairedProperty -> FieldReader(propertyInformation.observedField) - MaxLineLength:ComposableTypePropertySerializer.kt$PropertyWriteStrategy$ fun writeProperty(obj: Any?, data: Data, output: SerializationOutput, context: SerializationContext, debugIndent: Int) - MaxLineLength:ComposableTypePropertySerializer.kt$PropertyWriteStrategy.Companion$ fun make(name: String, propertyInformation: LocalPropertyInformation, factory: LocalSerializerFactory): PropertyWriteStrategy - MaxLineLength:CompositeKey.kt$CompositeKey$ fun isFulfilledBy(keysToCheck: Iterable<PublicKey>): Boolean - MaxLineLength:CompositeKey.kt$CompositeKey$return SubjectPublicKeyInfo(AlgorithmIdentifier(CordaObjectIdentifier.COMPOSITE_KEY), DERSequence(keyVector)).encoded - MaxLineLength:CompositeKey.kt$CompositeKey.Builder$ fun build(threshold: Int? = null): PublicKey - MaxLineLength:CompositeKey.kt$CompositeKey.Builder$require(threshold == null || threshold > 0) { "Threshold must not be specified or its value must be greater than zero" } - MaxLineLength:CompositeKey.kt$CompositeKey.Builder${ "Trying to build invalid CompositeKey, threshold value different than weight of single child node." } - MaxLineLength:CompositeKey.kt$CompositeKey.Builder${ require(threshold == null || threshold == children.first().weight) { "Trying to build invalid CompositeKey, threshold value different than weight of single child node." } // Returning the only child node which is [PublicKey] itself. We need to avoid single-key [CompositeKey] instances, // as there are scenarios where developers expected the underlying key and its composite versions to be equivalent. children.first().node } - MaxLineLength:CompositeKey.kt$CompositeKey.NodeAndWeight$if (weight == other.weight) // TODO: this might be expensive, consider a faster deterministic compareTo implementation when weights are equal. node.encoded.sequence().compareTo(other.node.encoded.sequence()) else weight.compareTo(other.weight) - MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$// By lazy is required so that the serialisers are configured before vals initialisation takes place (they internally invoke serialise). private val aliceSignature by lazy { aliceKey.sign(SignableData(secureHash, SignatureMetadata(1, Crypto.findSignatureScheme(alicePublicKey).schemeNumberID))) } MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$@Test() fun `composite key validation with graph cycle detection`() - MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$assertFalse { engine.verify(CompositeSignaturesWithKeys(listOf(aliceSignature, brokenBobSignature)).serialize().bytes) } - MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$assertTrue { engine.verify(CompositeSignaturesWithKeys(listOf(aliceSignature, bobSignature)).serialize().bytes) } - MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$assertTrue { engine.verify(CompositeSignaturesWithKeys(listOf(aliceSignature, bobSignature, charlieSignature)).serialize().bytes) } - MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$assertTrue { engine.verify(CompositeSignaturesWithKeys(listOf(aliceSignature, charlieSignature)).serialize().bytes) } - MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$assertTrue { engine.verify(CompositeSignaturesWithKeys(listOf(bobSignature, charlieSignature)).serialize().bytes) } MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$private MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$private val bobSignature by lazy { bobKey.sign(SignableData(secureHash, SignatureMetadata(1, Crypto.findSignatureScheme(bobPublicKey).schemeNumberID))) } MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$private val charlieSignature by lazy { charlieKey.sign(SignableData(secureHash, SignatureMetadata(1, Crypto.findSignatureScheme(charliePublicKey).schemeNumberID))) } @@ -4761,98 +3119,50 @@ MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$val RSASignature = keyPairRSA.sign(SignableData(secureHash, SignatureMetadata(1, Crypto.findSignatureScheme(keyPairRSA.public).schemeNumberID))) MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$val SPSignature = keyPairSP.sign(SignableData(secureHash, SignatureMetadata(1, Crypto.findSignatureScheme(keyPairSP.public).schemeNumberID))) MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$val brokenBobSignature = TransactionSignature(aliceSignature.bytes, bobSignature.by, SignatureMetadata(1, Crypto.findSignatureScheme(bobSignature.by).schemeNumberID)) - MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$val composite1 = CompositeKey.Builder().addKeys(pub1, pub2, pub3, pub4, pub5, pub6, pub7).build() as CompositeKey - MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$val composite2 = CompositeKey.Builder().addKeys(pub7, pub6, pub5, pub4, pub3, pub2, pub1).build() as CompositeKey MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$val compositeKey = CompositeKey.Builder().addKeys(keyPairRSA.public, keyPairK1.public, keyPairR1.public, keyPairEd.public, keyPairSP.public).build() as CompositeKey - MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$val compositeKeyCert = X509Utilities.createCertificate(CertificateType.LEGAL_IDENTITY, ca, caKeyPair, caName, compositeKey) - MaxLineLength:CompositeKeyTests.kt$CompositeKeyTests$val twoOfThree = CompositeKey.Builder().addKeys(alicePublicKey, bobPublicKey, charliePublicKey).build(threshold = 2) - MaxLineLength:CompositeMemberCompositeSchemaToClassCarpenterTests.kt$CompositeMembers$val mangledMap = envelope.typeInformation.values.find { it.typeIdentifier.name == "java.util.Map" }!!.mangle<C>() MaxLineLength:CompositeSignature.kt$CompositeSignature$throw InvalidKeyException("Composite signatures must be assembled independently from signatures provided by the component private keys") MaxLineLength:CompositeSignature.kt$CompositeSignature$throw SignatureException("Composite signatures must be assembled independently from signatures provided by the component private keys") MaxLineLength:CompositeSignature.kt$CompositeSignature.Companion$@JvmStatic fun getService(provider: Provider) - MaxLineLength:CompositeSignaturesWithKeys.kt$CompositeSignaturesWithKeys - MaxLineLength:ConcatenatedList.kt$ConcatenatedList$val permutedOffset = (if (permutedListIndex == 0) 0 else newSubNestedIndexOffsets[permutedListIndex - 1]) - MaxLineLength:ConcatenatedList.kt$ConcatenatedList${ // If a nested element is updated we simply propagate the update by offsetting the nested element index // by the startingOffsetOf the nested list. val listIndex = indexMap[wrapped]!!.first val startingOffset = startingOffsetOf(listIndex) for (i in change.from until change.to) { nextUpdate(startingOffset + i) } } - MaxLineLength:ConcatenatedList.kt$ConcatenatedList<A> : TransformationList - MaxLineLength:ConcatenatedListTest.kt$ConcatenatedListTest$sourceList = FXCollections.observableArrayList<ObservableList<String>>(FXCollections.observableArrayList("hello")) - MaxLineLength:ConcurrencyUtils.kt$ fun <V, W> firstOf(vararg futures: CordaFuture<out V>, handler: (CordaFuture<out V>) -> W) - MaxLineLength:ConcurrencyUtils.kt$internal - MaxLineLength:ConfigExporter.kt$ConfigExporter$fileWriter.write(configToWrite.root().render(ConfigRenderOptions.concise().setFormatted(true).setJson(false))) - MaxLineLength:ConfigExporter.kt$ConfigExporter$ourParsedConfig = ourParsedConfig.withValue("keyStorePassword", testNetParsedConfig.getValue("keyStorePassword")) - MaxLineLength:ConfigExporter.kt$ConfigExporter$ourParsedConfig = ourParsedConfig.withValue("trustStorePassword", testNetParsedConfig.getValue("trustStorePassword")) MaxLineLength:ConfigParsingTest.kt$ConfigParsingTest$assertThatThrownBy { configuration.parseAs<TypedConfiguration>() } - MaxLineLength:ConfigParsingTest.kt$ConfigParsingTest$private inline - MaxLineLength:ConfigParsingTest.kt$ConfigParsingTest$testPropertyType<InstantData, InstantListData, Instant>(Instant.now(), Instant.now().plusMillis(100), valuesToString = true) - MaxLineLength:ConfigParsingTest.kt$ConfigParsingTest$testPropertyType<LocalDateData, LocalDateListData, LocalDate>(LocalDate.now(), LocalDate.now().plusDays(1), valuesToString = true) - MaxLineLength:ConfigParsingTest.kt$ConfigParsingTest$testPropertyType<URLData, URLListData, URL>(URL("http://localhost:1234"), URL("http://localhost:1235"), valuesToString = true) MaxLineLength:ConfigParsingTest.kt$ConfigParsingTest$testPropertyType<X500PrincipalData, X500PrincipalListData, X500Principal>(X500Principal("C=US, L=New York, CN=Corda Root CA, OU=Corda, O=R3 HoldCo LLC"), X500Principal("O=Bank A,L=London,C=GB"), valuesToString = true) MaxLineLength:ConfigSections.kt$BFTSmartConfigSpec$return valid(BFTSmartConfig(configuration[replicaId], configuration[clusterAddresses], configuration[debug], configuration[exposeRaces])) - MaxLineLength:ConfigSections.kt$CertChainPolicyConfigSpec$@Suppress("DEPRECATION") internal - MaxLineLength:ConfigSections.kt$CertChainPolicyConfigSpec$return valid(CertChainPolicyConfig(configuration[role], configuration[policy], configuration[trustedAliases].toSet())) - MaxLineLength:ConfigSections.kt$DatabaseConfigSpec$private val exportHibernateJMXStatistics by boolean().optional().withDefaultValue(DatabaseConfig.Defaults.exportHibernateJMXStatistics) MaxLineLength:ConfigSections.kt$DatabaseConfigSpec$private val initialiseAppSchema by enum(SchemaInitializationType::class).optional().withDefaultValue(DatabaseConfig.Defaults.initialiseAppSchema) - MaxLineLength:ConfigSections.kt$DatabaseConfigSpec$private val mappedSchemaCacheSize by long().optional().withDefaultValue(DatabaseConfig.Defaults.mappedSchemaCacheSize) MaxLineLength:ConfigSections.kt$DatabaseConfigSpec$private val transactionIsolationLevel by enum(TransactionIsolationLevel::class).optional().withDefaultValue(DatabaseConfig.Defaults.transactionIsolationLevel) MaxLineLength:ConfigSections.kt$DatabaseConfigSpec$return valid(DatabaseConfig(configuration[initialiseSchema], configuration[initialiseAppSchema], configuration[transactionIsolationLevel], configuration[exportHibernateJMXStatistics], configuration[mappedSchemaCacheSize])) - MaxLineLength:ConfigSections.kt$DevModeOptionsSpec$private val allowCompatibilityZone by boolean().optional().withDefaultValue(DevModeOptions.Defaults.allowCompatibilityZone) - MaxLineLength:ConfigSections.kt$DevModeOptionsSpec$private val disableCheckpointChecker by boolean().optional().withDefaultValue(DevModeOptions.Defaults.disableCheckpointChecker) - MaxLineLength:ConfigSections.kt$FlowTimeoutConfigurationSpec$internal - MaxLineLength:ConfigSections.kt$FlowTimeoutConfigurationSpec$return valid(FlowTimeoutConfiguration(configuration[timeout], configuration[maxRestartCount], configuration[backoffBase])) - MaxLineLength:ConfigSections.kt$NetworkServicesConfigSpec$internal MaxLineLength:ConfigSections.kt$NetworkServicesConfigSpec$return valid(NetworkServicesConfig(configuration[doormanURL], configuration[networkMapURL], configuration[pnm], configuration[inferred])) MaxLineLength:ConfigSections.kt$NodeRpcSettingsSpec$return valid(NodeRpcSettings(configuration[address], configuration[adminAddress], configuration[standAloneBroker], configuration[useSsl], configuration[ssl])) - MaxLineLength:ConfigSections.kt$NotaryConfigSpec$private val etaMessageThresholdSeconds by int().optional().withDefaultValue(NotaryServiceFlow.defaultEstimatedWaitTime.seconds.toInt()) MaxLineLength:ConfigSections.kt$NotaryConfigSpec$return valid(NotaryConfig(configuration[validating], configuration[serviceLegalName], configuration[className], configuration[etaMessageThresholdSeconds], configuration[extraConfig], configuration[raft], configuration[bftSMaRt])) MaxLineLength:ConfigSections.kt$SSHDConfigurationSpec$override fun parseValid(configuration: Config): Valid<SSHDConfiguration> - MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec$internal MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec.AuthServiceSpec$dataSource.type == AuthDataSourceType.INMEMORY && options?.cache != null -> badValue("no cache supported for \"INMEMORY\" data provider") - MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec.AuthServiceSpec.DataSourceSpec$else -> valid(SecurityConfiguration.AuthService.DataSource(type, passwordEncryption, connection, users)) - MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec.AuthServiceSpec.DataSourceSpec$private MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec.AuthServiceSpec.DataSourceSpec$private val passwordEncryption by enum(PasswordEncryption::class).optional().withDefaultValue(SecurityConfiguration.AuthService.DataSource.Defaults.passwordEncryption) MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec.AuthServiceSpec.DataSourceSpec$type == AuthDataSourceType.DB && (users != null || connection == null) -> badValue("\"DB\" data source type requires \"connection\" and cannot specify \"users\"") MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec.AuthServiceSpec.DataSourceSpec$type == AuthDataSourceType.INMEMORY && (users == null || connection != null) -> badValue("\"INMEMORY\" data source type requires \"users\" and cannot specify \"connection\"") - MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec.AuthServiceSpec.OptionsSpec.CacheSpec$private MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec.AuthServiceSpec.OptionsSpec.CacheSpec$private val expireAfterSecs by long().mapValid { value -> if (value >= 0) validValue(value) else badValue("cannot be less than 0'") } MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec.AuthServiceSpec.OptionsSpec.CacheSpec$private val maxEntries by long().mapValid { value -> if (value >= 0) validValue(value) else badValue("cannot be less than 0'") } - MaxLineLength:ConfigSections.kt$SecurityConfigurationSpec.AuthServiceSpec.OptionsSpec.CacheSpec$return valid(SecurityConfiguration.AuthService.Options.Cache(configuration[expireAfterSecs], configuration[maxEntries])) MaxLineLength:ConfigUtilities.kt$ // TODO Move this to KeyStoreConfigHelpers. fun NodeConfiguration.configureWithDevSSLCertificate(cryptoService: CryptoService? = null) MaxLineLength:ConfigUtilities.kt$// Problems: // - Forces you to have a primary constructor with all fields of name and type matching the configuration file structure. // - Encourages weak bean-like types. // - Cannot support a many-to-one relationship between configuration file structures and configuration domain type. This is essential for versioning of the configuration files. // - It's complicated and based on reflection, meaning problems with it are typically found at runtime. // - It doesn't support validation errors in a structured way. If something goes wrong, it throws exceptions, which doesn't support good usability practices like displaying all the errors at once. fun <T : Any> Config.parseAs(clazz: KClass<T>, onUnknownKeys: ((Set<String>, logger: Logger) -> Unit) = UnknownConfigKeysPolicy.FAIL::handle, nestedPath: String? = null): T MaxLineLength:ConfigUtilities.kt$// TODO Move this to KeyStoreConfigHelpers. fun MutualSslConfiguration.configureDevKeyAndTrustStores(myLegalName: CordaX500Name, signingCertificateStore: FileBasedCertificateStoreSupplier, certificatesDirectory: Path, cryptoService: CryptoService? = null) - MaxLineLength:ConfigUtilities.kt$ConfigHelper$configOf( // Add substitution values here "baseDirectory" to baseDirectory.toString()) .withFallback(configOverrides) .withFallback(systemOverrides) .withFallback(environmentOverrides) .withFallback(appConfig) .withFallback(devModeConfig) MaxLineLength:ConfigUtilities.kt$ConfigHelper$return ConfigFactory.parseMap(toProperties().filterKeys { (it as String).startsWith(CORDA_PROPERTY_PREFIX) }.mapKeys { (it.key as String).removePrefix(CORDA_PROPERTY_PREFIX) }) MaxLineLength:ConfigUtilities.kt$ConfigHelper$val smartDevMode = CordaSystemUtils.isOsMac() || (CordaSystemUtils.isOsWindows() && !CordaSystemUtils.getOsName().toLowerCase().contains("server")) - MaxLineLength:ConfigUtilities.kt$ConfigHelper${ val parseOptions = ConfigParseOptions.defaults() val defaultConfig = ConfigFactory.parseResources("reference.conf", parseOptions.setAllowMissing(false)) val appConfig = ConfigFactory.parseFile(configFile.toFile(), parseOptions.setAllowMissing(allowMissingConfig)) // Detect the underlying OS. If mac or windows non-server then we assume we're running in devMode. Unless specified otherwise. val smartDevMode = CordaSystemUtils.isOsMac() || (CordaSystemUtils.isOsWindows() && !CordaSystemUtils.getOsName().toLowerCase().contains("server")) val devModeConfig = ConfigFactory.parseMap(mapOf("devMode" to smartDevMode)) val systemOverrides = ConfigFactory.systemProperties().cordaEntriesOnly() val environmentOverrides = ConfigFactory.systemEnvironment().cordaEntriesOnly() val finalConfig = configOf( // Add substitution values here "baseDirectory" to baseDirectory.toString()) .withFallback(configOverrides) .withFallback(systemOverrides) .withFallback(environmentOverrides) .withFallback(appConfig) .withFallback(devModeConfig) // this needs to be after the appConfig, so it doesn't override the configured devMode .withFallback(defaultConfig) .resolve() val entrySet = finalConfig.entrySet().filter { entry -> entry.key.contains("\"") } for ((key) in entrySet) { log.error("Config files should not contain \" in property names. Please fix: $key") } return finalConfig } - MaxLineLength:ConfigUtilities.kt$UnknownConfigurationKeysException : IllegalArgumentException - MaxLineLength:ConfigUtilities.kt$UnknownConfigurationKeysException$require(unknownKeys.isNotEmpty()) { "Absence of unknown keys should not raise UnknownConfigurationKeysException." } - MaxLineLength:ConfigUtilities.kt$UnknownConfigurationKeysException.Companion$fun of(offendingKeys: Set<String>): UnknownConfigurationKeysException - MaxLineLength:ConfigUtilities.kt$UnknownConfigurationKeysException.Companion$private fun message(offendingKeys: Set<String>) MaxLineLength:ConfigUtilities.kt$fun Any?.toConfigValue(): ConfigValue MaxLineLength:ConfigUtilities.kt$inline fun <reified T : Any> Config.parseAs(noinline onUnknownKeys: ((Set<String>, logger: Logger) -> Unit) = UnknownConfigKeysPolicy.FAIL::handle): T MaxLineLength:ConfigUtilities.kt$private - MaxLineLength:ConfigUtilities.kt$private fun parseEnum(enumType: Class<*>, name: String): Enum<*> MaxLineLength:ConfigUtilities.kt$require(clazz.isData) { "Only Kotlin data classes or class annotated with CustomConfigParser can be parsed. Offending: ${clazz.qualifiedName}" } MaxLineLength:ConfigUtilities.kt$return uncheckedCast(if (type.arguments.isEmpty()) getSingleValue(path, type, onUnknownKeys, nestedPath) else getCollectionValue(path, type, onUnknownKeys, nestedPath)) MaxLineLength:ConfigUtilities.kt$setPrivateKey(it, serviceKeystore.getPrivateKey(it, DEV_CA_KEY_STORE_PASS), serviceKeystore.getCertificateChain(it), signingKeyStore.entryPassword) - MaxLineLength:ConfigUtilities.kt$val elementClass = type.arguments[0].type?.jvmErasure ?: throw IllegalArgumentException("Cannot work with star projection: $type") MaxLineLength:ConfigUtilities.kt$val signingKeyStore = FileBasedCertificateStoreSupplier(signingCertificateStore.path, signingCertificateStore.storePassword, signingCertificateStore.entryPassword).get(true) .also { it.registerDevSigningCertificates(myLegalName) } MaxLineLength:ConfigUtilities.kt${ // These types are supported by Config as use as is value } - MaxLineLength:ConfigUtilities.kt${ // These types make sense to be represented as Strings and the exact inverse parsing function for use in parseAs value.toString() } - MaxLineLength:ConfigUtilities.kt${ val signingKeyStore = FileBasedCertificateStoreSupplier(signingCertificateStore.path, signingCertificateStore.storePassword, signingCertificateStore.entryPassword).get(true) .also { it.registerDevSigningCertificates(myLegalName) } // Move distributed service composite key (generated by IdentityGenerator.generateToDisk) to keystore if exists. val distributedServiceKeystore = certificatesDirectory / "distributedService.jks" if (distributedServiceKeystore.exists()) { val serviceKeystore = X509KeyStore.fromFile(distributedServiceKeystore, DEV_CA_KEY_STORE_PASS) signingKeyStore.update { serviceKeystore.aliases().forEach { if (serviceKeystore.internal.isKeyEntry(it)) { setPrivateKey(it, serviceKeystore.getPrivateKey(it, DEV_CA_KEY_STORE_PASS), serviceKeystore.getCertificateChain(it), signingKeyStore.entryPassword) } else { setCertificate(it, serviceKeystore.getCertificate(it)) } } } } } MaxLineLength:Configuration.kt$Configuration$Describer MaxLineLength:Configuration.kt$Configuration$Schema : ValidatorDescriber MaxLineLength:Configuration.kt$Configuration$Specification<VALUE> : SchemaParser MaxLineLength:Configuration.kt$Configuration$Validator : Validator MaxLineLength:Configuration.kt$Configuration.Describer$ fun describe(configuration: Config, serialiseValue: (Any?) -> ConfigValue = { value -> ConfigValueFactory.fromAnyRef(value.toString()) }): ConfigValue? MaxLineLength:Configuration.kt$Configuration.Property$Definition<TYPE> : MetadataValidatorExtractorDescriberParser - MaxLineLength:Configuration.kt$Configuration.Property$Metadata MaxLineLength:Configuration.kt$Configuration.Property.Definition$Single<TYPE> : Definition - MaxLineLength:Configuration.kt$Configuration.Property.Definition$override MaxLineLength:Configuration.kt$Configuration.Property.Definition.Companion$ fun <ENUM : Enum<ENUM>> enum(key: String, enumClass: KClass<ENUM>, sensitive: Boolean = false): Standard<ENUM> MaxLineLength:Configuration.kt$Configuration.Property.Definition.Companion$ fun boolean(key: String, sensitive: Boolean = false): Standard<Boolean> MaxLineLength:Configuration.kt$Configuration.Property.Definition.Companion$ fun double(key: String, sensitive: Boolean = false): Standard<Double> MaxLineLength:Configuration.kt$Configuration.Property.Definition.Companion$ fun duration(key: String, sensitive: Boolean = false): Standard<Duration> - MaxLineLength:Configuration.kt$Configuration.Property.Definition.Companion$ fun float(key: String, sensitive: Boolean = false): Standard<Float> - MaxLineLength:Configuration.kt$Configuration.Property.Definition.Companion$ fun int(key: String, sensitive: Boolean = false): Standard<Int> MaxLineLength:Configuration.kt$Configuration.Property.Definition.Companion$ fun nestedObject(key: String, schema: Schema? = null, sensitive: Boolean = false): Standard<ConfigObject> MaxLineLength:Configuration.kt$Configuration.Property.Definition.Companion$ fun string(key: String, sensitive: Boolean = false): Standard<String> MaxLineLength:Configuration.kt$Configuration.Property.Definition.Companion$invalid<Float, Configuration.Validation.Error>(Configuration.Validation.Error.BadValue.of(key, Float::class.javaObjectType.simpleName, "Provided value exceeds Float range.")) @@ -4860,9 +3170,7 @@ MaxLineLength:Configuration.kt$Configuration.Property.Definition.RequiredList$ fun <MAPPED> map(mappedTypeName: String, convert: (List<TYPE>) -> MAPPED): Required<MAPPED> MaxLineLength:Configuration.kt$Configuration.Property.Definition.RequiredList$ fun <MAPPED> mapValid(mappedTypeName: String, convert: (List<TYPE>) -> Validated<MAPPED, Validation.Error>): Required<MAPPED> MaxLineLength:Configuration.kt$Configuration.Property.Definition.Standard$ fun <MAPPED> map(mappedTypeName: String, convert: (TYPE) -> MAPPED): Standard<MAPPED> - MaxLineLength:Configuration.kt$Configuration.Property.Definition.Standard$ fun <MAPPED> mapValid(mappedTypeName: String, convert: (TYPE) -> Validated<MAPPED, Validation.Error>): Standard<MAPPED> MaxLineLength:Configuration.kt$Configuration.Schema.Companion$ fun withProperties(name: String? = null, builder: Property.Definition.Companion.() -> Iterable<Property.Definition<*>>): Schema - MaxLineLength:Configuration.kt$Configuration.Schema.Companion$ fun withProperties(name: String? = null, properties: Iterable<Property.Definition<*>>): Schema MaxLineLength:Configuration.kt$Configuration.Schema.Companion$ fun withProperties(vararg properties: Property.Definition<*>, name: String? = null): Schema MaxLineLength:Configuration.kt$Configuration.Specification$ fun <ENUM : Enum<ENUM>> enum(enumClass: KClass<ENUM>, sensitive: Boolean = false): PropertyDelegate.Standard<ENUM> MaxLineLength:Configuration.kt$Configuration.Specification$ fun <ENUM : Enum<ENUM>> enum(key: String? = null, enumClass: KClass<ENUM>, sensitive: Boolean = false): PropertyDelegate.Standard<ENUM> @@ -4877,7 +3185,6 @@ MaxLineLength:Configuration.kt$Configuration.Specification$ protected abstract fun parseValid(configuration: Config): Valid<VALUE> MaxLineLength:Configuration.kt$Configuration.Specification$abstract MaxLineLength:Configuration.kt$Configuration.Specification$final override fun parse(configuration: Config, options: Configuration.Validation.Options): Valid<VALUE> - MaxLineLength:Configuration.kt$Configuration.Specification$override fun describe(configuration: Config, serialiseValue: (Any?) -> ConfigValue) MaxLineLength:Configuration.kt$Configuration.Validation.Error$BadPath : Error MaxLineLength:Configuration.kt$Configuration.Validation.Error$BadValue : Error MaxLineLength:Configuration.kt$Configuration.Validation.Error$MalformedStructure : Error @@ -4888,10 +3195,8 @@ MaxLineLength:Configuration.kt$Configuration.Validation.Error$internal abstract fun with(keyName: String = this.keyName ?: UNKNOWN, typeName: String = this.typeName ?: UNKNOWN): Configuration.Validation.Error MaxLineLength:Configuration.kt$Configuration.Validation.Error$internal fun withContainingPathPrefix(vararg containingPath: String): Error MaxLineLength:Configuration.kt$Configuration.Validation.Error$sealed - MaxLineLength:Configuration.kt$Configuration.Validation.Error.BadPath$override fun with(keyName: String, typeName: String): BadPath MaxLineLength:Configuration.kt$Configuration.Validation.Error.BadPath$override fun withContainingPath(vararg containingPath: String) MaxLineLength:Configuration.kt$Configuration.Validation.Error.BadPath.Companion$fun of(message: String, keyName: String? = null, typeName: String = UNKNOWN, containingPath: List<String> = emptyList()): BadPath - MaxLineLength:Configuration.kt$Configuration.Validation.Error.BadValue$override fun with(keyName: String, typeName: String): BadValue MaxLineLength:Configuration.kt$Configuration.Validation.Error.BadValue$override fun withContainingPath(vararg containingPath: String) MaxLineLength:Configuration.kt$Configuration.Validation.Error.BadValue.Companion$fun of(message: String, keyName: String? = null, typeName: String = UNKNOWN, containingPath: List<String> = emptyList()): BadValue MaxLineLength:Configuration.kt$Configuration.Validation.Error.MalformedStructure$override fun with(keyName: String, typeName: String): MalformedStructure @@ -4899,12 +3204,8 @@ MaxLineLength:Configuration.kt$Configuration.Validation.Error.MalformedStructure.Companion$fun of(message: String, keyName: String? = null, typeName: String = UNKNOWN, containingPath: List<String> = emptyList()): MalformedStructure MaxLineLength:Configuration.kt$Configuration.Validation.Error.MissingValue$override fun with(keyName: String, typeName: String): MissingValue MaxLineLength:Configuration.kt$Configuration.Validation.Error.MissingValue$override fun withContainingPath(vararg containingPath: String) - MaxLineLength:Configuration.kt$Configuration.Validation.Error.MissingValue.Companion$fun forKey(keyName: String): MissingValue MaxLineLength:Configuration.kt$Configuration.Validation.Error.MissingValue.Companion$fun of(message: String, keyName: String? = null, typeName: String = UNKNOWN, containingPath: List<String> = emptyList()): MissingValue - MaxLineLength:Configuration.kt$Configuration.Validation.Error.Unknown$override fun withContainingPath(vararg containingPath: String) MaxLineLength:Configuration.kt$Configuration.Validation.Error.Unknown.Companion$fun of(keyName: String = UNKNOWN, containingPath: List<String> = emptyList()): Unknown - MaxLineLength:Configuration.kt$Configuration.Validation.Error.UnsupportedVersion$override fun withContainingPath(vararg containingPath: String) - MaxLineLength:Configuration.kt$Configuration.Validation.Error.WrongType$override fun with(keyName: String, typeName: String): WrongType MaxLineLength:Configuration.kt$Configuration.Validation.Error.WrongType$override fun withContainingPath(vararg containingPath: String) MaxLineLength:Configuration.kt$Configuration.Validation.Error.WrongType.Companion$fun forKey(keyName: String, expectedTypeName: String, actualTypeName: String): WrongType MaxLineLength:Configuration.kt$Configuration.Validation.Error.WrongType.Companion$fun of(message: String, keyName: String? = null, typeName: String = UNKNOWN, containingPath: List<String> = emptyList()): WrongType @@ -4918,35 +3219,19 @@ MaxLineLength:ConnectionChange.kt$ConnectionChange$return "ConnectionChange remoteAddress: $remoteAddress connected state: $connected cert subject: ${remoteCert?.subjectDN} cert ok: ${!badCert}" MaxLineLength:ConnectionManager.kt$ fun <A> connectToNodes(remoteNodes: List<RemoteNode>, tunnelPortAllocation: PortAllocation, withConnections: (List<NodeConnection>) -> A): A MaxLineLength:ConnectionStateMachine.kt$ConnectionStateMachine$logDebugWithMDC { "Put tag ${javax.xml.bind.DatatypeConverter.printHexBinary(delivery.tag)} on wire uuid: ${nextMessage.applicationProperties["_AMQ_DUPL_ID"]}" } - MaxLineLength:ConnectionStateMachine.kt$ConnectionStateMachine$logDebugWithMDC { "Sender delivery confirmed tag ${javax.xml.bind.DatatypeConverter.printHexBinary(delivery.tag)}" } - MaxLineLength:ConnectionStateMachine.kt$ConnectionStateMachine$sender.send(messageBuf.array(), messageBuf.arrayOffset() + messageBuf.readerIndex(), messageBuf.readableBytes()) - MaxLineLength:ConnectionStateMachine.kt$ConnectionStateMachine$val pending = transport.pending() // Note this drives frame generation, which the susbsequent writes push to the socket - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test fun `Fail early in the TransactionBuilder when attempting to change the hash of the HashConstraint on the spending transaction`() MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test fun `On contract annotated with NoConstraintPropagation there is no platform check for propagation, but the transaction builder can't use the AutomaticPlaceholderConstraint`() MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test fun `Switching from the WhitelistConstraint to the Signature Constraint fails if the signature constraint does not inherit all jar signatures`() MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test fun `Switching from the WhitelistConstraint to the Signature Constraint is possible if the attachment satisfies both constraints, and the signature constraint inherits all jar signatures`() - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$@Test fun `When the constraint of the output state is a valid transition from the input state, transaction validation works`() - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$SignableData(wireTransaction.id, SignatureMetadata(4, Crypto.findSignatureScheme(nodeKey).schemeNumberID)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFailsWith<IllegalArgumentException> { AutomaticPlaceholderConstraint.canBeTransitionedFrom(AutomaticPlaceholderConstraint, attachment) } MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFailsWith<IllegalArgumentException> { HashAttachmentConstraint(SecureHash.randomSHA256()).canBeTransitionedFrom(AutomaticPlaceholderConstraint, attachment) } - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(AlwaysAcceptAttachmentConstraint.canBeTransitionedFrom(HashAttachmentConstraint(SecureHash.randomSHA256()), attachment)) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(AlwaysAcceptAttachmentConstraint.canBeTransitionedFrom(SignatureAttachmentConstraint(ALICE_PUBKEY), attachment)) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(AlwaysAcceptAttachmentConstraint.canBeTransitionedFrom(WhitelistedByZoneAttachmentConstraint, attachment)) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(HashAttachmentConstraint(SecureHash.randomSHA256()).canBeTransitionedFrom(AlwaysAcceptAttachmentConstraint, attachment)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(HashAttachmentConstraint(SecureHash.randomSHA256()).canBeTransitionedFrom(HashAttachmentConstraint(SecureHash.randomSHA256()), attachment)) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(SignatureAttachmentConstraint(ALICE_PUBKEY).canBeTransitionedFrom(AlwaysAcceptAttachmentConstraint, attachment)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(SignatureAttachmentConstraint(ALICE_PUBKEY).canBeTransitionedFrom(HashAttachmentConstraint(SecureHash.randomSHA256()), attachment)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(SignatureAttachmentConstraint(ALICE_PUBKEY).canBeTransitionedFrom(HashAttachmentConstraint(allOnesHash), attachmentSigned)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(SignatureAttachmentConstraint(BOB_PUBKEY).canBeTransitionedFrom(SignatureAttachmentConstraint(ALICE_PUBKEY), attachment)) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(SignatureAttachmentConstraint(BOB_PUBKEY).canBeTransitionedFrom(WhitelistedByZoneAttachmentConstraint, attachment)) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(WhitelistedByZoneAttachmentConstraint.canBeTransitionedFrom(AlwaysAcceptAttachmentConstraint, attachment)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(WhitelistedByZoneAttachmentConstraint.canBeTransitionedFrom(HashAttachmentConstraint(SecureHash.randomSHA256()), attachment)) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertFalse(WhitelistedByZoneAttachmentConstraint.canBeTransitionedFrom(SignatureAttachmentConstraint(ALICE_PUBKEY), attachment)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertTrue(HashAttachmentConstraint(SecureHash.randomSHA256()).canBeTransitionedFrom(SignatureAttachmentConstraint(ALICE_PUBKEY), attachment)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertTrue(HashAttachmentConstraint(SecureHash.randomSHA256()).canBeTransitionedFrom(WhitelistedByZoneAttachmentConstraint, attachment)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertTrue(SignatureAttachmentConstraint(ALICE_PUBKEY).canBeTransitionedFrom(SignatureAttachmentConstraint(ALICE_PUBKEY), attachment)) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertTrue(SignatureAttachmentConstraint(ALICE_PUBKEY).canBeTransitionedFrom(WhitelistedByZoneAttachmentConstraint, attachment)) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$assertTrue(WhitelistedByZoneAttachmentConstraint.canBeTransitionedFrom(WhitelistedByZoneAttachmentConstraint, attachment)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$attachment(Cash.PROGRAM_ID, SecureHash.allOnesHash, listOf(hashToSignatureConstraintsKey), mapOf(Attributes.Name.IMPLEMENTATION_VERSION.toString() to "1")) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$attachment(Cash.PROGRAM_ID, SecureHash.allOnesHash, listOf(hashToSignatureConstraintsKey), mapOf(Attributes.Name.IMPLEMENTATION_VERSION.toString() to "2")) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$attachment(Cash.PROGRAM_ID, SecureHash.allOnesHash, listOf(hashToSignatureConstraintsKey), mapOf(Attributes.Name.IMPLEMENTATION_VERSION.toString() to "3")) @@ -4954,7 +3239,6 @@ MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$attachment(Cash.PROGRAM_ID, SecureHash.zeroHash, listOf(hashToSignatureConstraintsKey), mapOf(Attributes.Name.IMPLEMENTATION_VERSION.toString() to "2")) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$attachment(Cash.PROGRAM_ID, SecureHash.zeroHash, listOf(hashToSignatureConstraintsKey), mapOf(Attributes.Name.IMPLEMENTATION_VERSION.toString() to "3")) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$ledgerServices.attachments.importContractAttachment(cordapp.contractClassNames, "rpc", signedJarStream,null, listOf(jarAndSigner.second)) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$ledgerServices.attachments.importContractAttachment(cordapp.contractClassNames, "rpc", unsignedJarStream,null) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$output(Cash.PROGRAM_ID, "c1", DUMMY_NOTARY, null, HashAttachmentConstraint(SecureHash.allOnesHash), Cash.State(1000.POUNDS `issued by` ALICE_PARTY.ref(1), ALICE_PARTY)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$output(Cash.PROGRAM_ID, "c1", DUMMY_NOTARY, null, HashAttachmentConstraint(SecureHash.zeroHash), Cash.State(1000.POUNDS `issued by` ALICE_PARTY.ref(1), ALICE_PARTY)) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$output(Cash.PROGRAM_ID, "c1", DUMMY_NOTARY, null, HashAttachmentConstraint(unsignedAttachmentId), Cash.State(1000.POUNDS `issued by` ALICE_PARTY.ref(1), ALICE_PARTY)) @@ -4974,84 +3258,42 @@ MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$output(noPropagationContractClassName, "c1", DUMMY_NOTARY, null, HashAttachmentConstraint(SecureHash.zeroHash), NoPropagationContractState()) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$output(noPropagationContractClassName, "c2", DUMMY_NOTARY, null, WhitelistedByZoneAttachmentConstraint, NoPropagationContractState()) MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$output(noPropagationContractClassName, "c3", DUMMY_NOTARY, null, AutomaticPlaceholderConstraint, NoPropagationContractState()) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests$val jarAndSigner = ContractJarTestUtils.signContractJar(cordapp.jarPath, copyFirst = true, keyStoreDir = keyStoreDir.path) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests.<no name provided>$override fun loadContractAttachment(stateRef: StateRef) - MaxLineLength:ConstraintsPropagationTests.kt$ConstraintsPropagationTests.Companion$hashToSignatureConstraintsKey = keyStoreDir.path.generateKey("testAlias", "testPassword", ALICE_NAME.toString()) MaxLineLength:ConstraintsUtils.kt$ fun AttachmentConstraint.canBeTransitionedFrom(input: AttachmentConstraint, attachment: ContractAttachment): Boolean MaxLineLength:ConstraintsUtils.kt$ internal fun ContractClassName.contractHasAutomaticConstraintPropagation(classLoader: ClassLoader? = null): Boolean MaxLineLength:ConstraintsUtils.kt$HashAttachmentConstraint.disableHashConstraints && input is HashAttachmentConstraint && output is SignatureAttachmentConstraint -> true MaxLineLength:ConstraintsUtils.kt$input is AutomaticHashConstraint || output is AutomaticHashConstraint -> throw IllegalArgumentException("Illegal constraint: AutomaticHashConstraint.") MaxLineLength:ConstraintsUtils.kt$input is AutomaticPlaceholderConstraint || output is AutomaticPlaceholderConstraint -> throw IllegalArgumentException("Illegal constraint: AutomaticPlaceholderConstraint.") - MaxLineLength:ConstraintsUtils.kt$log.warnOnce("Found state ${state.contract} that is constrained by the insecure: AlwaysAcceptAttachmentConstraint.") - MaxLineLength:ConstraintsUtils.kt$require(state.constraint::class in validConstraints) { "Found state ${state.contract} with an illegal constraint: ${state.constraint}" } - MaxLineLength:ConstraintsUtils.kt$val Attachment.contractVersion: Version get() = if (this is ContractAttachment) version else CordappImpl.DEFAULT_CORDAPP_VERSION MaxLineLength:ConstraintsUtils.kt$when { // These branches should not happen, as this has been already checked. input is AutomaticPlaceholderConstraint || output is AutomaticPlaceholderConstraint -> throw IllegalArgumentException("Illegal constraint: AutomaticPlaceholderConstraint.") input is AutomaticHashConstraint || output is AutomaticHashConstraint -> throw IllegalArgumentException("Illegal constraint: AutomaticHashConstraint.") // Transition to the same constraint. input == output -> true // You can't transition from the AlwaysAcceptAttachmentConstraint to anything else, as it could hide something illegal. input is AlwaysAcceptAttachmentConstraint && output !is AlwaysAcceptAttachmentConstraint -> false // Nothing can be migrated from the HashConstraint except a HashConstraint with the same Hash. (This check is redundant, but added for clarity) input is HashAttachmentConstraint && output is HashAttachmentConstraint -> input == output // Anything (except the AlwaysAcceptAttachmentConstraint) can be transformed to a HashAttachmentConstraint. input !is HashAttachmentConstraint && output is HashAttachmentConstraint -> true // The SignatureAttachmentConstraint allows migration from a Signature constraint with the same key. // TODO - we don't support currently third party signers. When we do, the output key will have to be stronger then the input key. input is SignatureAttachmentConstraint && output is SignatureAttachmentConstraint -> input.key == output.key // HashAttachmentConstraint can be transformed to a SignatureAttachmentConstraint when hash constraint verification checking disabled. HashAttachmentConstraint.disableHashConstraints && input is HashAttachmentConstraint && output is SignatureAttachmentConstraint -> true // You can transition from the WhitelistConstraint to the SignatureConstraint only if all signers of the JAR are required to sign in the future. input is WhitelistedByZoneAttachmentConstraint && output is SignatureAttachmentConstraint -> attachment.signerKeys.isNotEmpty() && output.key.keys.containsAll(attachment.signerKeys) else -> false } - MaxLineLength:ContentSignerBuilder.kt$ContentSignerBuilder$fun build(signatureScheme: SignatureScheme, privateKey: PrivateKey, provider: Provider, random: SecureRandom? = null): ContentSigner - MaxLineLength:Context.kt$Context - MaxLineLength:ContractAttachment.kt$ContractAttachment : Attachment MaxLineLength:ContractAttachment.kt$ContractAttachment$return "ContractAttachment(attachment=${attachment.id}, contracts='$allContracts', uploader='$uploader', signed='$isSigned', version='$version')" - MaxLineLength:ContractAttachment.kt$ContractAttachment$uploader: String? = null - MaxLineLength:ContractAttachmentSerializer.kt$ContractAttachmentSerializer$return ContractAttachment.create(proxy.attachment, proxy.contract, proxy.contracts, proxy.uploader, proxy.signers, proxy.version) MaxLineLength:ContractAttachmentSerializer.kt$ContractAttachmentSerializer$return ContractAttachmentProxy(GeneratedAttachment(bytes, obj.uploader), obj.contract, obj.additionalContracts, obj.uploader, obj.signerKeys, obj.version) MaxLineLength:ContractAttachmentSerializer.kt$ContractAttachmentSerializer.ContractAttachmentProxy$@KeepForDJVM data - MaxLineLength:ContractAttachmentSerializerTest.kt$ContractAttachmentSerializerTest$val contractAttachment = ContractAttachment(GeneratedAttachment(EMPTY_BYTE_ARRAY, "test"), DummyContract.PROGRAM_ID) - MaxLineLength:ContractFunctions.kt$fun swap(partyA: Party, amountA: BigDecimal, currencyA: Currency, partyB: Party, amountB: BigDecimal, currencyB: Currency) - MaxLineLength:ContractFunctions.kt$swap(partyA, BigDecimal(notional * strike), domesticCurrency, partyB, BigDecimal(notional), foreignCurrency) MaxLineLength:ContractHierarchyTest.kt$ContractHierarchyTest$PrepareTransaction : FlowLogic - MaxLineLength:ContractHierarchyTest.kt$ContractHierarchyTest$aliceNode.services.startFlow(PrepareTransaction(bob, notary, IndirectContract.State())).resultFuture.getOrThrow() MaxLineLength:ContractHierarchyTest.kt$ContractHierarchyTest$mockNet = InternalMockNetwork(networkSendManuallyPumped = false, threadPerNode = true, cordappsForAllNodes = listOf(enclosedCordapp())) - MaxLineLength:ContractHierarchyTest.kt$ContractHierarchyTest.PrepareTransaction$val command = Command(IndirectContract.Create(), listOf(serviceHub.myInfo.singleIdentity().owningKey, otherSide.owningKey)) - MaxLineLength:ContractHierarchyTest.kt$ContractHierarchyTest.PrepareTransaction$val txB = TransactionBuilder(notary = notary, outputs = mutableListOf(txState), commands = mutableListOf(command)) - MaxLineLength:ContractJarTestUtils.kt$ContractJarTestUtils$@JvmOverloads fun makeTestContractJar(workingDir: Path, contractName: String, signed: Boolean = false, version: Int = 1, versionSeed: Int = 0): Path MaxLineLength:ContractJarTestUtils.kt$ContractJarTestUtils$@JvmOverloads fun makeTestContractJar(workingDir: Path, contractNames: List<String>, signed: Boolean = false, version: Int = 1, generateManifest: Boolean = true, jarFileName : String? = null): Path - MaxLineLength:ContractJarTestUtils.kt$ContractJarTestUtils$@JvmOverloads fun makeTestSignedContractJar(workingDir: Path, contractName: String, version: Int = 1, versionSeed: Int = 0): Pair<Path, PublicKey> MaxLineLength:ContractJarTestUtils.kt$ContractJarTestUtils$fun signContractJar(jarURL: URL, copyFirst: Boolean, keyStoreDir: Path? = null, alias: String = "testAlias", pwd: String = "testPassword"): Pair<Path, PublicKey> - MaxLineLength:ContractJarTestUtils.kt$ContractJarTestUtils$private - MaxLineLength:ContractJarTestUtils.kt$ContractJarTestUtils$val outFile = fileManager.getFileForInput(StandardLocation.CLASS_OUTPUT, packages.joinToString("."), "$className.class") MaxLineLength:ContractJarTestUtils.kt$ContractJarTestUtils$val source = object : SimpleJavaFileObject(URI.create("string:///${packages.joinToString("/")}/$className.java"), JavaFileObject.Kind.SOURCE) { override fun getCharContent(ignoreEncodingErrors: Boolean): CharSequence { return newClass } } MaxLineLength:ContractStateModel.kt$ContractStateModel$val cashStates: ObservableList<StateAndRef<Cash.State>> = cashStatesDiff.fold(FXCollections.observableArrayList()) { list: MutableList<StateAndRef<Cash.State>>, (added, removed) -> list.removeIf { it in removed } list.addAll(added) }.distinctBy { it.ref } - MaxLineLength:ContractUpgradeFlow.kt$ContractUpgradeFlow$Authorise : FlowLogic MaxLineLength:ContractUpgradeFlow.kt$ContractUpgradeFlow.Initiate$( originalState: StateAndRef<OldState>, newContractClass: Class<out UpgradedContract<OldState, NewState>> ) MaxLineLength:ContractUpgradeFlow.kt$ContractUpgradeFlow.Initiate$val signableData = SignableData(tx.id, SignatureMetadata(serviceHub.myInfo.platformVersion, Crypto.findSignatureScheme(myKey).schemeNumberID)) - MaxLineLength:ContractUpgradeFlowRPCTest.kt$ContractUpgradeFlowRPCTest$has<ContractUpgradeLedgerTransaction, Any>("input data", { it.inputs.single().state.data }, isA<T>(anything)) - MaxLineLength:ContractUpgradeFlowRPCTest.kt$ContractUpgradeFlowRPCTest.Companion$private val classMockNet = InternalMockNetwork(cordappsForAllNodes = listOf(DUMMY_CONTRACTS_CORDAPP, enclosedCordapp())) - MaxLineLength:ContractUpgradeFlowTest.kt$ContractUpgradeFlowTest$and - MaxLineLength:ContractUpgradeFlowTest.kt$ContractUpgradeFlowTest$has<ContractUpgradeLedgerTransaction, Any>("input data", { it.inputs.single().state.data }, isA<T>(anything)) - MaxLineLength:ContractUpgradeFlowTest.kt$ContractUpgradeFlowTest${ // Create dummy contract. val signedByA = aliceNode.signDummyContract(alice.ref(1), 0, bob.ref(1)) val stx = bobNode.addSignatureTo(signedByA) aliceNode.finalise(stx, bob) val aliceTx = aliceNode.getValidatedTransaction(stx) val bobTx = bobNode.getValidatedTransaction(stx) // The request is expected to be rejected because party B hasn't authorised the upgrade yet. assert.that( aliceNode.initiateContractUpgrade(aliceTx, DummyContractV2::class), willThrow<UnexpectedFlowEndException>()) // Party B authorises the contract state upgrade, and immediately de-authorises the same. assert.that(bobNode.authoriseContractUpgrade(bobTx, DummyContractV2::class), willReturn()) assert.that(bobNode.deauthoriseContractUpgrade(bobTx), willReturn()) // The request is expected to be rejected because party B has subsequently de-authorised a previously authorised upgrade. assert.that( aliceNode.initiateContractUpgrade(aliceTx, DummyContractV2::class), willThrow<UnexpectedFlowEndException>()) // Party B authorises the contract state upgrade. assert.that(bobNode.authoriseContractUpgrade(bobTx, DummyContractV2::class), willReturn()) // Party A initiates contract upgrade flow, expected to succeed this time. assert.that( aliceNode.initiateContractUpgrade(aliceTx, DummyContractV2::class), willReturn( aliceNode.hasContractUpgradeTransaction<DummyContract.State, DummyContractV2.State>() and bobNode.hasContractUpgradeTransaction<DummyContract.State, DummyContractV2.State>())) val upgradedState = aliceNode.getStateFromVault(DummyContractV2.State::class) // We now test that the upgraded state can be upgraded further, to V3. // Party B authorises the contract state upgrade. assert.that(bobNode.authoriseContractUpgrade(upgradedState, DummyContractV3::class), willReturn()) // Party A initiates contract upgrade flow which is expected to succeed. assert.that( aliceNode.initiateContractUpgrade(upgradedState, DummyContractV3::class), willReturn( aliceNode.hasContractUpgradeTransaction<DummyContractV2.State, DummyContractV3.State>() and bobNode.hasContractUpgradeTransaction<DummyContractV2.State, DummyContractV3.State>())) } - MaxLineLength:ContractUpgradeFlowTest.kt$ContractUpgradeFlowTest.CashV2.State$@BelongsToContract(CashV2::class) data - MaxLineLength:ContractUpgradeFlowTest.kt$ContractUpgradeFlowTest.CashV2.State$override fun withNewOwner(newOwner: AbstractParty) MaxLineLength:ContractUpgradeFlowTest.kt$ContractUpgradeFlowTest.CashV2.State$override fun withNewOwnerAndAmount(newAmount: Amount<Issued<Currency>>, newOwner: AbstractParty) MaxLineLength:ContractUpgradeFlowTest.kt$ContractUpgradeFlowTest.Companion$private val classMockNet = InternalMockNetwork(cordappsForAllNodes = listOf(FINANCE_CONTRACTS_CORDAPP, DUMMY_CONTRACTS_CORDAPP, enclosedCordapp())) - MaxLineLength:ContractUpgradeServiceImpl.kt$ContractUpgradeServiceImpl : ContractUpgradeServiceSingletonSerializeAsToken - MaxLineLength:ContractUpgradeServiceImpl.kt$ContractUpgradeServiceImpl$override - MaxLineLength:ContractUpgradeServiceImpl.kt$ContractUpgradeServiceImpl.Companion$fun createContractUpgradesMap(cacheFactory: NamedCacheFactory): PersistentMap<String, String, DBContractUpgrade, String> MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeFilteredTransaction : CoreTransaction MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeLedgerTransaction$( inputs: List<StateAndRef<ContractState>> = this.inputs, notary: Party = this.notary, legacyContractAttachment: Attachment = this.legacyContractAttachment, upgradedContractClassName: ContractClassName = this.upgradedContract::class.java.name, upgradedContractAttachment: Attachment = this.upgradedContractAttachment, id: SecureHash = this.id, privacySalt: PrivacySalt = this.privacySalt, sigs: List<TransactionSignature> = this.sigs, networkParameters: NetworkParameters = this.networkParameters ) MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeLedgerTransaction$( inputs: List<StateAndRef<ContractState>>, notary: Party, legacyContractAttachment: Attachment, upgradedContractClassName: ContractClassName, upgradedContractAttachment: Attachment, id: SecureHash, privacySalt: PrivacySalt, sigs: List<TransactionSignature>, networkParameters: NetworkParameters ) MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeLedgerTransaction$?: - MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeLedgerTransaction$@Deprecated("ContractUpgradeLedgerTransaction should not be created directly, use ContractUpgradeWireTransaction.resolve instead.") MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeLedgerTransaction$override - MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeLedgerTransaction$override fun equals(other: Any?): Boolean MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeLedgerTransaction$return "ContractUpgradeLedgerTransaction(inputs=$inputs, notary=$notary, legacyContractAttachment=$legacyContractAttachment, upgradedContractAttachment=$upgradedContractAttachment, id=$id, privacySalt=$privacySalt, sigs=$sigs, networkParameters=$networkParameters, upgradedContract=$upgradedContract, references=$references, legacyContractClassName='$legacyContractClassName', outputs=$outputs)" MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeLedgerTransaction.Companion$@CordaInternal internal MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeLedgerTransaction.Companion$return ContractUpgradeLedgerTransaction(inputs, notary, legacyContractAttachment, upgradedContractAttachment, id, privacySalt, sigs, networkParameters, upgradedContract) - MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeLedgerTransaction.Companion$val cordappLoader = services.cordappProvider::class.java.getMethod("getCordappLoader").invoke(services.cordappProvider) - MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$ @CordaInternal internal fun resolveOutputComponent(services: ServicesForResolution, stateRef: StateRef, params: NetworkParameters): SerializedBytes<TransactionState<ContractState>> MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$ fun buildFilteredTransaction(): ContractUpgradeFilteredTransaction MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$@CordaInternal internal - MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$PARAMETERS_HASH.ordinal to FilteredComponent(serializedComponents[PARAMETERS_HASH.ordinal], nonces[PARAMETERS_HASH.ordinal]) MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$classLoader.loadClass(className).asSubclass(UpgradedContract::class.java).newInstance() as UpgradedContract<ContractState, ContractState> MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$private MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$return AttachmentsClassLoaderBuilder.withAttachmentsClassloaderContext(listOf(legacyAttachment, upgradedAttachment), params, id) { transactionClassLoader -> val resolvedInput = binaryInput.deserialize() val upgradedContract = upgradedContract(upgradedContractClassName, transactionClassLoader) val outputState = calculateUpgradedState(resolvedInput, upgradedContract, upgradedAttachment) outputState.serialize() } MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$val binaryInput: SerializedBytes<TransactionState<ContractState>> = resolveStateRefBinaryComponent(inputs[stateRef.index], services)!! - MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$val legacyContractAttachmentId: SecureHash by lazy { serializedComponents[LEGACY_ATTACHMENT.ordinal].deserialize<SecureHash>() } - MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$val resolvedNetworkParameters = services.networkParametersService.lookup(hashToResolve) ?: throw TransactionResolutionException(id) - MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$val upgradedContractAttachmentId: SecureHash by lazy { serializedComponents[UPGRADED_ATTACHMENT.ordinal].deserialize<SecureHash>() } MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction$val upgradedContractClassName: ContractClassName by lazy { serializedComponents[UPGRADED_CONTRACT.ordinal].deserialize<ContractClassName>() } MaxLineLength:ContractUpgradeTransactions.kt$ContractUpgradeWireTransaction.Companion$@CordaInternal internal MaxLineLength:ContractsDSL.kt$inline - MaxLineLength:ContractsDSL.kt$mapNotNull { if (klass.isInstance(it.value)) uncheckedCast<CommandWithParties<CommandData>, CommandWithParties<C>>(it) else null } - MaxLineLength:ContractsDSLTests.kt$RequireSingleCommandTests MaxLineLength:ContractsDSLTests.kt$RequireSingleCommandTests.Companion$arrayOf<Any>({ commands: Collection<CommandWithParties<CommandData>> -> commands.requireSingleCommand(TestCommands::class.java) }, "Interop version") MaxLineLength:ContractsDSLTests.kt$RequireSingleCommandTests.Companion$arrayOf<Any>({ commands: Collection<CommandWithParties<CommandData>> -> commands.requireSingleCommand<TestCommands>() }, "Inline version") MaxLineLength:ContractsDSLTests.kt$SelectWithMultipleInputsTests @@ -5061,17 +3303,11 @@ MaxLineLength:ContractsDSLTests.kt$SelectWithSingleInputsTests.Companion$arrayOf<Any>({ commands: Collection<CommandWithParties<CommandData>>, signer: PublicKey?, party: AbstractParty? -> commands.select(TestCommands::class.java, signer, party) }, "Interop version") MaxLineLength:ContractsDSLTests.kt$SelectWithSingleInputsTests.Companion$arrayOf<Any>({ commands: Collection<CommandWithParties<CommandData>>, signer: PublicKey?, party: AbstractParty? -> commands.select<TestCommands>(signer, party) }, "Inline version") MaxLineLength:ContractsDSLTests.kt$val validCommandOne = CommandWithParties(listOf(megaCorp.publicKey, miniCorp.publicKey), listOf(megaCorp.party, miniCorp.party), TestCommands.CommandOne()) - MaxLineLength:ContractsScanning.kt$// When scanning of the CorDapp Jar is performed without "corda-core.jar" being in the classpath, there is no way to appreciate // relationships between those interfaces, therefore they have to be listed explicitly. val coreContractClasses = setOf(Contract::class, UpgradedContractWithLegacyConstraint::class, UpgradedContract::class) - MaxLineLength:Converters.kt$CordaConverterProvider$override - MaxLineLength:CopiedNode.kt$CopiedNode$return BuiltNode(this.configFile, this.baseDirectory, this.copiedNodeConfig, this.copiedNodeDir, nodeConfig, localImageId) - MaxLineLength:CorDappInfoServlet.kt$CorDappInfoServlet$private MaxLineLength:CordaAuthenticationPlugin.kt$CordaAuthenticationPlugin : CRaSHPluginAuthenticationPlugin MaxLineLength:CordaClassResolver.kt$CordaClassResolver$// We don't allow the annotation for classes in attachments for now. The class will be on the main classpath if we have the CorDapp installed. // We also do not allow extension of KryoSerializable for annotated classes, or combination with @DefaultSerializer for custom serialisation. // TODO: Later we can support annotations on attachment classes and spin up a proxy via bytecode that we know is harmless. private fun checkForAnnotation(type: Class<*>): Boolean MaxLineLength:CordaClassResolver.kt$CordaClassResolver$if (type.isPrimitive || type == Any::class.java || type == String::class.java || (!type.isEnum && isAbstract(type.modifiers))) return null MaxLineLength:CordaClassResolver.kt$CordaClassResolver$kotlin.jvm.internal.Lambda::class.java.isAssignableFrom(targetType) - MaxLineLength:CordaClassResolver.kt$CordaClassResolver$throw KryoException("Class ${Util.className(type)} is not annotated or on the whitelist, so cannot be used in serialization") MaxLineLength:CordaClassResolver.kt$CordaClassResolver${ // If call path has disabled whitelisting (see [CordaKryo.register]), just return without checking. if (!whitelistEnabled) return null // If array, recurse on element type if (type.isArray) return checkClass(type.componentType) // Specialised enum entry, so just resolve the parent Enum type since cannot annotate the specialised entry. if (!type.isEnum && Enum::class.java.isAssignableFrom(type)) return checkClass(type.superclass) // Allow primitives, abstracts and interfaces. Note that we can also create abstract Enum types, // but we don't want to whitelist those here. if (type.isPrimitive || type == Any::class.java || type == String::class.java || (!type.isEnum && isAbstract(type.modifiers))) return null // It's safe to have the Class already, since Kryo loads it with initialisation off. // If we use a whitelist with blacklisting capabilities, whitelist.hasListed(type) may throw an IllegalStateException if input class is blacklisted. // Thus, blacklisting precedes annotation checking. if (!whitelist.hasListed(type) && !checkForAnnotation(type)) { throw KryoException("Class ${Util.className(type)} is not annotated or on the whitelist, so cannot be used in serialization") } return null } - MaxLineLength:CordaClassResolver.kt$CordaClassResolver${ val targetType = typeForSerializationOf(type) val objectInstance = targetType.kotlinObjectInstance // We have to set reference to true, since the flag influences how String fields are treated and we want it to be consistent. val references = kryo.references try { kryo.references = true val serializer = when { objectInstance != null -> KotlinObjectSerializer(objectInstance) kotlin.jvm.internal.Lambda::class.java.isAssignableFrom(targetType) -> // Kotlin lambdas extend this class and any captured variables are stored in synthetic fields FieldSerializer<Any>(kryo, targetType).apply { setIgnoreSyntheticFields(false) } Throwable::class.java.isAssignableFrom(targetType) -> ThrowableSerializer(kryo, targetType) else -> kryo.getDefaultSerializer(targetType) } return register(Registration(targetType, serializer, NAME.toInt())) } finally { kryo.references = references } } MaxLineLength:CordaClassResolverTests.kt$CordaClassResolverTests$expectedEx.expectMessage("The superclass java.util.HashSet of net.corda.serialization.internal.CordaClassResolverTests\$CordaSerializableHashSet is blacklisted, so it cannot be used in serialization.") MaxLineLength:CordaClassResolverTests.kt$CordaClassResolverTests$expectedEx.expectMessage("The superclass java.util.HashSet of net.corda.serialization.internal.CordaClassResolverTests\$SubHashSet is blacklisted, so it cannot be used in serialization.") MaxLineLength:CordaClassResolverTests.kt$CordaClassResolverTests$expectedEx.expectMessage("The superclass java.util.HashSet of net.corda.serialization.internal.CordaClassResolverTests\$SubSubHashSet is blacklisted, so it cannot be used in serialization.") @@ -5081,182 +3317,64 @@ MaxLineLength:CordaClassResolverTests.kt$CordaClassResolverTests$private val allButBlacklistedContext: CheckpointSerializationContext = CheckpointSerializationContextImpl(this.javaClass.classLoader, AllButBlacklisted, emptyMap(), true, null) MaxLineLength:CordaClassResolverTests.kt$CordaClassResolverTests$private val emptyWhitelistContext: CheckpointSerializationContext = CheckpointSerializationContextImpl(this.javaClass.classLoader, EmptyWhitelist, emptyMap(), true, null) MaxLineLength:CordaClassResolverTests.kt$CordaClassResolverTests$val classLoader = AttachmentsClassLoader(arrayOf(attachmentHash).map { storage.openAttachment(it)!! }, testNetworkParameters(), SecureHash.zeroHash) - MaxLineLength:CordaCliWrapper.kt$CliWrapperBase$// Override this function with the actual method to be run once all the arguments have been parsed. The return number // is the exit code to be returned abstract fun runProgram(): Int - MaxLineLength:CordaCliWrapper.kt$CliWrapperBase$// Raw args are provided for use in logging - this is a lateinit var rather than a constructor parameter as the class // needs to be parameterless for autocomplete to work. lateinit var args: Array<String> - MaxLineLength:CordaCliWrapper.kt$CliWrapperBase$// This needs to be called before loggers (See: NodeStartup.kt:51 logger called by lazy, initLogging happens before). // Node's logging is more rich. In corda configurations two properties, defaultLoggingLevel and consoleLogLevel, are usually used. open fun initLogging(): Boolean - MaxLineLength:CordaCliWrapper.kt$CliWrapperBase$@Option(names = ["-v", "--verbose", "--log-to-console"], description = ["If set, prints logging to the console as well as to a file."]) - MaxLineLength:CordaCliWrapper.kt$CliWrapperBase$System.setProperty("defaultLogLevel", specifiedLogLevel) - MaxLineLength:CordaCliWrapper.kt$CordaCliWrapper : CliWrapperBase - MaxLineLength:CordaCliWrapper.kt$DefaultExceptionHandler<List<Any>>().useErr(System.err).useAnsi(defaultAnsiMode).andExit(ExitCodes.FAILURE) - MaxLineLength:CordaCliWrapper.kt$Validated - MaxLineLength:CordaCliWrapper.kt${ val defaultAnsiMode = if (CordaSystemUtils.isOsWindows()) { Help.Ansi.ON } else { Help.Ansi.AUTO } val results = cmd.parseWithHandlers(RunLast().useOut(System.out).useAnsi(defaultAnsiMode), DefaultExceptionHandler<List<Any>>().useErr(System.err).useAnsi(defaultAnsiMode).andExit(ExitCodes.FAILURE), *args) // If an error code has been returned, use this and exit results?.firstOrNull()?.let { if (it is Int) { exitProcess(it) } else { exitProcess(ExitCodes.FAILURE) } } // If no results returned, picocli ran something without invoking the main program, e.g. --help or --version, so exit successfully exitProcess(ExitCodes.SUCCESS) } - MaxLineLength:CordaClock.kt$CordaClock$@Deprecated("Do not use this. Instead seek to use ZonedDateTime methods.", level = DeprecationLevel.ERROR) override - MaxLineLength:CordaClock.kt$MutableClock$ protected fun notifyMutationObservers() MaxLineLength:CordaClosureSerializer.kt$CordaClosureSerializer$const val ERROR_MESSAGE = "Unable to serialize Java Lambda expression, unless explicitly declared e.g., Runnable r = (Runnable & Serializable) () -> System.out.println(\"Hello world!\");" - MaxLineLength:CordaException.kt$CordaException$if (originalMessage == null) "$originalExceptionClassName" else "$originalExceptionClassName: $originalMessage" - MaxLineLength:CordaException.kt$CordaException$private var _cause: Throwable? = null - MaxLineLength:CordaException.kt$CordaRuntimeException$if (originalMessage == null) "$originalExceptionClassName" else "$originalExceptionClassName: $originalMessage" - MaxLineLength:CordaException.kt$CordaRuntimeException$private var _cause: Throwable? - MaxLineLength:CordaExceptionTest.kt$CordaExceptionTest$val ex = assertFailsWith<ConflictingAttachmentsRejection> { throw ConflictingAttachmentsRejection(TX_ID, CONTRACT_CLASS) } - MaxLineLength:CordaExceptionTest.kt$CordaExceptionTest$val ex = assertFailsWith<NotaryChangeInWrongTransactionType> { throw NotaryChangeInWrongTransactionType(TX_ID, ALICE, BOB) } MaxLineLength:CordaFuture.kt$CordaFuture<V> : Future MaxLineLength:CordaFutureImpl.kt$ fun <ELEMENT> CordaFuture<out ELEMENT>.mapError(transform: (Throwable) -> Throwable): CordaFuture<ELEMENT> MaxLineLength:CordaFutureImpl.kt$ fun <RESULT> CordaFuture<out RESULT>.doOnError(accept: (Throwable) -> Unit): CordaFuture<RESULT> - MaxLineLength:CordaFutureImpl.kt$ fun <V, W, X> CordaFuture<out V>.thenMatch(success: (V) -> W, failure: (Throwable) -> X) - MaxLineLength:CordaFutureImpl.kt$ fun <V, W> CordaFuture<out V>.flatMap(transform: (V) -> CordaFuture<out W>): CordaFuture<W> - MaxLineLength:CordaFutureImpl.kt$CordaFutureImpl$@VisibleForTesting internal - MaxLineLength:CordaFutureImpl.kt$internal fun <V> Future<V>.get(timeout: Duration? = null): V - MaxLineLength:CordaInternal.kt$CordaInternal - MaxLineLength:CordaMigration.kt$CordaMigration : CustomTaskChange MaxLineLength:CordaMigration.kt$CordaMigration$_servicesForResolution = MigrationServicesForResolution(identityService, attachmentsService, dbTransactions, cordaDB, cacheFactory) - MaxLineLength:CordaMigration.kt$CordaMigration$return CordaPersistence(configDefaults, schema, jdbcUrl, cacheFactory, attributeConverters, closeConnection = false) - MaxLineLength:CordaMigration.kt$CordaMigration${ val configDefaults = DatabaseConfig() val attributeConverters = listOf( PublicKeyToTextConverter(), AbstractPartyToX500NameAsStringConverter( identityService::wellKnownPartyFromX500Name, identityService::wellKnownPartyFromAnonymous) ) // Liquibase handles closing the database connection when migrations are finished. If the connection is closed here, then further // migrations may fail. return CordaPersistence(configDefaults, schema, jdbcUrl, cacheFactory, attributeConverters, closeConnection = false) } MaxLineLength:CordaModule.kt$AmountBeanDeserializerModifier$override - MaxLineLength:CordaModule.kt$CordaSerializableBeanSerializerModifier$// We need to pass in a SerializerFactory when scanning for properties, but don't actually do any serialisation so any will do. private val serializerFactory = SerializerFactoryBuilder.build(AllWhitelist, javaClass.classLoader) - MaxLineLength:CordaModule.kt$NetworkHostAndPortDeserializer : SimpleDeserializer - MaxLineLength:CordaModule.kt$SignatureSchemeDeserializer$signatureSchemesByNumberID[parser.intValue] ?: throw JsonParseException(parser, "Unable to find SignatureScheme ${parser.text}") - MaxLineLength:CordaModule.kt$SignedTransactionDeserializer$val core = wrapper.run { wire ?: filtered ?: notaryChangeWire ?: contractUpgradeWire ?: contractUpgradeFiltered!! } MaxLineLength:CordaModule.kt$StxJson$val count = Booleans.countTrue(wire != null, filtered != null, notaryChangeWire != null, contractUpgradeWire != null, contractUpgradeFiltered != null) - MaxLineLength:CordaPersistence.kt$// Add the subscriber to the wrapping subscriber, which will invoke the original subscribers together inside a database transaction. wrappingSubscriber.delegates.add(toBeWrappedInDbTx) // If we are the first subscriber, return the shared subscriber, otherwise return a subscriber that does nothing. if (wrappingSubscriber.delegates.size == 1) wrappingSubscriber else NoOpSubscriber(toBeWrappedInDbTx) // Clean up the shared list of subscribers when they unsubscribe. - MaxLineLength:CordaPersistence.kt$CordaPersistence$ fun <T> transaction(isolationLevel: TransactionIsolationLevel, recoverableFailureTolerance: Int, recoverAnyNestedSQLException: Boolean, statement: DatabaseTransaction.() -> T): T - MaxLineLength:CordaPersistence.kt$CordaPersistence$ fun <T> transaction(recoverableFailureTolerance: Int, statement: DatabaseTransaction.() -> T): T - MaxLineLength:CordaPersistence.kt$CordaPersistence$HibernateConfiguration(schemas, databaseConfig, attributeConverters, jdbcUrl, cacheFactory, customClassLoader) MaxLineLength:CordaPersistence.kt$CordaPersistence$error("Was not expecting to find existing database transaction on current strand when setting database: ${Strand.currentStrand()}, $it") MaxLineLength:CordaPersistence.kt$CordaPersistence$is SchemaManagementException -> throw HibernateSchemaChangeException("Incompatible schema change detected. Please run the node with database.initialiseSchema=true. Reason: ${e.message}", e) - MaxLineLength:CordaPersistence.kt$CordaPersistence$recoverAnyNestedSQLException: Boolean MaxLineLength:CordaPersistence.kt$CordaPersistence$val connectionBag: ConcurrentBag<ConcurrentBag.IConcurrentBagEntry> = connectionBagField.get(pool) as ConcurrentBag<ConcurrentBag.IConcurrentBagEntry> MaxLineLength:CordaPersistence.kt$CordaPersistence$val transaction = contextDatabase.currentOrNew(isolationLevel) // XXX: Does this code really support statement changing the contextDatabase? - MaxLineLength:CordaPersistence.kt$CordaPersistence${ // DataSource doesn't implement AutoCloseable so we just have to hope that the implementation does so that we can close it (_dataSource as? AutoCloseable)?.close() } - MaxLineLength:CordaPersistence.kt$CordaPersistence${ // We need to set the database for the current [Thread] or [Fiber] here as some tests share threads across databases. _contextDatabase.set(this) currentDBSession().flush() return contextTransaction.connection } - MaxLineLength:CordaPersistence.kt$CordaPersistence${ // We need to set the database for the current [Thread] or [Fiber] here as some tests share threads across databases. _contextDatabase.set(this) return currentOrNew(isolationLevel) } - MaxLineLength:CordaPersistence.kt$CouldNotCreateDataSourceException : Exception - MaxLineLength:CordaPersistence.kt$currentTx.boundary.filter { !it.success }.subscribe { this.onError(DatabaseTransactionRolledBackException(it.txId)) } - MaxLineLength:CordaPersistence.kt$return _contextDatabase.get() ?: error("Was expecting to find CordaPersistence set on current thread: ${Strand.currentStrand()}") - MaxLineLength:CordaPersistence.kt${ var wrappingSubscriber = DatabaseTransactionWrappingSubscriber<T>(db) // Use lift to add subscribers to a special subscriber that wraps a database transaction around observations. // Each subscriber will be passed to this lambda when they subscribe, at which point we add them to wrapping subscriber. return this.lift { toBeWrappedInDbTx: Subscriber<in T> -> // Add the subscriber to the wrapping subscriber, which will invoke the original subscribers together inside a database transaction. wrappingSubscriber.delegates.add(toBeWrappedInDbTx) // If we are the first subscriber, return the shared subscriber, otherwise return a subscriber that does nothing. if (wrappingSubscriber.delegates.size == 1) wrappingSubscriber else NoOpSubscriber(toBeWrappedInDbTx) // Clean up the shared list of subscribers when they unsubscribe. }.doOnUnsubscribe { wrappingSubscriber.cleanUp() // If cleanup removed the last subscriber reset the system, as future subscribers might need the stream again if (wrappingSubscriber.delegates.isEmpty()) { wrappingSubscriber = DatabaseTransactionWrappingSubscriber(db) } } } MaxLineLength:CordaRPCClient.kt$CordaRPCClient - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$ fun start(username: String, password: String): CordaRPCConnection - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$ fun start(username: String, password: String, externalTrace: Trace?, impersonatedActor: Actor?): CordaRPCConnection MaxLineLength:CordaRPCClient.kt$CordaRPCClient$ fun start(username: String, password: String, externalTrace: Trace?, impersonatedActor: Actor?, targetLegalIdentity: CordaX500Name?): CordaRPCConnection - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$ fun start(username: String, password: String, targetLegalIdentity: CordaX500Name): CordaRPCConnection MaxLineLength:CordaRPCClient.kt$CordaRPCClient$( haAddressPool: List<NetworkHostAndPort>, configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT, sslConfiguration: ClientRpcSslOptions? = null, classLoader: ClassLoader? = null ) MaxLineLength:CordaRPCClient.kt$CordaRPCClient$( hostAndPort: NetworkHostAndPort, configuration: CordaRPCClientConfiguration, sslConfiguration: ClientRpcSslOptions?, classLoader: ClassLoader? = null ) - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$( hostAndPort: NetworkHostAndPort, sslConfiguration: ClientRpcSslOptions? = null, classLoader: ClassLoader? = null ) - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$@JvmOverloads constructor(hostAndPort: NetworkHostAndPort, configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT) : this( hostAndPort = hostAndPort, haAddressPool = emptyList(), configuration = configuration ) - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$AMQPClientSerializationScheme.initialiseSerialization(classLoader, customSerializers, serializationWhitelists, cache) - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$AMQPClientSerializationScheme.initialiseSerialization(classLoader, serializerFactoriesForContexts = cache) - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$if (classLoader != null) AMQP_RPC_CLIENT_CONTEXT.withClassLoader(classLoader) else AMQP_RPC_CLIENT_CONTEXT MaxLineLength:CordaRPCClient.kt$CordaRPCClient$return CordaRPCConnection(getRpcClient().start(CordaRPCOps::class.java, username, password, externalTrace, impersonatedActor, targetLegalIdentity)) - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$val cache = Caffeine.newBuilder().maximumSize(128).build<SerializationFactoryCacheKey, SerializerFactory>().asMap() - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$val customSerializers = createInstancesOfClassesImplementing(classLoader, SerializationCustomSerializer::class.java) - MaxLineLength:CordaRPCClient.kt$CordaRPCClient$val serializationWhitelists = ServiceLoader.load(SerializationWhitelist::class.java, classLoader).toSet() MaxLineLength:CordaRPCClient.kt$CordaRPCClient${ val cache = Caffeine.newBuilder().maximumSize(128).build<SerializationFactoryCacheKey, SerializerFactory>().asMap() // If the client has provided a classloader, the associated classpath is checked for available custom serializers and serialization whitelists. if (classLoader != null) { val customSerializers = createInstancesOfClassesImplementing(classLoader, SerializationCustomSerializer::class.java) val serializationWhitelists = ServiceLoader.load(SerializationWhitelist::class.java, classLoader).toSet() AMQPClientSerializationScheme.initialiseSerialization(classLoader, customSerializers, serializationWhitelists, cache) } else { AMQPClientSerializationScheme.initialiseSerialization(classLoader, serializerFactoriesForContexts = cache) } } - MaxLineLength:CordaRPCClient.kt$CordaRPCClientConfiguration$/** * The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak references * and are cleaned up in batches in this interval. If set too large it will waste server side resources for this * duration. If set too low it wastes client side cycles. The default is to check once per second. */ open val reapInterval: Duration = 1.seconds - MaxLineLength:CordaRPCClient.kt$CordaRPCConnection : RPCConnection - MaxLineLength:CordaRPCClientTest.kt$CordaRPCClientTest$// WireTransaction stores its components as blobs which are deserialised in its constructor. This test makes sure // the extra class loader given to the CordaRPCClient is used in this deserialisation, as otherwise any WireTransaction // containing Cash.State objects are not receivable by the client. // // We run the client in a separate process, without the finance module on its system classpath to ensure that the // additional class loader that we give it is used. Cash.State objects are used as they can't be synthesised fully // by the carpenter, and thus avoiding any false-positive results. @Test fun `additional class loader used by WireTransaction when it deserialises its components`() - MaxLineLength:CordaRPCClientTest.kt$CordaRPCClientTest$checkRpcNotification(update.stateMachineInfo, rpcUser.username, historicalIds, externalTrace, impersonatedActor) MaxLineLength:CordaRPCClientTest.kt$CordaRPCClientTest$node.services.startFlow(CashIssueFlow(100.POUNDS, OpaqueBytes.of(1), identity), InvocationContext.shell()).flatMap { it.resultFuture }.getOrThrow() MaxLineLength:CordaRPCClientTest.kt$CordaRPCClientTest$node.services.startFlow(CashIssueFlow(2000.DOLLARS, OpaqueBytes.of(0), identity), InvocationContext.shell()).flatMap { it.resultFuture }.getOrThrow() - MaxLineLength:CordaRPCClientTest.kt$CordaRPCClientTest$private - MaxLineLength:CordaRPCClientTest.kt$CordaRPCClientTest$proxy.startFlowDynamic(CashIssueFlow::class.java, 1000.DOLLARS, OpaqueBytes.of(0), identity).returnValue.getOrThrow() - MaxLineLength:CordaRPCClientTest.kt$CordaRPCClientTest.CloseableExecutor$private MaxLineLength:CordaRPCOps.kt$ @Deprecated("For automated upgrades, consider using the `gracefulShutdown` command in an SSH session instead.") fun CordaRPCOps.pendingFlowsCount(): DataFeed<Int, Pair<Int, Int>> - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ // DOCSTART VaultQueryByAPI @RPCReturnsObservables fun <T : ContractState> vaultQueryBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): Vault.Page<T> - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ // DOCSTART VaultTrackByAPI @RPCReturnsObservables fun <T : ContractState> vaultTrackBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ // TODO This operation should be restricted to just node admins. @RPCReturnsObservables fun networkParametersFeed(): DataFeed<ParametersUpdateInfo?, ParametersUpdateInfo> MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ // TODO This operation should be restricted to just node admins. fun acceptNewNetworkParameters(parametersHash: SecureHash) MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ @CordaInternal @Deprecated("This method is intended only for internal use and will be removed from the public API soon.") fun internalFindVerifiedTransaction(txnId: SecureHash): SignedTransaction? MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ @Deprecated("This method is intended only for internal use and will be removed from the public API soon.") @RPCReturnsObservables fun internalVerifiedTransactionsFeed(): DataFeed<List<SignedTransaction>, SignedTransaction> MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ @Deprecated("This method is intended only for internal use and will be removed from the public API soon.") fun internalVerifiedTransactionsSnapshot(): List<SignedTransaction> - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ @RPCReturnsObservables fun stateMachineRecordedTransactionMappingFeed(): DataFeed<List<StateMachineTransactionMapping>, StateMachineTransactionMapping> - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ fun clearNetworkMapCache() - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ fun killFlow(id: StateMachineRunId): Boolean - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ fun nodeInfoFromParty(party: AbstractParty): NodeInfo? - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ fun notaryIdentities(): List<Party> - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ fun refreshNetworkMapCache() - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ fun setFlowsDrainingModeEnabled(enabled: Boolean) MaxLineLength:CordaRPCOps.kt$CordaRPCOps$ fun terminate(drainPendingFlows: Boolean = false) - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$fun <T : ContractState> vaultQueryByCriteria(criteria: QueryCriteria, contractStateType: Class<out T>): Vault.Page<T> MaxLineLength:CordaRPCOps.kt$CordaRPCOps$fun <T : ContractState> vaultQueryByWithPagingSpec(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification): Vault.Page<T> - MaxLineLength:CordaRPCOps.kt$CordaRPCOps$fun <T : ContractState> vaultQueryByWithSorting(contractStateType: Class<out T>, criteria: QueryCriteria, sorting: Sort): Vault.Page<T> MaxLineLength:CordaRPCOps.kt$CordaRPCOps$fun <T : ContractState> vaultTrackByCriteria(contractStateType: Class<out T>, criteria: QueryCriteria): DataFeed<Vault.Page<T>, Vault.Update<T>> MaxLineLength:CordaRPCOps.kt$CordaRPCOps$fun <T : ContractState> vaultTrackByWithPagingSpec(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification): DataFeed<Vault.Page<T>, Vault.Update<T>> MaxLineLength:CordaRPCOps.kt$CordaRPCOps$fun <T : ContractState> vaultTrackByWithSorting(contractStateType: Class<out T>, criteria: QueryCriteria, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> - MaxLineLength:CordaRPCOps.kt$ParametersUpdateInfo - MaxLineLength:CordaRPCOps.kt$StateMachineInfo$progressTrackerStepAndUpdates: DataFeed<String, String>? = this.progressTrackerStepAndUpdates MaxLineLength:CordaRPCOps.kt$StateMachineInfo$return copy(id = id, flowLogicClassName = flowLogicClassName, initiator = initiator, progressTrackerStepAndUpdates = progressTrackerStepAndUpdates, invocationContext = invocationContext) - MaxLineLength:CordaRPCOps.kt$inline MaxLineLength:CordaRPCOps.kt$sorting: Sort = Sort(emptySet()) - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$/** * Returns the RPC protocol version, which is the same the node's platform Version. Exists since version 1 so guaranteed * to be present. */ override val protocolVersion: Int get() = nodeInfo().platformVersion - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$?: - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$contractStateType: Class<out T> - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$hash.serialize().sign { services.keyManagementService.sign(it.bytes, services.myInfo.legalIdentities[0].owningKey) } MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$is ConnectException -> throw CordaRuntimeException("There is connection problem to network map. The possible causes are incorrect configuration or network map service being down") - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$is InvocationOrigin.Scheduled -> FlowInitiator.Scheduled((origin as InvocationOrigin.Scheduled).scheduledState) MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$logger.error("Error while waiting for pending flows to drain in preparation for shutdown. Cause was: ${error.message}", error) MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$override MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$override fun internalFindVerifiedTransaction(txnId: SecureHash): SignedTransaction? - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$override fun killFlow(id: StateMachineRunId): Boolean - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$override fun registeredFlows(): List<String> - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$override fun setFlowsDrainingModeEnabled(enabled: Boolean) MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$private fun setPersistentDrainingModeProperty(enabled: Boolean, propagateChange: Boolean) - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$progress = stateMachine.logic.track()?.updates?.filter { !it.startsWith(STRUCTURAL_STEP_PREFIX) } ?: Observable.empty() MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$return StateMachineInfo(flowLogic.runId, flowLogic.javaClass.name, flowLogic.stateMachine.context.toFlowInitiator(), flowLogic.track(), flowLogic.stateMachine.context) - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$return vaultQueryBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), contractStateType) - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$return vaultTrackBy(QueryCriteria.VaultQueryCriteria(), PageSpecification(), Sort(emptySet()), contractStateType) - MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl$val wellKnownParty = services.identityService.wellKnownPartyFromX500Name((origin as InvocationOrigin.Peer).party) MaxLineLength:CordaRPCOpsImpl.kt$CordaRPCOpsImpl${(completed, total) -> logger.info("Pending flows progress before shutdown: $completed / $total.") } - MaxLineLength:CordaRPCOpsImplTest.kt$CordaRPCOpsImplTest$CURRENT_RPC_CONTEXT.set(RpcAuthContext(InvocationContext.rpc(testActor()), buildSubject("TEST_USER", emptySet()))) MaxLineLength:CordaRPCOpsImplTest.kt$CordaRPCOpsImplTest$assertThatCode { rpc.startFlow(::SoftLock, cash.ref, Duration.ofSeconds(1)).returnValue.getOrThrow() }.doesNotThrowAnyException() - MaxLineLength:CordaRPCOpsImplTest.kt$CordaRPCOpsImplTest$require(aliceNode.services.keyManagementService.filterMyKeys(signaturePubKeys).toList().isNotEmpty()) MaxLineLength:CordaRPCOpsImplTest.kt$CordaRPCOpsImplTest$val cash = rpc.startFlow(::CashIssueFlow, 10.DOLLARS, issuerRef, notary).returnValue.getOrThrow().stx.tx.outRefsOfType<Cash.State>().single() - MaxLineLength:CordaRPCOpsImplTest.kt$CordaRPCOpsImplTest$withPermissions MaxLineLength:CordaSSHAuthInfo.kt$CordaSSHAuthInfo : AuthInfo - MaxLineLength:CordaService.kt$CordaService - MaxLineLength:CordaServiceTest.kt$CordaServiceTest$CordaServiceThatRequiresThreadContextClassLoader : SingletonSerializeAsToken MaxLineLength:CordaServiceTest.kt$CordaServiceTest$mockNet = MockNetwork(MockNetworkParameters(threadPerNode = true, cordappsForAllNodes = listOf(FINANCE_CONTRACTS_CORDAPP, enclosedCordapp()))) MaxLineLength:CordaServiceTest.kt$CordaServiceTest.CordaServiceThatRequiresThreadContextClassLoader$assertNotNull(Thread.currentThread().contextClassLoader, "thread context classloader should not be null during service initialisation") - MaxLineLength:CordaUtils.kt$ @DeleteForDJVM fun TransactionBuilder.toLedgerTransaction(services: ServicesForResolution, serializationContext: SerializationContext): LedgerTransaction - MaxLineLength:CordaUtils.kt$ @DeleteForDJVM fun TransactionBuilder.toWireTransaction(services: ServicesForResolution, serializationContext: SerializationContext): WireTransaction MaxLineLength:CordaUtils.kt$ private fun owns(packageName: String, fullClassName: String): Boolean - MaxLineLength:CordaUtils.kt$"$requiredMinPlatformVersion. The current zone is only enforcing a minimum platform version of " MaxLineLength:CordaUtils.kt$AttachmentSort(listOf(AttachmentSort.AttachmentSortColumn(AttachmentSort.AttachmentSortAttribute.VERSION, Sort.Direction.DESC))) - MaxLineLength:CordaUtils.kt$Character.isJavaIdentifierStart(token[0]) && token.toCharArray().drop(1).all { Character.isJavaIdentifierPart(it) } - MaxLineLength:CordaUtils.kt$private - MaxLineLength:CordaVersion.kt$CordaVersion$arrayOf("Version: $releaseVersion", "Revision: $revision", "Platform Version: $platformVersion", "Vendor: $vendor") - MaxLineLength:CordaVersion.kt$CordaVersion.Companion$internal val semanticVersion: String by lazy { if(releaseVersion == UNKNOWN) current_major_release else releaseVersion } - MaxLineLength:CordaVersionProvider.kt$CordaVersionProvider : IVersionProvider MaxLineLength:CordaViewModel.kt$CordaView : View - MaxLineLength:CordaX500Name.kt$CordaX500Name$/** * @param organisation name of the organisation. * @param locality locality of the organisation, typically nearest major city. * @param country country the organisation is in, as an ISO 3166-1 2-letter country code. */ constructor(organisation: String, locality: String, country: String) : this(null, null, organisation, locality, null, country) - MaxLineLength:CordaX500Name.kt$CordaX500Name$require(locality.length < MAX_LENGTH_LOCALITY) { "Locality attribute (L) must contain less then $MAX_LENGTH_LOCALITY characters." } - MaxLineLength:CordaX500Name.kt$CordaX500Name$state?.let { require(it.length < MAX_LENGTH_STATE) { "State attribute (ST) must contain less then $MAX_LENGTH_STATE characters." } } MaxLineLength:CordaX500Name.kt$CordaX500Name$this(commonName = commonName, organisationUnit = null, organisation = organisation, locality = locality, state = null, country = country) - MaxLineLength:Cordapp.kt$Cordapp - MaxLineLength:Cordapp.kt$Cordapp$Info - MaxLineLength:Cordapp.kt$Cordapp.Info$ContractAndWorkflow : Info MaxLineLength:Cordapp.kt$Cordapp.Info$Workflow : Info MaxLineLength:Cordapp.kt$Cordapp.Info.Contract$data - MaxLineLength:Cordapp.kt$Cordapp.Info.Contract$override fun toString() MaxLineLength:Cordapp.kt$Cordapp.Info.Default$data MaxLineLength:Cordapp.kt$Cordapp.Info.Workflow$data - MaxLineLength:Cordapp.kt$Cordapp.Info.Workflow$override fun toString() - MaxLineLength:CordappConfigFileProviderTests.kt$CordappConfigFileProviderTests$private - MaxLineLength:CordappConfiguration.kt$CordappConfiguration : ConfigurationTemplate - MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$assertThat(aliceQuery.statesMetadata[0].constraintInfo!!.type()).isEqualTo(Vault.ConstraintInfo.Type.SIGNATURE) MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$assertThat(allStates[0].state.constraint).isInstanceOfAny(HashAttachmentConstraint::class.java, SignatureAttachmentConstraint::class.java) - MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$assertThat(bobQuery.statesMetadata[0].constraintInfo!!.type()).isEqualTo(Vault.ConstraintInfo.Type.SIGNATURE) - MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$val aliceQuery = alice.rpc.vaultQueryBy<Cash.State>(QueryCriteria.VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)) MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$val aliceQuery = restartedAlice.rpc.vaultQueryBy<Cash.State>(QueryCriteria.VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)) MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$val issueTx = alice.rpc.startFlow(::CashIssueFlow, 1000.DOLLARS, OpaqueBytes.of(1), defaultNotaryIdentity).returnValue.getOrThrow() - MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$val issueTx = alice.rpc.startFlow(::CashIssueFlow, expected, ref, defaultNotaryIdentity).returnValue.getOrThrow() - MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$val issueTx2 = restartedNode.rpc.startFlow(::CashIssueFlow, expected, ref, defaultNotaryIdentity).returnValue.getOrThrow() - MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$val parameters = NetworkParametersReader(DEV_ROOT_CA.certificate, null, notary.baseDirectory).read().networkParameters MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$val transferTx = alice.rpc.startFlow(::CashPaymentFlow, 1000.DOLLARS, bobParty, true, defaultNotaryIdentity).returnValue.getOrThrow() MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$val transferTxn = restartedAlice.rpc.startFlow(::CashPaymentFlow, 1000.DOLLARS, bobParty, true, defaultNotaryIdentity).returnValue.getOrThrow() MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$val vaultUpdatesBob = bob.rpc.vaultTrackByCriteria(Cash.State::class.java, QueryCriteria.VaultQueryCriteria(status = Vault.StateStatus.ALL)).updates MaxLineLength:CordappConstraintsTests.kt$CordappConstraintsTests$val vaultUpdatesBob = restartedBob.rpc.vaultTrackByCriteria(Cash.State::class.java, QueryCriteria.VaultQueryCriteria(status = Vault.StateStatus.ALL)).updates - MaxLineLength:CordappContext.kt$CordappContext - MaxLineLength:CordappContext.kt$CordappContext.Companion$@CordaInternal fun create(cordapp: Cordapp, attachmentId: SecureHash?, classLoader: ClassLoader, config: CordappConfig): CordappContext - MaxLineLength:CordappContext.kt$CordappContext.EmptyCordappConfig$override fun get(path: String) MaxLineLength:CordappContext.kt$CordappContext.EmptyCordappConfig$override fun getBoolean(path: String) MaxLineLength:CordappContext.kt$CordappContext.EmptyCordappConfig$override fun getDouble(path: String) MaxLineLength:CordappContext.kt$CordappContext.EmptyCordappConfig$override fun getFloat(path: String) @@ -5264,690 +3382,218 @@ MaxLineLength:CordappContext.kt$CordappContext.EmptyCordappConfig$override fun getLong(path: String) MaxLineLength:CordappContext.kt$CordappContext.EmptyCordappConfig$override fun getNumber(path: String) MaxLineLength:CordappContext.kt$CordappContext.EmptyCordappConfig$override fun getString(path: String) - MaxLineLength:CordappProvider.kt$CordappProvider$ fun getAppContext(): CordappContext - MaxLineLength:CordappProviderImpl.kt$CordappProviderImpl$private val attachmentStorage: AttachmentStorage - MaxLineLength:CordappResolver.kt$CordappResolver$ @Synchronized @VisibleForTesting fun <T> withCordapp(minimumPlatformVersion: Int = 1, targetPlatformVersion: Int = PLATFORM_VERSION, block: () -> T): T - MaxLineLength:CordappResolver.kt$CordappResolver$CordappImpl.TEST_INSTANCE.copy(minimumPlatformVersion = minimumPlatformVersion, targetPlatformVersion = targetPlatformVersion) - MaxLineLength:CordappResolver.kt$CordappResolver$Exception().stackTrace .mapNotNull { cordappClasses[it.className] } // in case there are multiple classes matched, we select the first one having a single CorDapp registered against it. .firstOrNull { it.size == 1 } MaxLineLength:CordappResolverTest.kt$CordappResolverTest$@Test fun `when the same cordapp is registered for the same class multiple times, the resolver deduplicates and returns it as the current one`() MaxLineLength:CordappSmokeTest.kt$CordappSmokeTest$(additionalNodeInfoDir / "nodeInfo-41408E093F95EAD51F6892C34DEB65AE1A3569A4B0E5744769A1B485AF8E04B5").write(signedNodeInfo.serialize().bytes) - MaxLineLength:CordappSmokeTest.kt$CordappSmokeTest$private MaxLineLength:CordappSmokeTest.kt$CordappSmokeTest$val nodeInfo = createNodeInfoWithSingleIdentity(CordaX500Name(organisation = "Bob Corp", locality = "Madrid", country = "ES"), dummyKeyPair, dummyKeyPair.public) - MaxLineLength:CordappSmokeTest.kt$CordappSmokeTest${ val baseDir = factory.baseDirectory(aliceConfig) val cordappsDir = (baseDir / CORDAPPS_DIR_NAME).createDirectories() // Find the jar file for the smoke tests of this module val selfCordapp = Paths.get("build", "libs").list { it.filter { "-smokeTests" in it.toString() }.toList().single() } selfCordapp.copyToDirectory(cordappsDir) // The `nodeReadyFuture` in the persistent network map cache will not complete unless there is at least one other // node in the network. We work around this limitation by putting another node info file in the additional-node-info // folder. // TODO clean this up after we refactor the persistent network map cache / network map updater val additionalNodeInfoDir = (baseDir / "additional-node-infos").createDirectories() createDummyNodeInfo(additionalNodeInfoDir) factory.create(aliceConfig).use { alice -> alice.connect(superUser).use { connectionToAlice -> val aliceIdentity = connectionToAlice.proxy.nodeInfo().legalIdentitiesAndCerts.first().party val future = connectionToAlice.proxy.startFlow(::GatherContextsFlow, aliceIdentity).returnValue val (sessionInitContext, sessionConfirmContext) = future.getOrThrow() val selfCordappName = selfCordapp.fileName.toString().removeSuffix(".jar") assertThat(sessionInitContext.appName).isEqualTo(selfCordappName) assertThat(sessionConfirmContext.appName).isEqualTo(selfCordappName) } } } MaxLineLength:CoreFlowHandlers.kt$ContractUpgradeHandler : Acceptor - MaxLineLength:CoreFlowHandlers.kt$ContractUpgradeHandler$"The instigator is one of the participants" using (initiatingSession.counterparty in oldStateAndRef.state.data.participants) MaxLineLength:CoreFlowHandlers.kt$ContractUpgradeHandler$"The proposed upgrade ${proposal.modification.javaClass} is a trusted upgrade path" using (proposal.modification.name == authorisedUpgrade) MaxLineLength:CoreFlowHandlers.kt$ContractUpgradeHandler$@Suspendable override - MaxLineLength:CoreFlowHandlers.kt$ContractUpgradeHandler$val authorisedUpgrade = checkNotNull(serviceHub.contractUpgradeService.getAuthorisedContractUpgrade(oldStateAndRef.ref)) { "Contract state upgrade is unauthorised. State hash : ${oldStateAndRef.ref}" } - MaxLineLength:CoreFlowHandlers.kt$ContractUpgradeHandler$val expectedTx = ContractUpgradeUtils.assembleUpgradeTx(oldStateAndRef, proposal.modification, proposedTx.privacySalt, serviceHub) - MaxLineLength:CoreFlowHandlers.kt$ContractUpgradeHandler${ // Retrieve signed transaction from our side, we will apply the upgrade logic to the transaction on our side, and // verify outputs matches the proposed upgrade. val ourSTX = requireNotNull(serviceHub.validatedTransactions.getTransaction(proposal.stateRef.txhash)) { "We don't have a copy of the referenced state" } val oldStateAndRef = ourSTX.resolveBaseTransaction(serviceHub).outRef<ContractState>(proposal.stateRef.index) val authorisedUpgrade = checkNotNull(serviceHub.contractUpgradeService.getAuthorisedContractUpgrade(oldStateAndRef.ref)) { "Contract state upgrade is unauthorised. State hash : ${oldStateAndRef.ref}" } val proposedTx = stx.coreTransaction as ContractUpgradeWireTransaction val expectedTx = ContractUpgradeUtils.assembleUpgradeTx(oldStateAndRef, proposal.modification, proposedTx.privacySalt, serviceHub) requireThat { "The instigator is one of the participants" using (initiatingSession.counterparty in oldStateAndRef.state.data.participants) "The proposed upgrade ${proposal.modification.javaClass} is a trusted upgrade path" using (proposal.modification.name == authorisedUpgrade) "The proposed tx matches the expected tx for this upgrade" using (proposedTx == expectedTx) } proposedTx.resolve(serviceHub, stx.sigs) } MaxLineLength:CoreFlowHandlers.kt$FinalityHandler$logger.warnOnce("Insecure API to record finalised transaction was used by ${sender.counterparty} (${sender.getCounterpartyFlowInfo()})") - MaxLineLength:CoreFlowHandlers.kt$NotaryChangeHandler : Acceptor - MaxLineLength:CoreFlowHandlers.kt$NotaryChangeHandler${ val state = proposal.stateRef val proposedTx = stx.resolveNotaryChangeTransaction(serviceHub) // TODO: Right now all nodes will automatically approve the notary change. We need to figure out if stricter controls are necessary. if (state !in proposedTx.inputs.map { it.ref }) { throw StateReplacementException("The proposed state $state is not in the proposed transaction inputs") } val newNotary = proposal.modification val isNotary = serviceHub.networkMapCache.isNotary(newNotary) if (!isNotary) { throw StateReplacementException("The proposed node $newNotary does not run a Notary service") } } - MaxLineLength:CrossCashTest.kt$"Divergence detected, the remote state doesn't match any of our possible predictions." - MaxLineLength:CrossCashTest.kt$fun searchForStateHelper(state: Map<A, Long>, diffIx: Int, consumedTxs: HashMap<A, Int>, matched: ArrayList<Map<A, Int>>) - MaxLineLength:CrossCashTest.kt$is IssueAndPaymentRequest -> command.node.proxy.startFlow(::CashIssueAndPaymentFlow, request).returnValue - MaxLineLength:CrossCashTest.kt$it.value.toDouble() / 1000 to generateMove(it.value, USD, node.mainIdentity, possibleRecipients) - MaxLineLength:CrossCashTest.kt$listOf(1.0 to generateIssue(10000, USD, notaryIdentity, possibleRecipients)) + moves + exits - MaxLineLength:CrossCashTest.kt$val minimumMatches = matches.fold<Map<AbstractParty, Int>, HashMap<AbstractParty, Int>?>(null) { minimum, next -> if (minimum == null) { HashMap(next) } else { next.forEach { minimum.merge(it.key, it.value, Math::min) } minimum } }!! MaxLineLength:CrossCashTest.kt${ log.warn( "Divergence detected, the remote state doesn't match any of our possible predictions." + "\nPredicted state/queues:\n$previousState" + "\nActual gathered state:\n${CrossCashState(currentNodeVaults, mapOf())}" ) // TODO We should terminate here with an exception, we cannot carry on as we have an inconsistent model. We carry on currently because we always diverge due to notarisation failures return@LoadTest CrossCashState(currentNodeVaults, mapOf()) } - MaxLineLength:Crypto.kt$Crypto$ @DeleteForDJVM @JvmOverloads @JvmStatic fun generateKeyPair(signatureScheme: SignatureScheme = DEFAULT_SIGNATURE_SCHEME): KeyPair - MaxLineLength:Crypto.kt$Crypto$ @DeleteForDJVM @JvmStatic @Throws(InvalidKeyException::class, SignatureException::class) fun doSign(privateKey: PrivateKey, clearData: ByteArray): ByteArray MaxLineLength:Crypto.kt$Crypto$ @DeleteForDJVM @JvmStatic fun generateKeyPair(schemeCodeName: String): KeyPair MaxLineLength:Crypto.kt$Crypto$ @JvmStatic @Throws(InvalidKeyException::class, SignatureException::class) fun doVerify(publicKey: PublicKey, signatureData: ByteArray, clearData: ByteArray): Boolean - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic @Throws(InvalidKeyException::class, SignatureException::class) fun doVerify(schemeCodeName: String, publicKey: PublicKey, signatureData: ByteArray, clearData: ByteArray): Boolean - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic @Throws(InvalidKeyException::class, SignatureException::class) fun doVerify(signatureScheme: SignatureScheme, publicKey: PublicKey, signatureData: ByteArray, clearData: ByteArray): Boolean - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic @Throws(InvalidKeyException::class, SignatureException::class) fun doVerify(txId: SecureHash, transactionSignature: TransactionSignature): Boolean - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic @Throws(InvalidKeySpecException::class) fun decodePrivateKey(schemeCodeName: String, encodedKey: ByteArray): PrivateKey - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic @Throws(InvalidKeySpecException::class) fun decodePublicKey(schemeCodeName: String, encodedKey: ByteArray): PublicKey - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic @Throws(SignatureException::class) fun isValid(publicKey: PublicKey, signatureData: ByteArray, clearData: ByteArray): Boolean - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic @Throws(SignatureException::class) fun isValid(signatureScheme: SignatureScheme, publicKey: PublicKey, signatureData: ByteArray, clearData: ByteArray): Boolean - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic @Throws(SignatureException::class) fun isValid(txId: SecureHash, transactionSignature: TransactionSignature): Boolean - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic fun deriveKeyPair(privateKey: PrivateKey, seed: ByteArray): KeyPair - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic fun deriveKeyPair(signatureScheme: SignatureScheme, privateKey: PrivateKey, seed: ByteArray): KeyPair - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic fun deriveKeyPairFromEntropy(entropy: BigInteger): KeyPair - MaxLineLength:Crypto.kt$Crypto$ @JvmStatic fun deriveKeyPairFromEntropy(signatureScheme: SignatureScheme, entropy: BigInteger): KeyPair MaxLineLength:Crypto.kt$Crypto$ @JvmStatic fun findSignatureScheme(schemeCodeName: String): SignatureScheme MaxLineLength:Crypto.kt$Crypto$ @JvmStatic fun publicKeyOnCurve(signatureScheme: SignatureScheme, publicKey: PublicKey): Boolean - MaxLineLength:Crypto.kt$Crypto$"Metadata schemeCodeName: ${sigMetaData.schemeCodeName} is not aligned with the key type: ${sigKey.schemeCodeName}." - MaxLineLength:Crypto.kt$Crypto$// Check if a public key satisfies algorithm specs (for ECC: key should lie on the curve and not being point-at-infinity). private fun validatePublicKey(signatureScheme: SignatureScheme, key: PublicKey): Boolean - MaxLineLength:Crypto.kt$Crypto$AlgorithmIdentifier(BCObjectIdentifiers.sphincs256_with_SHA512, DLSequence(arrayOf(ASN1Integer(0), SHA512_256))) MaxLineLength:Crypto.kt$Crypto$ECDSA_SECP256R1_SHA256, ECDSA_SECP256K1_SHA256 -> deriveKeyPairECDSA(signatureScheme.algSpec as ECParameterSpec, privateKey, seed) - MaxLineLength:Crypto.kt$Crypto$else -> throw InvalidKeyException("Key type ${privateKey.algorithm} is not supported for deterministic key derivation") - MaxLineLength:Crypto.kt$Crypto$else -> throw UnsupportedOperationException("Although supported for signing, deterministic key derivation is " + "not currently implemented for ${signatureScheme.schemeCodeName}") - MaxLineLength:Crypto.kt$Crypto$is BCECPublicKey -> publicKey.parameters == signatureScheme.algSpec && !publicKey.q.isInfinity && publicKey.q.isValid MaxLineLength:Crypto.kt$Crypto$is BCRSAPrivateKey, is BCSphincs256PrivateKey -> true MaxLineLength:Crypto.kt$Crypto$is BCRSAPublicKey -> key.modulus.bitLength() >= 2048 - MaxLineLength:Crypto.kt$Crypto$is EdDSAPublicKey -> publicKey.params == signatureScheme.algSpec && !isEdDSAPointAtInfinity(publicKey) && publicKey.a.isOnCurve - MaxLineLength:Crypto.kt$Crypto$listOf(AlgorithmIdentifier(BCObjectIdentifiers.sphincs256, DLSequence(arrayOf(ASN1Integer(0), SHA512_256)))) - MaxLineLength:Crypto.kt$Crypto$private - MaxLineLength:Crypto.kt$Crypto$require(txId.sha256() in usedHashes) { "Transaction with id:$txId is not a leaf in the provided partial Merkle tree" } - MaxLineLength:Crypto.kt$Crypto$return publicKey.a.toP3() == (EDDSA_ED25519_SHA512.algSpec as EdDSANamedCurveSpec).curve.getZero(GroupElement.Representation.P3) - MaxLineLength:Crypto.kt$Crypto$throw InvalidKeySpecException("This private key cannot be decoded, please ensure it is PKCS8 encoded and that " + "it corresponds to the input scheme's code name.", ikse) - MaxLineLength:Crypto.kt$Crypto$throw throw InvalidKeySpecException("This public key cannot be decoded, please ensure it is X509 encoded and " + "that it corresponds to the input scheme's code name.", ikse) - MaxLineLength:Crypto.kt$Crypto$val bytes = entropy.toByteArray().copyOf(params.curve.field.getb() / 8) // Need to pad the entropy to the valid seed length. - MaxLineLength:Crypto.kt$Crypto$val keyPairGenerator = KeyPairGenerator.getInstance(signatureScheme.algorithmName, providerMap[signatureScheme.providerName]) MaxLineLength:Crypto.kt$Crypto$val signableData = SignableData(originalSignedHash(txId, transactionSignature.partialMerkleTree), transactionSignature.signatureMetadata) - MaxLineLength:Crypto.kt$Crypto$val signature = Instances.getSignatureInstance(signatureScheme.signatureName, providerMap[signatureScheme.providerName]) - MaxLineLength:Crypto.kt$Crypto${ // Compute HMAC(privateKey, seed). val macBytes = deriveHMAC(privateKey, seed) // Get the first EC curve fieldSized-bytes from macBytes. // According to recommendations from the deterministic ECDSA rfc, see https://tools.ietf.org/html/rfc6979 // performing a simple modular reduction would induce biases that would be detrimental to security. // Thus, the result is not reduced modulo q and similarly to BIP32, EC curve fieldSized-bytes are utilised. val fieldSizeMacBytes = macBytes.copyOf(parameterSpec.curve.fieldSize / 8) // Calculate value d for private key. val deterministicD = BigInteger(1, fieldSizeMacBytes) // Key generation checks follow the BC logic found in // https://github.com/bcgit/bc-java/blob/master/core/src/main/java/org/bouncycastle/crypto/generators/ECKeyPairGenerator.java // There is also an extra check to align with the BIP32 protocol, according to which // if deterministicD >= order_of_the_curve the resulted key is invalid and we should proceed with another seed. // TODO: We currently use SHA256(seed) when retrying, but BIP32 just skips a counter (i) that results to an invalid key. // Although our hashing approach seems reasonable, we should check if there are alternatives, // especially if we use counters as well. if (deterministicD < ECConstants.TWO || WNafUtil.getNafWeight(deterministicD) < parameterSpec.n.bitLength().ushr(2) || deterministicD >= parameterSpec.n) { // Instead of throwing an exception, we retry with SHA256(seed). return deriveKeyPairECDSA(parameterSpec, privateKey, seed.sha256().bytes) } val privateKeySpec = ECPrivateKeySpec(deterministicD, parameterSpec) val privateKeyD = BCECPrivateKey(privateKey.algorithm, privateKeySpec, BouncyCastleProvider.CONFIGURATION) // Compute the public key by scalar multiplication. // Note that BIP32 uses masterKey + mac_derived_key as the final private key and it consequently // requires an extra point addition: master_public + mac_derived_public for the public part. // In our model, the mac_derived_output, deterministicD, is not currently added to the masterKey and it // it forms, by itself, the new private key, which in turn is used to compute the new public key. val pointQ = FixedPointCombMultiplier().multiply(parameterSpec.g, deterministicD) // This is unlikely to happen, but we should check for point at infinity. if (pointQ.isInfinity) { // Instead of throwing an exception, we retry with SHA256(seed). return deriveKeyPairECDSA(parameterSpec, privateKey, seed.sha256().bytes) } val publicKeySpec = ECPublicKeySpec(pointQ, parameterSpec) val publicKeyD = BCECPublicKey(privateKey.algorithm, publicKeySpec, BouncyCastleProvider.CONFIGURATION) return KeyPair(publicKeyD, privateKeyD) } - MaxLineLength:Crypto.kt$Crypto${ val sigKey: SignatureScheme = Crypto.findSignatureScheme(keyPair.private) val sigMetaData: SignatureScheme = Crypto.findSignatureScheme(signableData.signatureMetadata.schemeNumberID) // Special handling if the advertised SignatureScheme is CompositeKey. // TODO fix notaries that advertise [CompositeKey] in their signature Metadata. Currently, clustered notary nodes // mention Crypto.COMPOSITE_KEY in their SignatureMetadata, but they are actually signing with a leaf-key // (and if they refer to it as a Composite key, then we lose info about the actual type of their signing key). // In short, their metadata should be the leaf key-type, until we support CompositeKey signatures. require(sigKey == sigMetaData || sigMetaData == Crypto.COMPOSITE_KEY) { "Metadata schemeCodeName: ${sigMetaData.schemeCodeName} is not aligned with the key type: ${sigKey.schemeCodeName}." } val signatureBytes = doSign(sigKey.schemeCodeName, keyPair.private, signableData.serialize().bytes) return TransactionSignature(signatureBytes, keyPair.public, signableData.signatureMetadata) } - MaxLineLength:CryptoService.kt$CryptoService$ fun defaultIdentitySignatureScheme(): SignatureScheme - MaxLineLength:CryptoService.kt$CryptoService$ fun defaultTLSSignatureScheme(): SignatureScheme - MaxLineLength:CryptoSignUtils.kt$CryptoSignUtils - MaxLineLength:CryptoSignUtils.kt$CryptoSignUtils$"Metadata schemeCodeName: ${sigMetaData.schemeCodeName} is not aligned with the key type: ${sigKey.schemeCodeName}." - MaxLineLength:CryptoUtils.kt$ // TODO: SignatureException should be used only for a damaged signature, as per `java.security.Signature.verify()`. @Throws(SignatureException::class, InvalidKeyException::class) fun PublicKey.verify(content: ByteArray, signature: DigitalSignature) MaxLineLength:CryptoUtils.kt$ @DeleteForDJVM @Throws(NoSuchAlgorithmException::class) fun newSecureRandom(): SecureRandom MaxLineLength:CryptoUtils.kt$ @DeleteForDJVM @Throws(NoSuchAlgorithmException::class) fun secureRandomBytes(numOfBytes: Int): ByteArray - MaxLineLength:CryptoUtils.kt$ @DeleteForDJVM fun random63BitValue(): Long MaxLineLength:CryptoUtils.kt$ @Throws(InvalidKeyException::class, SignatureException::class) fun KeyPair.verify(signatureData: ByteArray, clearData: ByteArray): Boolean MaxLineLength:CryptoUtils.kt$ @Throws(InvalidKeyException::class, SignatureException::class) fun PublicKey.verify(signatureData: ByteArray, clearData: ByteArray): Boolean - MaxLineLength:CryptoUtils.kt$ @Throws(SignatureException::class, InvalidKeyException::class) fun PublicKey.isValid(content: ByteArray, signature: DigitalSignature): Boolean - MaxLineLength:CryptoUtils.kt$ fun <T : Any> serializedHash(x: T): SecureHash MaxLineLength:CryptoUtils.kt$ fun PublicKey.isFulfilledBy(otherKeys: Iterable<PublicKey>): Boolean - MaxLineLength:CryptoUtils.kt$ fun componentHash(nonce: SecureHash, opaqueBytes: OpaqueBytes): SecureHash - MaxLineLength:CryptoUtils.kt$ fun componentHash(opaqueBytes: OpaqueBytes, privacySalt: PrivacySalt, componentGroupIndex: Int, internalIndex: Int): SecureHash MaxLineLength:CryptoUtils.kt$ fun computeNonce(privacySalt: PrivacySalt, groupIndex: Int, internalIndex: Int) MaxLineLength:CryptoUtils.kt$throw IllegalStateException("Verification of CompositeKey signatures currently not supported.") - MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$assertEquals("DL9yJfiNGqteRrKPjGUkRQkeqzuQ4kwcYQWMCi5YKuUHrk", keyPairBiggerThan256bitsV2.public.toStringShort()) - MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$assertEquals("DLANmjhGSVdLyghxcPHrn3KuGatscf6LtvqifUDxw7SGU8", keyPairBiggerThan256bitsV2.public.toStringShort()) - MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$assertEquals("DLB9K1UiBrWonn481z6NzkqoWHjMBXpfDeaet3wiwRNWSU", keyPairBiggerThan256bitsV2.public.toStringShort()) MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val expectedAlgSet = setOf("RSA_SHA256", "ECDSA_SECP256K1_SHA256", "ECDSA_SECP256R1_SHA256", "EDDSA_ED25519_SHA512", "SPHINCS-256_SHA512", "COMPOSITE") MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan256bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("2").pow(258).minus(BigInteger.TEN)) MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan256bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("2").pow(258).minus(BigInteger.TEN)) - MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan256bits = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("2").pow(258).minus(BigInteger.TEN)) MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan256bitsV2 = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("2").pow(258).minus(BigInteger("50"))) MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan256bitsV2 = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("2").pow(258).minus(BigInteger("50"))) MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan256bitsV2 = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("2").pow(258).minus(BigInteger("50"))) MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan258bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("2").pow(259).plus(BigInteger.ONE)) MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan258bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("2").pow(259).plus(BigInteger.ONE)) - MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan258bits = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("2").pow(259).plus(BigInteger.ONE)) MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan512bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("2").pow(514).minus(BigInteger.TEN)) MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan512bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("2").pow(514).minus(BigInteger.TEN)) - MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val keyPairBiggerThan512bits = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("2").pow(514).minus(BigInteger.TEN)) MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest$val pubKeySpec = EdDSAPublicKeySpec((EDDSA_ED25519_SHA512.algSpec as EdDSANamedCurveSpec).curve.getZero(GroupElement.Representation.P3), EDDSA_ED25519_SHA512.algSpec as EdDSANamedCurveSpec) - MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest${ val keyPairPositive = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("10")) assertEquals("DL6pYKUgH17az8MLdonvvUtUPN8TqwpCGcdgLr7vg3skCU", keyPairPositive.public.toStringShort()) // The underlying implementation uses the hash of entropy if it is out of range 2 <= entropy < N, where N the order of the group. val keyPairNegative = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("-10")) assertEquals("DLnpXhxece69Nyqgm3pPt3yV7ESQYDJKoYxs1hKgfBAEu", keyPairNegative.public.toStringShort()) val keyPairZero = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("0")) assertEquals("DLBC28e18T6KsYwjTFfUWJfhvHjvYVapyVf6antnqUkbgd", keyPairZero.public.toStringShort()) // BigIntenger.Zero is out or range, so 1 and hash(1.toByteArray) would have the same impact. val zeroHashed = BigInteger(1, BigInteger("0").toByteArray().sha256().bytes) // Check oneHashed < N (order of the group), otherwise we would need an extra hash. assertEquals(-1, zeroHashed.compareTo((ECDSA_SECP256K1_SHA256.algSpec as ECNamedCurveParameterSpec).n)) val keyPairZeroHashed = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, zeroHashed) assertEquals("DLBC28e18T6KsYwjTFfUWJfhvHjvYVapyVf6antnqUkbgd", keyPairZeroHashed.public.toStringShort()) val keyPairOne = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("1")) assertEquals("DLBimRXdEQhJUTpL6f9ri9woNdsze6mwkRrhsML13Eh7ET", keyPairOne.public.toStringShort()) // BigIntenger.ONE is out or range, so 1 and hash(1.toByteArray) would have the same impact. val oneHashed = BigInteger(1, BigInteger("1").toByteArray().sha256().bytes) // Check oneHashed < N (order of the group), otherwise we would need an extra hash. assertEquals(-1, oneHashed.compareTo((ECDSA_SECP256K1_SHA256.algSpec as ECNamedCurveParameterSpec).n)) val keyPairOneHashed = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, oneHashed) assertEquals("DLBimRXdEQhJUTpL6f9ri9woNdsze6mwkRrhsML13Eh7ET", keyPairOneHashed.public.toStringShort()) // 2 is in the range. val keyPairTwo = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("2")) assertEquals("DLG32UWaevGw9YY7w1Rf9mmK88biavgpDnJA9bG4GapVPs", keyPairTwo.public.toStringShort()) // Try big numbers that are out of range. val keyPairBiggerThan256bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("2").pow(258).minus(BigInteger.TEN)) assertEquals("DLGHsdv2xeAuM7n3sBc6mFfiphXe6VSf3YxqvviKDU6Vbd", keyPairBiggerThan256bits.public.toStringShort()) val keyPairBiggerThan256bitsV2 = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("2").pow(258).minus(BigInteger("50"))) assertEquals("DL9yJfiNGqteRrKPjGUkRQkeqzuQ4kwcYQWMCi5YKuUHrk", keyPairBiggerThan256bitsV2.public.toStringShort()) val keyPairBiggerThan512bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("2").pow(514).minus(BigInteger.TEN)) assertEquals("DL3Wr5EQGrMTaKBy5XMvG8rvSfKX1AYZLCRU8kixGbxt1E", keyPairBiggerThan512bits.public.toStringShort()) val keyPairBiggerThan258bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256K1_SHA256, BigInteger("2").pow(259).plus(BigInteger.ONE)) assertEquals("DL7NbssqvuuJ4cqFkkaVYu9j1MsVswESGgCfbqBS9ULwuM", keyPairBiggerThan258bits.public.toStringShort()) } - MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest${ val keyPairPositive = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("10")) assertEquals("DLHDcxuSt9J3cbjd2Dsx4rAgYYA7BAP7A8VLrFiq1tH9yy", keyPairPositive.public.toStringShort()) // The underlying implementation uses the hash of entropy if it is out of range 2 < entropy < N, where N the order of the group. val keyPairNegative = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("-10")) assertEquals("DLBASmjiMZuu1g3EtdHJxfSueXE8PRoUWbkdU61Qcnpamt", keyPairNegative.public.toStringShort()) val keyPairZero = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("0")) assertEquals("DLH2FEHEnsT3MpCJt2gfyNjpqRqcBxeupK4YRPXvDsVEkb", keyPairZero.public.toStringShort()) // BigIntenger.Zero is out or range, so 1 and hash(1.toByteArray) would have the same impact. val zeroHashed = BigInteger(1, BigInteger("0").toByteArray().sha256().bytes) // Check oneHashed < N (order of the group), otherwise we would need an extra hash. assertEquals(-1, zeroHashed.compareTo((ECDSA_SECP256R1_SHA256.algSpec as ECNamedCurveParameterSpec).n)) val keyPairZeroHashed = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, zeroHashed) assertEquals("DLH2FEHEnsT3MpCJt2gfyNjpqRqcBxeupK4YRPXvDsVEkb", keyPairZeroHashed.public.toStringShort()) val keyPairOne = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("1")) assertEquals("DLHrtKwjv6onq9HcrQDJPs8Cgtai5mZU5ZU6sb1ivJjx3z", keyPairOne.public.toStringShort()) // BigIntenger.ONE is out or range, so 1 and hash(1.toByteArray) would have the same impact. val oneHashed = BigInteger(1, BigInteger("1").toByteArray().sha256().bytes) // Check oneHashed < N (order of the group), otherwise we would need an extra hash. assertEquals(-1, oneHashed.compareTo((ECDSA_SECP256R1_SHA256.algSpec as ECNamedCurveParameterSpec).n)) val keyPairOneHashed = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, oneHashed) assertEquals("DLHrtKwjv6onq9HcrQDJPs8Cgtai5mZU5ZU6sb1ivJjx3z", keyPairOneHashed.public.toStringShort()) // 2 is in the range. val keyPairTwo = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("2")) assertEquals("DLFoz6txJ3vHcKNSM1vFxHJUoEQ69PorBwW64dHsAnEoZB", keyPairTwo.public.toStringShort()) // Try big numbers that are out of range. val keyPairBiggerThan256bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("2").pow(258).minus(BigInteger.TEN)) assertEquals("DLBv6fZqaCTbE4L7sgjbt19biXHMgU9CzR5s8g8XBJjZ11", keyPairBiggerThan256bits.public.toStringShort()) val keyPairBiggerThan256bitsV2 = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("2").pow(258).minus(BigInteger("50"))) assertEquals("DLANmjhGSVdLyghxcPHrn3KuGatscf6LtvqifUDxw7SGU8", keyPairBiggerThan256bitsV2.public.toStringShort()) val keyPairBiggerThan512bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("2").pow(514).minus(BigInteger.TEN)) assertEquals("DL9sKwMExBTD3MnJN6LWGqo496Erkebs9fxZtXLVJUBY9Z", keyPairBiggerThan512bits.public.toStringShort()) val keyPairBiggerThan258bits = Crypto.deriveKeyPairFromEntropy(ECDSA_SECP256R1_SHA256, BigInteger("2").pow(259).plus(BigInteger.ONE)) assertEquals("DLBwjWwPJSF9E7b1NWaSbEJ4oK8CF7RDGWd648TiBhZoL1", keyPairBiggerThan258bits.public.toStringShort()) } MaxLineLength:CryptoUtilsTest.kt$CryptoUtilsTest${ val keyPairPositive = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("10")) assertEquals("DLBL3iHCp9uRReWhhCGfCsrxZZpfAm9h9GLbfN8ijqXTq", keyPairPositive.public.toStringShort()) val keyPairNegative = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("-10")) assertEquals("DLC5HXnYsJAFqmM9hgPj5G8whQ4TpyE9WMBssqCayLBwA2", keyPairNegative.public.toStringShort()) val keyPairZero = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("0")) assertEquals("DL4UVhGh4tqu1G86UVoGNaDDNCMsBtNHzE6BSZuNNJN7W2", keyPairZero.public.toStringShort()) val keyPairOne = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("1")) assertEquals("DL8EZUdHixovcCynKMQzrMWBnXQAcbVDHi6ArPphqwJVzq", keyPairOne.public.toStringShort()) val keyPairBiggerThan256bits = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("2").pow(258).minus(BigInteger.TEN)) assertEquals("DLB9K1UiBrWonn481z6NzkqoWHjMBXpfDeaet3wiwRNWSU", keyPairBiggerThan256bits.public.toStringShort()) // The underlying implementation uses the first 256 bytes of the entropy. Thus, 2^258-10 and 2^258-50 and 2^514-10 have the same impact. val keyPairBiggerThan256bitsV2 = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("2").pow(258).minus(BigInteger("50"))) assertEquals("DLB9K1UiBrWonn481z6NzkqoWHjMBXpfDeaet3wiwRNWSU", keyPairBiggerThan256bitsV2.public.toStringShort()) val keyPairBiggerThan512bits = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("2").pow(514).minus(BigInteger.TEN)) assertEquals("DLB9K1UiBrWonn481z6NzkqoWHjMBXpfDeaet3wiwRNWSU", keyPairBiggerThan512bits.public.toStringShort()) // Try another big number. val keyPairBiggerThan258bits = Crypto.deriveKeyPairFromEntropy(EDDSA_ED25519_SHA512, BigInteger("2").pow(259).plus(BigInteger.ONE)) assertEquals("DL5tEFVMXMGrzwjfCAW34JjkhsRkPfFyJ38iEnmpB6L2Z9", keyPairBiggerThan258bits.public.toStringShort()) } - MaxLineLength:Currencies.kt$infix fun Amount<Currency>.issuedBy(deposit: PartyAndReference) - MaxLineLength:CurrencyConfiguration.kt$CurrencyConfiguration${ // TODO This is no longer correct. issuableCurrencies is a config of the finance app and belongs // in a separate .conf file for the app (in the config sub-directory, with a filename matching the CorDapp // jar filename). It is no longer read in from the node conf file. There seem to be pieces missing in the // behave framework to allow one to do this. """ |custom : { | issuableCurrencies : [ | ${issuableCurrencies.joinToString(", ")} | ] |} """ } - MaxLineLength:CurrencyParameterSensitivitiesSerializer.kt$CurrencyParameterSensitivitiesSerializer$override fun fromProxy(proxy: Proxy): CurrencyParameterSensitivities MaxLineLength:CurrencyParameterSensitivitySerialiser.kt$CurrencyParameterSensitivitySerializer$override fun toProxy(obj: CurrencyParameterSensitivity) - MaxLineLength:CustomCordapp.kt$CustomCordapp : TestCordappInternal - MaxLineLength:CustomCordapp.kt$CustomCordapp$jos.addEntry(testEntry(JarFile.MANIFEST_NAME)) { createTestManifest(name, versionId, targetPlatformVersion).write(jos) } // The same resource may be found in different locations (this will happen when running from gradle) so just // pick the first one found. scanResult.allResources.asMap().forEach { path, resourceList -> jos.addEntry(testEntry(path), resourceList[0].open()) } - MaxLineLength:CustomCordapp.kt$CustomCordapp$return ZipEntry(name).setCreationTime(epochFileTime).setLastAccessTime(epochFileTime).setLastModifiedTime(epochFileTime) - MaxLineLength:CustomCordapp.kt$CustomCordapp.Companion$val filename = it.run { "${name.replace(whitespace, "-")}_${versionId}_${targetPlatformVersion}_${UUID.randomUUID()}.jar" } - MaxLineLength:CustomCordappTest.kt$CustomCordappTest$val cordapp = cordappWithPackages("net.corda.testing.node.internal").copy(targetPlatformVersion = 123, name = "CustomCordappTest") - MaxLineLength:CustomSerializer.kt$CustomSerializer$/** * This exists purely for documentation and cross-platform purposes. It is not used by our serialization / deserialization * code path. */ abstract val schemaForDocumentation: Schema - MaxLineLength:CustomSerializer.kt$CustomSerializer$Implements<T : Any> : CustomSerializerImp - MaxLineLength:CustomSerializer.kt$CustomSerializer$Proxy<T : Any, P : Any> : CustomSerializerImp - MaxLineLength:CustomSerializer.kt$CustomSerializer$SubClass<T : Any> : CustomSerializer MaxLineLength:CustomSerializer.kt$CustomSerializer.CustomSerializerImp$abstract MaxLineLength:CustomSerializer.kt$CustomSerializer.CustomSerializerImp$override fun isSerializerFor(clazz: Class<*>): Boolean - MaxLineLength:CustomSerializer.kt$CustomSerializer.CustomSerializerImp$override val typeDescriptor: Symbol = Symbol.valueOf("$DESCRIPTOR_DOMAIN:${AMQPTypeIdentifiers.nameForType(clazz)}") MaxLineLength:CustomSerializer.kt$CustomSerializer.Proxy$override fun isSerializerFor(clazz: Class<*>): Boolean - MaxLineLength:CustomSerializer.kt$CustomSerializer.Proxy$private val proxySerializer: ObjectSerializer by lazy { ObjectSerializer.make(factory.getTypeInformation(proxyClass), factory) } - MaxLineLength:CustomSerializer.kt$CustomSerializer.Proxy$withInheritance: Boolean = true - MaxLineLength:CustomSerializer.kt$CustomSerializer.ToString$listOf - MaxLineLength:CustomSerializer.kt$CustomSerializer.ToString$private - MaxLineLength:CustomSerializerRegistry.kt$CachingCustomSerializerRegistry$CustomSerializerIdentifier - MaxLineLength:CustomSerializerRegistry.kt$CachingCustomSerializerRegistry$logger.warn("Duplicate custom serializers detected for $clazz: ${declaredSerializers.map { it::class.qualifiedName }}") - MaxLineLength:CustomSerializerRegistry.kt$CachingCustomSerializerRegistry$logger.warn("Illegal custom serializer detected for $clazz: ${declaredSerializers.first()::class.qualifiedName}") MaxLineLength:CustomSerializerRegistry.kt$CachingCustomSerializerRegistry$private val customSerializersCache: MutableMap<CustomSerializerIdentifier, CustomSerializerLookupResult> = DefaultCacheProvider.createCache() - MaxLineLength:CustomSerializerRegistry.kt$CachingCustomSerializerRegistry.CustomSerializerLookupResult$CustomSerializerFound : CustomSerializerLookupResult - MaxLineLength:CustomSerializerRegistry.kt$DuplicateCustomSerializerException : Exception - MaxLineLength:CustomSerializerRegistryTests.kt$CustomSerializerRegistryTests$TestCustomSerializer : CustomSerializer - MaxLineLength:CustomSerializerRegistryTests.kt$CustomSerializerRegistryTests$private fun CustomSerializerRegistry.find(clazz: Class<*>): AMQPSerializer<Any> - MaxLineLength:CustomSerializerRegistryTests.kt$CustomSerializerRegistryTests.TestCustomSerializer$override - MaxLineLength:CustomVaultQuery.kt$TopupIssuerFlow.TopupIssuanceRequester$return initiateFlow(issuerBankParty).sendAndReceive<List<AbstractCashFlow.Result>>(topupRequest).unwrap { it } - MaxLineLength:CustomVaultQuery.kt$TopupIssuerFlow.TopupIssuer$val txn = issueCashTo(amount, topupRequest.issueToParty, topupRequest.issuerPartyRef, topupRequest.notaryParty) - MaxLineLength:CustomVaultQuery.kt$TopupIssuerFlow.TopupIssuer${ // invoke Cash subflow to issue Asset progressTracker.currentStep = ISSUING val issueCashFlow = CashIssueFlow(amount, issuerPartyRef, notaryParty) val issueTx = subFlow(issueCashFlow) // NOTE: issueCashFlow performs a Broadcast (which stores a local copy of the txn to the ledger) // short-circuit when issuing to self if (serviceHub.myInfo.isLegalIdentity(issueTo)) return issueTx // now invoke Cash subflow to Move issued assetType to issue requester progressTracker.currentStep = TRANSFERRING val moveCashFlow = CashPaymentFlow(amount, issueTo, anonymous = false) // NOTE: CashFlow PayCash calls FinalityFlow which performs a Broadcast (which stores a local copy of the txn to the ledger) return subFlow(moveCashFlow) } MaxLineLength:CustomVaultQueryTest.kt$CustomVaultQueryTest$mockNet = MockNetwork(threadPerNode = true, cordappPackages = listOf("net.corda.finance", IOUFlow::class.packageName, javaClass.packageName, "com.template")) - MaxLineLength:DBCheckpointStorageTests.kt$DBCheckpointStorageTests$CheckpointVerifier.verifyCheckpointsCompatible(checkpointStorage, emptyList(), 1, mockServices, emptyList()) MaxLineLength:DBCheckpointStorageTests.kt$DBCheckpointStorageTests$val checkpoint = Checkpoint.create(InvocationContext.shell(), FlowStart.Explicit, logic.javaClass, frozenLogic, ALICE, SubFlowVersion.CoreFlow(version), false) .getOrThrow() - MaxLineLength:DBNetworkParametersStorage.kt$DBNetworkParametersStorage$log.warn("Tried to download historical network parameters with hash $parametersHash, but network map url isn't configured") - MaxLineLength:DBNetworkParametersStorage.kt$DBNetworkParametersStorage$override MaxLineLength:DBNetworkParametersStorage.kt$DBNetworkParametersStorage.Companion$PersistentNetworkParameters MaxLineLength:DBNetworkParametersStorage.kt$DBNetworkParametersStorage.Companion$fun createParametersMap(cacheFactory: NamedCacheFactory): AppendOnlyPersistentMap<SecureHash, SignedDataWithCert<NetworkParameters>, PersistentNetworkParameters, String> - MaxLineLength:DBNetworkParametersStorage.kt$DBNetworkParametersStorage.PersistentNetworkParameters$( @Id @Column(name = "hash", length = MAX_HASH_HEX_SIZE, nullable = false) val hash: String = "", @Column(name = "epoch", nullable = false) val epoch: Int = 0, // Stored as serialized bytes because network parameters structure evolves over time. @Lob @Column(name = "parameters_bytes", nullable = false) val networkParametersBytes: ByteArray = ArrayUtils.EMPTY_BYTE_ARRAY, @Lob @Column(name = "signature_bytes", nullable = false) private val signature: ByteArray = ArrayUtils.EMPTY_BYTE_ARRAY, // First certificate in the certificate chain. @Lob @Column(name = "cert", nullable = false) private val certificate: ByteArray = ArrayUtils.EMPTY_BYTE_ARRAY, // Parent certificate path (the first one is stored separately), so node is agnostic to certificate hierarchy. @Lob @Column(name = "parent_cert_path", nullable = false) private val certPath: ByteArray = ArrayUtils.EMPTY_BYTE_ARRAY ) MaxLineLength:DBNetworkParametersStorage.kt$DBNetworkParametersStorage.PersistentNetworkParameters$val signWithCert = DigitalSignatureWithCert(X509CertificateFactory().generateCertificate(certificate.inputStream()), certChain, signature) - MaxLineLength:DBNetworkParametersStorageTest.kt$DBNetworkParametersStorageTest$incorrectParams = createDevNetworkMapCa(DEV_INTERMEDIATE_CA).sign(testNetworkParameters(minimumPlatformVersion = 3)) - MaxLineLength:DBNetworkParametersStorageTest.kt$DBNetworkParametersStorageTest$it.contains("Caused by: java.security.cert.CertPathValidatorException: subject/issuer name chaining check failed") - MaxLineLength:DBNetworkParametersStorageTest.kt$DBNetworkParametersStorageTest$networkParametersService - MaxLineLength:DBTransactionMappingStorage.kt$DBTransactionMappingStorage : StateMachineRecordedTransactionMappingStorage MaxLineLength:DBTransactionMappingStorage.kt$DBTransactionMappingStorage$cq.multiselect(from.get<String>(DBTransactionStorage.DBTransaction::stateMachineRunId.name), from.get<String>(DBTransactionStorage.DBTransaction::txId.name)) - MaxLineLength:DBTransactionMappingStorage.kt$DBTransactionMappingStorage$override MaxLineLength:DBTransactionMappingStorage.kt$DBTransactionMappingStorage$val flowIds = session.createQuery(cq).resultList.map { StateMachineTransactionMapping(StateMachineRunId(UUID.fromString(it[0] as String)), SecureHash.parse(it[1] as String)) } MaxLineLength:DBTransactionStorage.kt$DBTransactionStorage : WritableTransactionStorageSingletonSerializeAsToken - MaxLineLength:DBTransactionStorage.kt$DBTransactionStorage$override fun getTransaction(id: SecureHash): SignedTransaction? - MaxLineLength:DBTransactionStorage.kt$DBTransactionStorage.Companion$return if (effectiveSerializationEnv.serializationFactory.currentContext?.useCase == SerializationContext.UseCase.Storage) { effectiveSerializationEnv.serializationFactory.currentContext!! } else { SerializationDefaults.STORAGE_CONTEXT } MaxLineLength:DBTransactionStorageTests.kt$DBTransactionStorageTests$listOf(TransactionSignature(ByteArray(1), ALICE_PUBKEY, SignatureMetadata(1, Crypto.findSignatureScheme(ALICE_PUBKEY).schemeNumberID))) - MaxLineLength:DJVM.kt$@Throws(ClassNotFoundException::class) internal - MaxLineLength:DJVM.kt$internal MaxLineLength:DJVM.kt$private val allEnumDirectories: sandbox.java.util.Map<Class<out Enum<*>>, sandbox.java.util.Map<String, out Enum<*>>> = sandbox.java.util.LinkedHashMap() - MaxLineLength:DJVMTest.kt$DJVMTest$arrayOf(intOf(1), longOf(10), stringOf("Hello World"), charOf('?'), booleanOf(false), doubleOf(1234.56)) - MaxLineLength:DJVMTest.kt$DJVMTest$unsandbox(arrayOf(intOf(1), longOf(10L), stringOf("Hello World"), charOf('?'), booleanOf(false), doubleOf(1234.56))) - MaxLineLength:DataSourceFactory.kt$DataSourceFactory$fun createDataSource(hikariProperties: Properties, pool: Boolean = true, metricRegistry: MetricRegistry? = null): DataSource - MaxLineLength:DatabaseTransaction.kt$get() = contextTransactionOrNull ?: error("Was expecting to find transaction set on current strand: ${Strand.currentStrand()}") MaxLineLength:DatabaseTransaction.kt$get() = if (_prohibitDatabaseAccess.get() == true) throw IllegalAccessException("Database access is disabled in this context.") else _contextTransaction.get() - MaxLineLength:DbExceptionHandler.kt$DbExceptionHandler : UncaughtExceptionHandler - MaxLineLength:DbExceptionHandler.kt$DbExceptionHandler$errorAndTerminate("Thread ${t!!.name} failed due to database connection error. This is unrecoverable, terminating node.", e) - MaxLineLength:DbMapDeadlockTest.kt$DbMapDeadlockTest$// First clean up any remains from previous test runs persistence.transaction { session.createNativeQuery("delete from locktestobjects").executeUpdate() session.createNativeQuery("delete from otherlockobjects").executeUpdate() } // Prepare a few rows for reading in table 1 val prepMap = AppendOnlyPersistentMap<TestKey, Int, MyPersistenceClass, Int>( cacheFactory, "myTestCache", { k -> k.value }, { e -> Pair(TestKey(e.key), e.value) }, { k, v -> MyPersistenceClass(k.value, v) }, MyPersistenceClass::class.java ) persistence.transaction { prepMap.set(TestKey(1), 1) prepMap.set(TestKey(2), 2) prepMap.set(TestKey(10), 10) } // the map that will read from the prepared table val testMap = AppendOnlyPersistentMap<TestKey, Int, MyPersistenceClass, Int>( cacheFactory, "myTestCache", { k -> k.value }, { e -> Pair(TestKey(e.key), e.value) }, { k, v -> MyPersistenceClass(k.value, v) }, MyPersistenceClass::class.java ) // a second map that writes to another (unrelated table) val otherMap = AppendOnlyPersistentMap<TestKey, Int, SecondPersistenceClass, Int>( cacheFactory, "myTestCache", { k -> k.value }, { e -> Pair(TestKey(e.key), e.value) }, { k, v -> SecondPersistenceClass(k.value, v) }, SecondPersistenceClass::class.java ) val latch1 = CyclicBarrier(2) val latch2 = CountDownLatch(1) val latch3 = CyclicBarrier(2) val otherThreadException = AtomicReference<Exception?>(null) // This thread will wait for the main thread to do a few things. Then it will starting to read key 2, and write a key to // the second table. This read will be buffered (not flushed) at first. The subsequent access to read value 10 fromt the // first table will cause the previous write to flush. As the row this will be writing to should be locked from the main // thread, it will wait for the main thread's db transaction to commit or rollback before proceeding with the read. val otherThread = thread(name = "testThread2") { try { log.info("Thread2 waiting") latch1.await() latch2.await() log.info("Thread2 starting transaction") persistence.transaction { log.info("Thread2 getting key 2") testMap.get(TestKey(2)) log.info("Thread2 set other value 100") otherMap.set(TestKey(100), 100) latch3.await() log.info("Thread2 getting value 10") val v = testMap.get(TestKey(10)) assertEquals(10, v) } log.info("Thread2 done") } catch (e: Exception) { log.info("Thread2 threw") // Don't log the exception though, since we expect it and check in the assertions what it is. otherThreadException.set(e) } } log.info("MainThread waiting for Thread2 to start waiting") latch1.await() // The main thread will write to the same key in the second table, and then read key 1 from the read table. As it will do that // before triggering the run on thread 2, it will get the row lock in the second table when flushing before the read, then // read and carry on. log.info("MainThread starting transaction") persistence.transaction { log.info("MainThread getting key 2") testMap.get(TestKey(2)) log.info("MainThread set other key 100") otherMap.set(TestKey(100), 100) log.info("MainThread getting key 1") testMap.get(TestKey(1)) // Then it will trigger the start of the second thread (see above) and then sleep for a bit to make sure the other // thread actually runs and beats this thread to the get(10). The test will still pass if it doesn't. log.info("MainThread signal") latch2.countDown() log.info("MainThread wait for Thread2 to be getting the same key") latch3.await() log.info("MainThread sleep for 2 seconds so ideally Thread2 reaches the get first") sleep(2000) // finally it will try to get the same value from the read table that the other thread is trying to read. // If access to reading this value from the DB is guarded by a lock, the other thread will be holding this lock // which means the threads are now deadlocked. log.info("MainThread get value 10") try { assertEquals(10, testMap.get(TestKey(10))) } catch (e: Exception) { checkException(e) } } log.info("MainThread joining with Thread2") otherThread.join() assertNotNull(otherThreadException.get()) checkException(otherThreadException.get()) log.info("MainThread done") - MaxLineLength:DbMapDeadlockTest.kt$DbMapDeadlockTest$// We have to catch any exception thrown and check what they are - primary key constraint violations are fine, we are trying // to insert the same key twice after all. Any deadlock time outs or similar are completely not fine and should be a test failure. private fun checkException(exception: Exception?) - MaxLineLength:DbMapDeadlockTest.kt$DbMapDeadlockTest$createCordaPersistence(dbConfig, { null }, { null }, schemaService, hikariProperties, cacheFactory, null) MaxLineLength:DbMapDeadlockTest.kt$DbMapDeadlockTest$it.setProperty("dataSource.url", "jdbc:h2:file:${temporaryFolder.root}/persistence;DB_CLOSE_ON_EXIT=FALSE;WRITE_DELAY=0;LOCK_TIMEOUT=10000") - MaxLineLength:DbMapDeadlockTest.kt$DbMapDeadlockTest$log.info("MainThread getting key 2") testMap.get(TestKey(2)) log.info("MainThread set other key 100") otherMap.set(TestKey(100), 100) log.info("MainThread getting key 1") testMap.get(TestKey(1)) // Then it will trigger the start of the second thread (see above) and then sleep for a bit to make sure the other // thread actually runs and beats this thread to the get(10). The test will still pass if it doesn't. log.info("MainThread signal") latch2.countDown() log.info("MainThread wait for Thread2 to be getting the same key") latch3.await() log.info("MainThread sleep for 2 seconds so ideally Thread2 reaches the get first") sleep(2000) // finally it will try to get the same value from the read table that the other thread is trying to read. // If access to reading this value from the DB is guarded by a lock, the other thread will be holding this lock // which means the threads are now deadlocked. log.info("MainThread get value 10") try { assertEquals(10, testMap.get(TestKey(10))) } catch (e: Exception) { checkException(e) } - MaxLineLength:DbMapDeadlockTest.kt$DbMapDeadlockTest$log.info("Thread2 threw") - MaxLineLength:DbMapDeadlockTest.kt$DbMapDeadlockTest$startHikariPool(hikariProperties, dbConfig, schemaService.schemaOptions.keys, ourName = TestIdentity(ALICE_NAME, 70).name) - MaxLineLength:DbMapDeadlockTest.kt$DbMapDeadlockTest$val dbConfig = DatabaseConfig(initialiseSchema = true, transactionIsolationLevel = TransactionIsolationLevel.READ_COMMITTED) MaxLineLength:DbMapDeadlockTest.kt$LockDbSchemaV2 : MappedSchema - MaxLineLength:DeduplicationChecker.kt$DeduplicationChecker - MaxLineLength:DeduplicationId.kt$SenderDeduplicationId MaxLineLength:DefaultKryoCustomizer.kt$DefaultKryoCustomizer$// Store a little schema of field names in the stream the first time a class is used which increases tolerance // for change to a class. setDefaultSerializer(CompatibleFieldSerializer::class.java) // Take the safest route here and allow subclasses to have fields named the same as super classes. fieldSerializerConfig.cachedFieldNameStrategy = FieldSerializer.CachedFieldNameStrategy.EXTENDED instantiatorStrategy = CustomInstantiatorStrategy() // Required for HashCheckingStream (de)serialization. // Note that return type should be specifically set to InputStream, otherwise it may not work, i.e. val aStream : InputStream = HashCheckingStream(...). addDefaultSerializer(InputStream::class.java, InputStreamSerializer) addDefaultSerializer(SerializeAsToken::class.java, SerializeAsTokenSerializer<SerializeAsToken>()) addDefaultSerializer(Logger::class.java, LoggerSerializer) addDefaultSerializer(X509Certificate::class.java, X509CertificateSerializer) // WARNING: reordering the registrations here will cause a change in the serialized form, since classes // with custom serializers get written as registration ids. This will break backwards-compatibility. // Please add any new registrations to the end. // TODO: re-organise registrations into logical groups before v1.0 register(Arrays.asList("").javaClass, ArraysAsListSerializer()) register(LazyMappedList::class.java, LazyMappedListSerializer) register(SignedTransaction::class.java, SignedTransactionSerializer) register(WireTransaction::class.java, WireTransactionSerializer) register(SerializedBytes::class.java, SerializedBytesSerializer) UnmodifiableCollectionsSerializer.registerSerializers(this) ImmutableListSerializer.registerSerializers(this) ImmutableSetSerializer.registerSerializers(this) ImmutableSortedSetSerializer.registerSerializers(this) ImmutableMapSerializer.registerSerializers(this) ImmutableMultimapSerializer.registerSerializers(this) // InputStream subclasses whitelisting, required for attachments. register(BufferedInputStream::class.java, InputStreamSerializer) register(Class.forName("sun.net.www.protocol.jar.JarURLConnection\$JarURLInputStream"), InputStreamSerializer) noReferencesWithin<WireTransaction>() register(ECPublicKeyImpl::class.java, publicKeySerializer) register(EdDSAPublicKey::class.java, publicKeySerializer) register(EdDSAPrivateKey::class.java, PrivateKeySerializer) register(CompositeKey::class.java, publicKeySerializer) // Using a custom serializer for compactness // Exceptions. We don't bother sending the stack traces as the client will fill in its own anyway. register(Array<StackTraceElement>::class, read = { _, _ -> emptyArray() }, write = { _, _, _ -> }) // This ensures a NonEmptySetSerializer is constructed with an initial value. register(NonEmptySet::class.java, NonEmptySetSerializer) register(BitSet::class.java, BitSetSerializer()) register(Class::class.java, ClassSerializer) register(FileInputStream::class.java, InputStreamSerializer) register(CertPath::class.java, CertPathSerializer) register(X509CertPath::class.java, CertPathSerializer) register(BCECPrivateKey::class.java, PrivateKeySerializer) register(BCECPublicKey::class.java, publicKeySerializer) register(BCRSAPrivateCrtKey::class.java, PrivateKeySerializer) register(BCRSAPublicKey::class.java, publicKeySerializer) register(BCSphincs256PrivateKey::class.java, PrivateKeySerializer) register(BCSphincs256PublicKey::class.java, publicKeySerializer) register(NotaryChangeWireTransaction::class.java, NotaryChangeWireTransactionSerializer) register(PartyAndCertificate::class.java, PartyAndCertificateSerializer) // Don't deserialize PrivacySalt via its default constructor. register(PrivacySalt::class.java, PrivacySaltSerializer) // Used by the remote verifier, and will possibly be removed in future. register(ContractAttachment::class.java, ContractAttachmentSerializer) register(java.lang.invoke.SerializedLambda::class.java) register(ClosureSerializer.Closure::class.java, CordaClosureBlacklistSerializer) register(ContractUpgradeWireTransaction::class.java, ContractUpgradeWireTransactionSerializer) register(ContractUpgradeFilteredTransaction::class.java, ContractUpgradeFilteredTransactionSerializer) for (whitelistProvider in serializationWhitelists) { val types = whitelistProvider.whitelist require(types.toSet().size == types.size) { val duplicates = types.toMutableList() types.toSet().forEach { duplicates -= it } "Cannot add duplicate classes to the whitelist ($duplicates)." } for (type in types) { ((kryo.classResolver as? CordaClassResolver)?.whitelist as? MutableClassWhitelist)?.add(type) } } - MaxLineLength:DefaultKryoCustomizer.kt$DefaultKryoCustomizer$register(Class.forName("sun.net.www.protocol.jar.JarURLConnection\$JarURLInputStream"), InputStreamSerializer) - MaxLineLength:DefaultKryoCustomizer.kt$DefaultKryoCustomizer.ContractAttachmentSerializer$return ContractAttachment.create(lazyAttachment, contract, additionalContracts, uploader, signers, version) - MaxLineLength:DefaultKryoCustomizer.kt$DefaultKryoCustomizer.CustomInstantiatorStrategy$val strat = if (type.name.startsWith("java.") && !isPublic(type.modifiers)) fallbackStrategy else defaultStrategy MaxLineLength:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$Action.SendExisting(initiatedSession.peerParty, existingMessage, SenderDeduplicationId(deduplicationId, startingState.senderUUID)) - MaxLineLength:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$is FlowException -> DeclaredField<Party?>(FlowException::class.java, "peer", exception).value = sessionState.peerParty - MaxLineLength:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$pendingDeduplicationHandlers = currentState.pendingDeduplicationHandlers + event.deduplicationHandler - MaxLineLength:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$sessions = checkpoint.sessions + (sessionId to sessionState.copy(rejectionError = flowError)) - MaxLineLength:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$sessions = currentState.checkpoint.sessions + (event.sessionMessage.recipientSessionId to initiatedSession) - MaxLineLength:DeliverSessionMessageTransition.kt$DeliverSessionMessageTransition$sessions = startingState.checkpoint.sessions + (event.sessionMessage.recipientSessionId to newSessionState) - MaxLineLength:DeserializationInput.kt$DeserializationInput$"Existing reference type mismatch. Expected: '$type', found: '${objectRetrieved::class.java}' " - MaxLineLength:DeserializationInput.kt$DeserializationInput$@VisibleForTesting @Throws(AMQPNoTypeNotSerializableException::class) fun getEnvelope(byteSequence: ByteSequence, context: SerializationContext) - MaxLineLength:DeserializationInput.kt$DeserializationInput$clazz - MaxLineLength:DeserializationInput.kt$DeserializationInput$if (type != TypeIdentifier.UnknownType.getLocalType() && serializer.type != type && with(serializer.type) { !isSubClassOf(type) && !materiallyEquivalentTo(type) } ) { throw AMQPNotSerializableException( type, "Described type with descriptor ${obj.descriptor} was " + "expected to be of type $type but was ${serializer.type}") } - MaxLineLength:DeserializationInput.kt$DeserializationInput$throw NotSerializableException("Internal deserialization failure: ${e.javaClass.name}: ${e.message}").apply { initCause(e) } - MaxLineLength:DeserializationInput.kt$DeserializationInput${ // It must be a reference to an instance that has already been read, cheaply and quickly returning it by reference. val objectIndex = (obj.described as UnsignedInteger).toInt() if (objectIndex >= objectHistory.size) throw AMQPNotSerializableException( type, "Retrieval of existing reference failed. Requested index $objectIndex " + "is outside of the bounds for the list of size: ${objectHistory.size}") val objectRetrieved = objectHistory[objectIndex] if (!objectRetrieved::class.java.isSubClassOf(type.asClass())) { throw AMQPNotSerializableException( type, "Existing reference type mismatch. Expected: '$type', found: '${objectRetrieved::class.java}' " + "@ $objectIndex") } objectRetrieved } - MaxLineLength:DeserializationInput.kt$DeserializationInput.Companion$@Throws(AMQPNoTypeNotSerializableException::class) fun getEnvelope(byteSequence: ByteSequence, encodingWhitelist: EncodingWhitelist = NullEncodingWhitelist): Envelope - MaxLineLength:DeserializationInput.kt$DeserializationInput.Companion$throw AMQPNoTypeNotSerializableException(encodingNotPermittedFormat.format(encoding)) - MaxLineLength:DeserializeAndReturnEnvelopeTests.kt$DeserializeAndReturnEnvelopeTests$assertEquals(null, obj.envelope.schema.types.find { it.name == "java.lang.Comparable<${classTestName("Foo")}>" }) MaxLineLength:DeserializeMapTests.kt$DeserializeMapTests$Assertions.assertThatThrownBy { TestSerializationOutput(VERBOSE, sf).serialize(c) } .isInstanceOf(IllegalArgumentException::class.java) - MaxLineLength:DeserializeNeedingCarpentryTests.kt$DeserializeNeedingCarpentryTests$val classInstance = outerClass.constructors.first().newInstance(nestedClass.constructors.first().newInstance("name")) - MaxLineLength:DeserializeNeedingCarpentryTests.kt$DeserializeNeedingCarpentryTests${ val testVal = 10 val clazz = ClassCarpenterImpl(whitelist = AllWhitelist).build(ClassSchema(testName(), mapOf("a" to NonNullableField(Int::class.java)))) val classInstance = clazz.constructors[0].newInstance(testVal) val serialisedBytes = TestSerializationOutput(VERBOSE, sf1).serialize(classInstance) val deserializedObj1 = DeserializationInput(sf1).deserialize(serialisedBytes) assertEquals(clazz, deserializedObj1::class.java) assertEquals(testVal, deserializedObj1::class.java.getMethod("getA").invoke(deserializedObj1)) val deserializedObj2 = DeserializationInput(sf1).deserialize(serialisedBytes) assertEquals(clazz, deserializedObj2::class.java) assertEquals(deserializedObj1::class.java, deserializedObj2::class.java) assertEquals(testVal, deserializedObj2::class.java.getMethod("getA").invoke(deserializedObj2)) val deserializedObj3 = DeserializationInput(sf2).deserializeWithoutAndWithCarpenter(serialisedBytes) assertNotEquals(clazz, deserializedObj3::class.java) assertNotEquals(deserializedObj1::class.java, deserializedObj3::class.java) assertNotEquals(deserializedObj2::class.java, deserializedObj3::class.java) assertEquals(testVal, deserializedObj3::class.java.getMethod("getA").invoke(deserializedObj3)) // NOTE: There is no point attempting this without the carepenter a second time as having carpented things up once // it will, of course, just succeed even with the carpenter disabled val deserializedObj4 = DeserializationInput(sf2).deserialize(serialisedBytes) assertNotEquals(clazz, deserializedObj4::class.java) assertNotEquals(deserializedObj1::class.java, deserializedObj4::class.java) assertNotEquals(deserializedObj2::class.java, deserializedObj4::class.java) assertEquals(deserializedObj3::class.java, deserializedObj4::class.java) assertEquals(testVal, deserializedObj4::class.java.getMethod("getA").invoke(deserializedObj4)) } MaxLineLength:DeserializeQueryableStateTest.kt$DeserializeQueryableStateTest$val clientContext = AMQP_RPC_CLIENT_CONTEXT.copy(whitelist = AllWhitelist, deserializationClassLoader = ClassLoaderWithoutTestState(ClassLoader.getSystemClassLoader())) MaxLineLength:DevCertificatesTest.kt$DevCertificatesTest$val oldNodeCaKeyStore = loadKeyStore(javaClass.classLoader.getResourceAsStream("regression-test/$OLD_NODE_DEV_KEYSTORE_FILE_NAME"), OLD_DEV_KEYSTORE_PASS) - MaxLineLength:DevIdentityGenerator.kt$DevIdentityGenerator$ fun generateDistributedNotaryCompositeIdentity(dirs: List<Path>, notaryName: CordaX500Name, threshold: Int = 1): Party MaxLineLength:DevIdentityGenerator.kt$DevIdentityGenerator$DEV_CA_KEY_STORE_PASS MaxLineLength:DevIdentityGenerator.kt$DevIdentityGenerator$val p2pKeyStore = FileBasedCertificateStoreSupplier(certificatesDirectory / "sslkeystore.jks", DEV_CA_KEY_STORE_PASS, DEV_CA_KEY_STORE_PASS) MaxLineLength:DevIdentityGenerator.kt$DevIdentityGenerator$val p2pTrustStore = FileBasedCertificateStoreSupplier(certificatesDirectory / "truststore.jks", DEV_CA_TRUST_STORE_PASS, DEV_CA_TRUST_STORE_PRIVATE_KEY_PASS) MaxLineLength:DevIdentityGenerator.kt$DevIdentityGenerator$val signingCertStore = FileBasedCertificateStoreSupplier(certificatesDirectory / "nodekeystore.jks", DEV_CA_KEY_STORE_PASS, DEV_CA_KEY_STORE_PASS) MaxLineLength:DigitalSignatureWithCert.kt$DigitalSignatureWithCert : DigitalSignature - MaxLineLength:DigitalSignatureWithCert.kt$DigitalSignatureWithCert$val parameters = PKIXParameters(setOf(TrustAnchor(parentCertsChain.last(), null))).apply { isRevocationEnabled = false } - MaxLineLength:DigitalSignatureWithCert.kt$SignedDataWithCert<T : Any> : NamedByHash - MaxLineLength:DigitalSignatureWithCert.kt$net.corda.core.internal.DigitalSignatureWithCert.kt - MaxLineLength:DisallowNonDeterministicMethods.kt$DisallowNonDeterministicMethods$private fun isForbidden(instruction: MemberAccessInstruction): Boolean - MaxLineLength:DisallowNonDeterministicMethods.kt$DisallowNonDeterministicMethods$throwException<RuleViolationError>("Disallowed reference to API; ${memberFormatter.format(instruction.member)}") - MaxLineLength:DisallowNonDeterministicMethods.kt$DisallowNonDeterministicMethods$|| - MaxLineLength:Disruption.kt$connection.runShellCommandGetOutput("sudo rm ${connection.remoteNode.nodeDirectory}/persistence.mv.db").getResultOrThrow() MaxLineLength:Disruption.kt$val shell = "for c in {1..$parallelism} ; do openssl enc -aes-128-cbc -in /dev/urandom -pass pass: -e > /dev/null & done && JOBS=\$(jobs -p) && (sleep $durationSeconds && kill \$JOBS) & wait" - MaxLineLength:DistributedServiceTests.kt$DistributedServiceTests$// TODO Use a dummy distributed service rather than a Raft Notary Service as this test is only about Artemis' ability // to handle distributed services @Test fun `requests are distributed evenly amongst the nodes`() - MaxLineLength:DistributedServiceTests.kt$DistributedServiceTests$assertThat(notaryNodes.flatMap { it.nodeInfo.legalIdentities - raftNotaryIdentity }.toSet()).hasSameSizeAs(notaryNodes) - MaxLineLength:DistributedServiceTests.kt$DistributedServiceTests$proxy.stateMachinesFeed().updates.map { Pair(proxy.nodeInfo().legalIdentitiesAndCerts.first().party, it) } MaxLineLength:Distribution.kt$Distribution$throw Exception("Incorrect Artifactory permission. Please set CORDA_ARTIFACTORY_USERNAME and CORDA_ARTIFACTORY_PASSWORD environment variables correctly.") - MaxLineLength:Distribution.kt$Distribution.Companion$val url = URL("https://ci-artifactory.corda.r3cev.com/artifactory/corda-releases/net/corda/corda/$version/corda-$version.jar") MaxLineLength:DockerContainerPusher.kt$DockerContainerPusher$override - MaxLineLength:DockerUtils.kt$DockerUtils$private - MaxLineLength:Driver.kt$ fun <A> driver(defaultParameters: DriverParameters = DriverParameters(), dsl: DriverDSL.() -> A): A - MaxLineLength:Driver.kt$DriverParameters - MaxLineLength:Driver.kt$DriverParameters$@Deprecated("extraCordappPackagesToScan does not preserve the original CorDapp's versioning and metadata, which may lead to " + "misleading results in tests. Use cordappsForAllNodes instead.") - MaxLineLength:Driver.kt$DriverParameters$@Deprecated("extraCordappPackagesToScan does not preserve the original CorDapp's versioning and metadata, which may lead to " + "misleading results in tests. Use withCordappsForAllNodes instead.") MaxLineLength:Driver.kt$DriverParameters$@Deprecated("extraCordappPackagesToScan does not preserve the original CorDapp's versioning and metadata, which may lead to " + "misleading results in tests. Use withCordappsForAllNodes instead.") fun withExtraCordappPackagesToScan(extraCordappPackagesToScan: List<String>): DriverParameters - MaxLineLength:Driver.kt$DriverParameters$constructor(cordappsForAllNodes: Collection<TestCordapp>) : this(isDebug = false, cordappsForAllNodes = cordappsForAllNodes) MaxLineLength:Driver.kt$DriverParameters$fun withCordappsForAllNodes(cordappsForAllNodes: Collection<TestCordapp>?): DriverParameters - MaxLineLength:Driver.kt$DriverParameters$fun withDebugPortAllocation(debugPortAllocation: PortAllocation): DriverParameters - MaxLineLength:Driver.kt$DriverParameters$fun withNetworkParameters(networkParameters: NetworkParameters): DriverParameters MaxLineLength:Driver.kt$DriverParameters$fun withNotaryCustomOverrides(notaryCustomOverrides: Map<String, Any?>): DriverParameters - MaxLineLength:Driver.kt$DriverParameters$fun withStartNodesInProcess(startNodesInProcess: Boolean): DriverParameters - MaxLineLength:Driver.kt$DriverParameters$fun withSystemProperties(systemProperties: Map<String, String>): DriverParameters MaxLineLength:Driver.kt$DriverParameters$fun withWaitForAllNodesToFinish(waitForAllNodesToFinish: Boolean): DriverParameters MaxLineLength:Driver.kt$InProcess$ fun <T> startFlow(logic: FlowLogic<T>): CordaFuture<T> - MaxLineLength:Driver.kt$JmxPolicy MaxLineLength:Driver.kt$JmxPolicy$@Deprecated("The default constructor does not turn on monitoring. Simply leave the jmxPolicy parameter unspecified if you wish to not " + "have monitoring turned on.") - MaxLineLength:DriverDSL.kt$DriverDSL$ fun startNode( defaultParameters: NodeParameters = NodeParameters(), providedName: CordaX500Name? = defaultParameters.providedName, rpcUsers: List<User> = defaultParameters.rpcUsers, verifierType: VerifierType = defaultParameters.verifierType, customOverrides: Map<String, Any?> = defaultParameters.customOverrides, startInSameProcess: Boolean? = defaultParameters.startInSameProcess, maximumHeapSize: String = defaultParameters.maximumHeapSize ): CordaFuture<NodeHandle> - MaxLineLength:DriverDSLImpl.kt$CompatibilityZoneParams - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$ private fun startOutOfProcessMiniNode(config: NodeConfig, vararg extraCmdLineFlag: String): CordaFuture<Unit> - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$/** * Future which completes when the network map infrastructure is available, whether a local one or one from the CZ. * This future acts as a gate to prevent nodes from starting too early. The value of the future is a [LocalNetworkMap] * object, which is null if the network map is being provided by the CZ. */ private lateinit var networkMapAvailability: CordaFuture<LocalNetworkMap?> - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$LocalNetworkMap - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$NodeConfig MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$NodeConfiguration::rpcUsers.name to if (users.isEmpty()) defaultRpcUserList else users.map { it.toConfig().root().unwrapped() } MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$NodeParameters(rpcUsers = spec.rpcUsers, verifierType = spec.verifierType, customOverrides = notaryConfig + customOverrides, maximumHeapSize = spec.maximumHeapSize) - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$NodeParameters(rpcUsers = spec.rpcUsers, verifierType = spec.verifierType, customOverrides = notaryConfig(clusterAddress)) MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$NodeParameters(rpcUsers = spec.rpcUsers, verifierType = spec.verifierType, customOverrides = notaryConfig(nodeAddress, clusterAddress)) - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$OutOfProcessImpl(rpc.nodeInfo(), rpc, config.corda, webAddress, useHTTPS, debugPort, process, onNodeExit) - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$_executorService = Executors.newScheduledThreadPool(2, ThreadFactoryBuilder().setNameFormat("driver-pool-thread-%d").build()) MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$_notaries.map { notary -> notary.map { handle -> handle.nodeHandles } }.getOrThrow(notaryHandleTimeout).forEach { future -> future.getOrThrow(notaryHandleTimeout) } - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$fun notaryConfig(nodeAddress: NetworkHostAndPort, clusterAddress: NetworkHostAndPort? = null): Map<String, Any> - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$override - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$p2pAddress: NetworkHostAndPort = portAllocation.nextHostAndPort() - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$paths.filter { it.fileName.toString().startsWith(NodeInfoFilesCopier.NODE_INFO_FILE_NAME_PREFIX) }.findFirst().get() MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$private - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$return (0 until spec.cluster!!.clusterSize).map { spec.name.copy(organisation = "${spec.name.organisation}-$it") } - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$startNodeRegistration(name, compatibilityZone.rootCert, compatibilityZone.config(), parameters.customOverrides) - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$val client = OkHttpClient.Builder().connectTimeout(5, TimeUnit.SECONDS).readTimeout(60, TimeUnit.SECONDS).build() MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$val flowOverrideConfig = FlowOverrideConfig(parameters.flowOverrides.map { FlowOverride(it.key.canonicalName, it.value.canonicalName) }) MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$val jdbcUrl = "jdbc:h2:mem:persistence${inMemoryCounter.getAndIncrement()};DB_CLOSE_ON_EXIT=FALSE;LOCK_TIMEOUT=10000;WRITE_DELAY=100" - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$val name = parameters.providedName ?: CordaX500Name("${oneOf(names).organisation}-${p2pAddress.port}", "London", "GB") - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$val nodeInfo = Node(config.corda, MOCK_VERSION_INFO, initialiseSerialization = false).generateAndSaveNodeInfo() - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$val process = startOutOfProcessNode(config, quasarJarPath, debugPort, systemProperties, parameters.maximumHeapSize) - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl$val processDeathFuture = poll(executorService, "process death while waiting for RPC (${config.corda.myLegalName})") { if (process.isAlive) null else process } - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl${ // If no CZ is specified then the driver does the generation of the network parameters and the copying of the // node info files. startNotaryIdentityGeneration().map { notaryInfos -> Pair(notaryInfos, LocalNetworkMap(notaryInfos)) } } - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl${ // In this case we're dealing with the the RPCDriver or one of it's cousins which are internal and we don't care about them emptyList() } - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl${ // Otherwise it's the CZ's job to distribute thse via the HTTP network map, as that is what the nodes will be expecting. val notaryInfosFuture = if (compatibilityZone.rootCert == null) { // No root cert specified so we use the dev root cert to generate the notary identities. startNotaryIdentityGeneration() } else { // With a root cert specified we delegate generation of the notary identities to the CZ. startAllNotaryRegistrations(compatibilityZone.rootCert, compatibilityZone) } notaryInfosFuture.map { notaryInfos -> compatibilityZone.publishNotaries(notaryInfos) Pair(notaryInfos, null) } } - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$ private fun Map<String, Any>.removeResolvedClasspath(): Map<String, Any> - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$"com.fasterxml**;com.google**;com.ibm**;com.intellij**;com.jcabi**;com.nhaarman**;com.opengamma**;" - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$"com.lmax**;picocli**;liquibase**;com.github.benmanes**;org.json**;org.postgresql**;nonapi.io.github.classgraph**;)" - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$"com.typesafe**;com.zaxxer**;de.javakaffee**;groovy**;groovyjarjarantlr**;groovyjarjarasm**;io.atomix**;" - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$"io.github**;io.netty**;jdk**;joptsimple**;junit**;kotlin**;net.bytebuddy**;net.i2p**;org.apache**;" - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$"org.assertj**;org.bouncycastle**;org.codehaus**;org.crsh**;org.dom4j**;org.fusesource**;org.h2**;" - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$"org.hamcrest**;org.hibernate**;org.jboss**;org.jcp**;org.joda**;org.junit**;org.mockito**;org.objectweb**;" - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$/** * A sub-set of permissions that grant most of the essential operations used in the unit/integration tests as well as * in demo application like NodeExplorer. */ @Suppress("DEPRECATION") private val DRIVER_REQUIRED_PERMISSIONS = setOf( Permissions.invokeRpc(CordaRPCOps::nodeInfo), Permissions.invokeRpc(CordaRPCOps::networkMapFeed), Permissions.invokeRpc(CordaRPCOps::networkMapSnapshot), Permissions.invokeRpc(CordaRPCOps::notaryIdentities), Permissions.invokeRpc(CordaRPCOps::stateMachinesFeed), Permissions.invokeRpc(CordaRPCOps::stateMachineRecordedTransactionMappingFeed), Permissions.invokeRpc(CordaRPCOps::nodeInfoFromParty), Permissions.invokeRpc(CordaRPCOps::internalVerifiedTransactionsFeed), Permissions.invokeRpc(CordaRPCOps::internalFindVerifiedTransaction), Permissions.invokeRpc("vaultQueryBy"), Permissions.invokeRpc("vaultTrackBy"), Permissions.invokeRpc(CordaRPCOps::registeredFlows), Permissions.invokeRpc(CordaRPCOps::killFlow) ) - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$exclude.any { token -> cpEntry.contains("${File.separatorChar}$token") } || cpEntry.endsWith("-tests.jar") - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$log.info("Starting out-of-process Node ${config.corda.myLegalName.organisation}, debug port is " + (debugPort ?: "not enabled")) MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$private operator fun Config.plus(property: Pair<String, Any>) - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$private val defaultRpcUserList = listOf(InternalUser("default", "default", setOf("ALL")).toConfig().root().unwrapped()) - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$throw IllegalStateException("No quasar agent: -javaagent:lib/quasar.jar and working directory project root might fix") - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion$val excludePattern = "x(antlr**;bftsmart**;ch**;co.paralleluniverse**;com.codahale**;com.esotericsoftware**;" + "com.fasterxml**;com.google**;com.ibm**;com.intellij**;com.jcabi**;com.nhaarman**;com.opengamma**;" + "com.typesafe**;com.zaxxer**;de.javakaffee**;groovy**;groovyjarjarantlr**;groovyjarjarasm**;io.atomix**;" + "io.github**;io.netty**;jdk**;joptsimple**;junit**;kotlin**;net.bytebuddy**;net.i2p**;org.apache**;" + "org.assertj**;org.bouncycastle**;org.codehaus**;org.crsh**;org.dom4j**;org.fusesource**;org.h2**;" + "org.hamcrest**;org.hibernate**;org.jboss**;org.jcp**;org.joda**;org.junit**;org.mockito**;org.objectweb**;" + "org.objenesis**;org.slf4j**;org.w3c**;org.xml**;org.yaml**;reflectasm**;rx**;org.jolokia**;" + "com.lmax**;picocli**;liquibase**;com.github.benmanes**;org.json**;org.postgresql**;nonapi.io.github.classgraph**;)" MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.Companion${ log.info("Starting out-of-process Node ${config.corda.myLegalName.organisation}, debug port is " + (debugPort ?: "not enabled")) // Write node.conf writeConfig(config.corda.baseDirectory, "node.conf", config.typesafe.toNodeOnly()) val systemProperties = mutableMapOf( "name" to config.corda.myLegalName, "visualvm.display.name" to "corda-${config.corda.myLegalName}" ) debugPort?.let { systemProperties += "log4j2.level" to "debug" systemProperties += "log4j2.debug" to "true" } systemProperties += inheritFromParentProcess() systemProperties += overriddenSystemProperties // See experimental/quasar-hook/README.md for how to generate. val excludePattern = "x(antlr**;bftsmart**;ch**;co.paralleluniverse**;com.codahale**;com.esotericsoftware**;" + "com.fasterxml**;com.google**;com.ibm**;com.intellij**;com.jcabi**;com.nhaarman**;com.opengamma**;" + "com.typesafe**;com.zaxxer**;de.javakaffee**;groovy**;groovyjarjarantlr**;groovyjarjarasm**;io.atomix**;" + "io.github**;io.netty**;jdk**;joptsimple**;junit**;kotlin**;net.bytebuddy**;net.i2p**;org.apache**;" + "org.assertj**;org.bouncycastle**;org.codehaus**;org.crsh**;org.dom4j**;org.fusesource**;org.h2**;" + "org.hamcrest**;org.hibernate**;org.jboss**;org.jcp**;org.joda**;org.junit**;org.mockito**;org.objectweb**;" + "org.objenesis**;org.slf4j**;org.w3c**;org.xml**;org.yaml**;reflectasm**;rx**;org.jolokia**;" + "com.lmax**;picocli**;liquibase**;com.github.benmanes**;org.json**;org.postgresql**;nonapi.io.github.classgraph**;)" val extraJvmArguments = systemProperties.removeResolvedClasspath().map { "-D${it.key}=${it.value}" } + "-javaagent:$quasarJarPath=$excludePattern" val loggingLevel = if (debugPort == null) "INFO" else "DEBUG" val arguments = mutableListOf( "--base-directory=${config.corda.baseDirectory}", "--logging-level=$loggingLevel", "--no-local-shell").also { it += extraCmdLineFlag }.toList() // The following dependencies are excluded from the classpath of the created JVM, so that the environment resembles a real one as close as possible. // These are either classes that will be added as attachments to the node (i.e. samples, finance, opengamma etc.) or irrelevant testing libraries (test, corda-mock etc.). // TODO: There is pending work to fix this issue without custom blacklisting. See: https://r3-cev.atlassian.net/browse/CORDA-2164. val exclude = listOf("samples", "finance", "integrationTest", "test", "corda-mock", "com.opengamma.strata") val cp = ProcessUtilities.defaultClassPath.filterNot { cpEntry -> exclude.any { token -> cpEntry.contains("${File.separatorChar}$token") } || cpEntry.endsWith("-tests.jar") } return ProcessUtilities.startJavaProcess( className = "net.corda.node.Corda", // cannot directly get class for this, so just use string arguments = arguments, jdwpPort = debugPort, extraJvmArguments = extraJvmArguments, workingDirectory = config.corda.baseDirectory, maximumHeapSize = maximumHeapSize, classPath = cp ) } - MaxLineLength:DriverDSLImpl.kt$DriverDSLImpl.LocalNetworkMap$// TODO: this object will copy NodeInfo files from started nodes to other nodes additional-node-infos/ // This uses the FileSystem and adds a delay (~5 seconds) given by the time we wait before polling the file system. // Investigate whether we can avoid that. val nodeInfosCopier = NodeInfoFilesCopier().also { shutdownManager.registerShutdown(it::close) } MaxLineLength:DriverDSLImpl.kt$InternalDriverDSL$ fun <A> pollUntilNonNull(pollName: String, pollInterval: Duration = DEFAULT_POLL_INTERVAL, warnCount: Int = DEFAULT_WARN_COUNT, check: () -> A?): CordaFuture<A> MaxLineLength:DriverDSLImpl.kt$InternalDriverDSL$ fun pollUntilTrue(pollName: String, pollInterval: Duration = DEFAULT_POLL_INTERVAL, warnCount: Int = DEFAULT_WARN_COUNT, check: () -> Boolean): CordaFuture<Unit> MaxLineLength:DriverDSLImpl.kt$fun DriverDSL.startNode(providedName: CordaX500Name, devMode: Boolean, parameters: NodeParameters = NodeParameters()): CordaFuture<NodeHandle> - MaxLineLength:DriverInternal.kt$NodeHandleInternal$override val jmxAddress: NetworkHostAndPort? get() = configuration.jmxMonitoringHttpPort?.let { NetworkHostAndPort("localhost", it) } - MaxLineLength:DriverTests.kt$DriverTests$driver - MaxLineLength:DriverTests.kt$DriverTests$newNode(CordaX500Name(commonName = "Notary", organisation = "R3CEV", locality = "New York", country = "US"))().getOrThrow() MaxLineLength:DriverTests.kt$DriverTests$newNode(CordaX500Name(commonName = "Regulator", organisation = "R3CEV", locality = "New York", country = "US"))().getOrThrow() MaxLineLength:DriverTests.kt$DriverTests$val logFile = (baseDirectory / NodeStartup.LOGS_DIRECTORY_NAME).list { it.filter { a -> a.isRegularFile() && a.fileName.toString().startsWith("node") }.findFirst().get() } - MaxLineLength:DriverTests.kt$DriverTests${ // Based on local testing, running this 3 times gives us a high confidence that we'll spot if the feature is not working repeat(3) { driver(DriverParameters(startNodesInProcess = true)) { val bob = startNode(providedName = BOB_NAME).getOrThrow() assertThat(bob.rpc.networkMapSnapshot().flatMap { it.legalIdentities }).contains(defaultNotaryIdentity) } } } MaxLineLength:DummyContract.kt$DummyContract.Companion$ @JvmStatic fun generateInitial(magicNumber: Int, notary: Party, owner: PartyAndReference, vararg otherOwners: PartyAndReference): TransactionBuilder MaxLineLength:DummyContract.kt$DummyContract.Companion$StateAndContract(SingleOwnerState(magicNumber, owners.first().party), PROGRAM_ID) MaxLineLength:DummyContract.kt$DummyContract.Companion$TransactionBuilder(notary).withItems(StateAndContract(state, PROGRAM_ID), Command(Commands.Create(), owners.map { it.party.owningKey })) MaxLineLength:DummyContract.kt$DummyContract.Companion$val items = arrayOf(StateAndContract(SingleOwnerState(magicNumber, owners.first().party), PROGRAM_ID), Command(Commands.Create(), owners.first().party.owningKey), StateAndContract(SingleOwnerState(magicNumber, owners.first().party), PROGRAM_ID), Command(Commands.Create(), owners.first().party.owningKey)) - MaxLineLength:DummyContract.kt$DummyContract.SingleOwnerState$data MaxLineLength:DummyDealStateSchemaV1.kt$DummyDealStateSchemaV1 : MappedSchema MaxLineLength:DummyDealStateSchemaV1.kt$DummyDealStateSchemaV1.PersistentDummyDealState$@CollectionTable(name = "dummy_deal_states_parts", joinColumns = [(JoinColumn(name = "output_index", referencedColumnName = "output_index")), (JoinColumn(name = "transaction_id", referencedColumnName = "transaction_id"))]) MaxLineLength:DummyFungibleContract.kt$DummyFungibleContract$"for reference ${issuer.reference} at issuer ${issuer.party} the amounts balance: ${inputAmount.quantity} - ${amountExitingLedger.quantity} != ${outputAmount.quantity}" - MaxLineLength:DummyFungibleContract.kt$DummyFungibleContract$override MaxLineLength:DummyFungibleContract.kt$DummyFungibleContract$val exitCommand = tx.commands.select<Commands.Exit>(parties = null, signers = exitKeys).singleOrNull { it.value.amount.token == key } - MaxLineLength:DummyFungibleContract.kt$DummyFungibleContract$val inputAmount = inputs.sumCashOrNull() ?: throw IllegalArgumentException("there is at least one input for this group") - MaxLineLength:DummyFungibleContract.kt$DummyFungibleContract.State$override MaxLineLength:DummyIssueAndMove.kt$DummyIssueAndMove : FlowLogic - MaxLineLength:DummyLinearContract.kt$DummyLinearContract.State$override fun supportedSchemas(): Iterable<MappedSchema> MaxLineLength:DummyLinearStateSchemaV1.kt$DummyLinearStateSchemaV1 : MappedSchema MaxLineLength:DummyLinearStateSchemaV1.kt$DummyLinearStateSchemaV1.PersistentDummyLinearState$@Table(name = "dummy_linear_states", indexes = [Index(name = "external_id_idx", columnList = "external_id"), Index(name = "uuid_idx", columnList = "uuid")]) MaxLineLength:DummyLinearStateSchemaV2.kt$DummyLinearStateSchemaV2.PersistentDummyLinearState$@CollectionTable(name = "dummy_linear_states_v2_parts", joinColumns = [(JoinColumn(name = "output_index", referencedColumnName = "output_index")), (JoinColumn(name = "transaction_id", referencedColumnName = "transaction_id"))]) - MaxLineLength:DumpHistoryOnErrorInterceptor.kt$DumpHistoryOnErrorInterceptor$val (continuation, nextState) = delegate.executeTransition(fiber, previousState, event, transition, actionExecutor) MaxLineLength:DumpHistoryOnErrorInterceptor.kt$DumpHistoryOnErrorInterceptor$val transitionRecord = TransitionDiagnosticRecord(Instant.now(), fiber.id, previousState, nextState, event, transition, continuation) - MaxLineLength:DumpHistoryOnErrorInterceptor.kt$DumpHistoryOnErrorInterceptor${ val (continuation, nextState) = delegate.executeTransition(fiber, previousState, event, transition, actionExecutor) val transitionRecord = TransitionDiagnosticRecord(Instant.now(), fiber.id, previousState, nextState, event, transition, continuation) val record = records.compute(fiber.id) { _, record -> (record ?: ArrayList()).apply { add(transitionRecord) } } // Just if we decide to propagate, and not if just on the way to the hospital. Only log at debug level here - the flow transition // information is often unhelpful in the logs, and the actual cause of the problem will be logged elsewhere. if (nextState.checkpoint.errorState is ErrorState.Errored && nextState.checkpoint.errorState.propagating) { log.warn("Flow ${fiber.id} errored, dumping all transitions:\n${record!!.joinToString("\n")}") for (error in nextState.checkpoint.errorState.errors) { log.warn("Flow ${fiber.id} error", error.exception) } } if (nextState.isRemoved) { records.remove(fiber.id) } return Pair(continuation, nextState) } MaxLineLength:DurationSerializer.kt$DurationSerializer : Proxy MaxLineLength:E2ETestKeyManagementService.kt$E2ETestKeyManagementService : SingletonSerializeAsTokenKeyManagementServiceInternal - MaxLineLength:E2ETestKeyManagementService.kt$E2ETestKeyManagementService$getPrivateKey((privateKey as AliasPrivateKey).alias, cryptoService.certificateStore.entryPassword) - MaxLineLength:E2ETestKeyManagementService.kt$E2ETestKeyManagementService$override - MaxLineLength:E2ETestKeyManagementService.kt$E2ETestKeyManagementService$throw UnsupportedOperationException("This operation is only supported by persistent key management service variants.") - MaxLineLength:EdDSATests.kt$EdDSATests$// Required to implement a custom doSign function, because Corda's Crypto.doSign does not allow empty messages (testVector1). private fun doSign(privateKey: PrivateKey, clearData: ByteArray): ByteArray - MaxLineLength:EdDSATests.kt$EdDSATests$assertEquals(it.signatureOutputHex, doSign(privateKey, it.messageToSignHex.hexToByteArray()).toHex().toLowerCase()) MaxLineLength:EdDSATests.kt$EdDSATests$assertNotEquals(testVectorEd25519ctx.signatureOutputHex, doSign(privateKey, testVectorEd25519ctx.messageToSignHex.hexToByteArray()).toHex().toLowerCase()) - MaxLineLength:EdDSATests.kt$EdDSATests$val privateKey = EdDSAPrivateKey(EdDSAPrivateKeySpec(testVectorEd25519ctx.privateKeyHex.hexToByteArray(), edParams)) - MaxLineLength:EncodingUtils.kt$ fun parsePublicKeyBase58(base58String: String): PublicKey - MaxLineLength:EncodingUtils.kt$net.corda.core.utilities.EncodingUtils.kt MaxLineLength:EnumEvolutionSerializer.kt$EnumEvolutionSerializer$val converted = conversions[enumName] ?: throw AMQPNotSerializableException(type, "No rule to evolve enum constant $type::$enumName") - MaxLineLength:EnumEvolutionSerializer.kt$EnumEvolutionSerializer$val ordinal = ordinals[converted] ?: throw AMQPNotSerializableException(type, "Ordinal not found for enum value $type::$converted") MaxLineLength:EnumEvolvabilityTests.kt$EnumEvolvabilityTests$assertThatThrownBy { SerializationOutput(sf).serialize(C(RejectMultipleRenameFrom.A)) }.isInstanceOf(NotSerializableException::class.java) .hasToString("Unable to serialize/deserialize net.corda.serialization.internal.amqp.EnumEvolvabilityTests\$RejectMultipleRenameFrom: " + "There are multiple transformations from D, which is not allowed") - MaxLineLength:EnumEvolvabilityTests.kt$EnumEvolvabilityTests$assertTrue(envelope.transformsSchema.types[WithUnknownTest::class.java.name]!!.containsKey(TransformTypes.Unknown)) - MaxLineLength:EnumEvolvabilityTests.kt$EnumEvolvabilityTests$val envelope = DeserializationInput(sf).deserializeAndReturnEnvelope(SerializedBytes<WrapsUnknown>(sb1)).envelope - MaxLineLength:EnumSerializer.kt$EnumSerializer : AMQPSerializer MaxLineLength:EnumSetSerializer.kt$EnumSetSerializer : Proxy - MaxLineLength:EnumSetSerializer.kt$EnumSetSerializer$EnumSet.complementOf(uncheckedCast<EnumSet<*>, EnumSet<MapSerializer.EnumJustUsedForCasting>>(set)).first().javaClass - MaxLineLength:EnumTransforms.kt$EnumTransforms$ private fun validateNoCycles(constants: Map<String, Int>) - MaxLineLength:EnumTransforms.kt$EnumTransforms$"Rename chain from $chainStart to $chainEnd does not end with a known constant in ${constants.keys}" - MaxLineLength:EnumTransforms.kt$EnumTransforms$throw InvalidEnumTransformsException("Rename from $from to $to would rename existing constant in $constants.keys") - MaxLineLength:EnumTransforms.kt$EnumTransforms${ if (from in constants) { throw InvalidEnumTransformsException("Rename from $from to $to would rename existing constant in $constants.keys") } // If there is an existing chain, starting at the "to" node of this edge, then there is a chain from this edge's // "from" to that chain's end. val newEnd = chainStartsToEnds[to] ?: to // If there is an existing chain, ending at the "from" node of this edge, then there is a chain from that chain's start // to this edge's "to". val newStart = chainEndsToStarts[from] ?: from // If either chain ends where it begins, we have closed a loop, and detected a cycle. if (newEnd == from || newStart == to) { throw InvalidEnumTransformsException("Rename cycle detected in rename map starting from $newStart") } // Either update, or create, the chains in both directions. chainStartsToEnds[newStart] = newEnd chainEndsToStarts[newEnd] = newStart } MaxLineLength:ErrorCodeLoggingTests.kt$ErrorCodeLoggingTests$val linesWithErrorCode = logFile.useLines { lines -> lines.filter { line -> line.contains("[errorCode=") }.filter { line -> line.contains("moreInformationAt=https://errors.corda.net/") }.toList() } - MaxLineLength:ErrorCodeRewritePolicy.kt$ErrorCodeRewritePolicy$@Plugin(name = "ErrorCodeRewritePolicy", category = Core.CATEGORY_NAME, elementType = "rewritePolicy", printObject = false) MaxLineLength:ErrorFlowTransition.kt$ErrorFlowTransition$val (initiatedSessions, newSessions) = bufferErrorMessagesInInitiatingSessions(startingState.checkpoint.sessions, errorMessages) - MaxLineLength:ErrorMessagesTests.kt$ErrorMessagesTests$"Property '$property' or its getter is non public, this renders class 'class $testname\$C' unserializable -> class $testname\$C" MaxLineLength:ErrorMessagesTests.kt$ErrorMessagesTests$@Ignore("Current behaviour allows for the serialization of objects with private members, this will be disallowed at some point in the future") - MaxLineLength:Event.kt$Event$GeneratedByExternalEvent - MaxLineLength:Event.kt$Event$RetryFlowFromSafePoint : Event MaxLineLength:Event.kt$Event.EnterSubFlow$data MaxLineLength:EventGenerator.kt$ErrorFlowsEventGenerator : EventGenerator MaxLineLength:EventGenerator.kt$ErrorFlowsEventGenerator$private - MaxLineLength:EventGenerator.kt$EventGenerator$open MaxLineLength:EventGenerator.kt$EventGenerator$protected MaxLineLength:EventGenerator.kt$EventGenerator$protected val currencyMap: MutableMap<Currency, Long> = mutableMapOf(USD to 0L, GBP to 0L) // Used for estimation of how much money we have in general. - MaxLineLength:EventProcessor.kt$EventProcessor$val status: DeliveryState = if (completer.status == MessageStatus.Acknowledged) Accepted.getInstance() else Rejected() - MaxLineLength:Eventually.kt$ inline fun <R> eventually( duration: Duration = Duration.ofSeconds(5), waitBetween: Duration = Duration.ofMillis(100), waitBefore: Duration = waitBetween, test: () -> R): R - MaxLineLength:EvolutionSerializerFactory.kt$DefaultEvolutionSerializerFactory$private - MaxLineLength:EvolutionSerializerFactory.kt$DefaultEvolutionSerializerFactory$properties.asSequence().zip(localTypeInformation.properties.values.asSequence()) - MaxLineLength:EvolutionSerializerFactory.kt$DefaultEvolutionSerializerFactory$properties: Map<String, RemotePropertyInformation> - MaxLineLength:EvolutionSerializerFactory.kt$DefaultEvolutionSerializerFactory$return EnumEvolutionSerializer(localTypeInformation.observedType, localSerializerFactory, conversions, localOrdinals) - MaxLineLength:EvolutionSerializerFactory.kt$DefaultEvolutionSerializerFactory$val bestMatchEvolutionConstructor = findEvolverConstructor(localTypeInformation.evolutionConstructors, properties) - MaxLineLength:EvolutionSerializerFactory.kt$DefaultEvolutionSerializerFactory$val convertedOrdinals = remoteOrdinals.asSequence().map { (member, ord) -> ord to conversions[member]!! }.toMap() - MaxLineLength:EvolutionSerializerFactory.kt$DefaultEvolutionSerializerFactory$val localOrdinals = localTypeInformation.members.asSequence().mapIndexed { ord, member -> member to ord }.toMap() - MaxLineLength:EvolutionSerializerFactory.kt$DefaultEvolutionSerializerFactory$val propertyTypes = properties.mapValues { (_, info) -> info.type.typeIdentifier.getLocalType(classLoader).asClass() } - MaxLineLength:EvolutionSerializerFactory.kt$DefaultEvolutionSerializerFactory${ // The no-op case: although the fingerprints don't match for some reason, we have compatible signatures. // This might happen because of inconsistent type erasure, changes to the behaviour of the fingerprinter, // or changes to the type itself - such as adding an interface - that do not change its serialisation/deserialisation // signature. if (propertyNamesMatch(localTypeInformation)) { // Make sure types are assignment-compatible, and return the local serializer for the type. validateCompatibility(localTypeInformation) return null } // Failing that, we have to create an evolution serializer. val bestMatchEvolutionConstructor = findEvolverConstructor(localTypeInformation.evolutionConstructors, properties) val constructorForEvolution = bestMatchEvolutionConstructor?.constructor ?: localTypeInformation.constructor val evolverProperties = bestMatchEvolutionConstructor?.properties ?: localTypeInformation.properties validateEvolvability(evolverProperties) return buildComposableEvolutionSerializer(localTypeInformation, constructorForEvolution, evolverProperties) } - MaxLineLength:EvolutionSerializerFactory.kt$EvolutionSerializerFactory$ fun getEvolutionSerializer( remote: RemoteTypeInformation, local: LocalTypeInformation): AMQPSerializer<Any>? - MaxLineLength:EvolutionSerializerFactoryTests.kt$EvolutionSerializerFactoryTests$val withNonNullTarget = DeserializationInput(nonStrictFactory).deserialize(SerializedBytes<C>(withoutNullUrl.readBytes())) - MaxLineLength:EvolutionSerializerFactoryTests.kt$EvolutionSerializerFactoryTests$val withNullTarget = DeserializationInput(strictFactory).deserialize(SerializedBytes<C>(withNullUrl.readBytes())) - MaxLineLength:EvolvabilityTests.kt$EvolvabilityTests${ val resource = "EvolvabilityTests.evolutionWithCarpentry" val sf = testDefaultFactory() // Uncomment to recreate // File(URI("$localPath/$resource")).writeBytes(SerializationOutput(sf).serialize(Evolved("dronf", NewEnum.BUCKLE_MY_SHOE)).bytes) val url = EvolvabilityTests::class.java.getResource(resource) val sc2 = url.readBytes() val deserialized = DeserializationInput(sf).deserialize(SerializedBytes<Evolved>(sc2)) assertEquals("dronf", deserialized.fnord) } MaxLineLength:EvolvabilityTests.kt$EvolvabilityTests${ val resource = "EvolvabilityTests.evolutionWithPrimitives" val sf = testDefaultFactory() // Uncomment to recreate // File(URI("$localPath/$resource")).writeBytes(SerializationOutput(sf).serialize(ParameterizedContainer(Parameterized(10, setOf(20)))).bytes) val url = EvolvabilityTests::class.java.getResource(resource) val sc2 = url.readBytes() val deserialized = DeserializationInput(sf).deserialize(SerializedBytes<ParameterizedContainer>(sc2)) assertEquals(10, deserialized.parameterized?.a) } - MaxLineLength:EvolvabilityTests.kt$EvolvabilityTests${ val sf = testDefaultFactory() val resource = "EvolvabilityTests.removeParameterWithCalculatedParameter" // Original version of the class as it was serialised // data class CC(val a: Int, val b: String, val c: String, val d: Int) { // @get:SerializableCalculatedProperty // val e: String get() = "$b $c" // } // File(URI("$localPath/$resource")).writeBytes(SerializationOutput(sf).serialize(CC(1, "hello", "world", 2)).bytes) data class CC(val b: String, val d: Int) { @get:SerializableCalculatedProperty val e: String get() = "$b sailor" } val url = EvolvabilityTests::class.java.getResource(resource) val sc2 = url.readBytes() val deserializedCC = DeserializationInput(sf).deserialize(SerializedBytes<CC>(sc2)) assertEquals("hello", deserializedCC.b) assertEquals(2, deserializedCC.d) assertEquals("hello sailor", deserializedCC.e) } - MaxLineLength:ExampleConfigTest.kt$ExampleConfigTest$assertThat(ConfigHelper.loadConfig(baseDirectory = baseDirectory, configFile = it).parseAsNodeConfiguration().isValid).isTrue() - MaxLineLength:Examples.kt$Examples$// maybe in the presence of negative interest rates you would want other side of contract to be able to take initiative as well val zero_coupon_bond_2 = arrange { actions { (acmeCorp or highStreetBank) may { "execute".givenThat(after("2017-09-01")) { highStreetBank.owes(acmeCorp, 1.M, USD) } } } } - MaxLineLength:ExceptionMaskingRpcOpsProxy.kt$ExceptionMaskingRpcOpsProxy$internal - MaxLineLength:ExceptionMaskingRpcOpsProxy.kt$ExceptionMaskingRpcOpsProxy.Companion$return newProxyInstance(delegate::class.java.classLoader, arrayOf(CordaRPCOps::class.java), handler) as CordaRPCOps MaxLineLength:ExceptionMaskingRpcOpsProxy.kt$ExceptionMaskingRpcOpsProxy.ErrorObfuscatingInvocationHandler$private - MaxLineLength:ExceptionMaskingRpcOpsProxy.kt$ExceptionMaskingRpcOpsProxy.ErrorObfuscatingInvocationHandler$val exposed = if (error.isWhitelisted()) error else InternalNodeException((error as? IdentifiableException)?.errorId) - MaxLineLength:ExceptionSerialisingRpcOpsProxy.kt$ExceptionSerialisingRpcOpsProxy$internal - MaxLineLength:ExceptionSerialisingRpcOpsProxy.kt$ExceptionSerialisingRpcOpsProxy.Companion$return newProxyInstance(delegate::class.java.classLoader, arrayOf(CordaRPCOps::class.java), handler) as CordaRPCOps MaxLineLength:ExceptionSerialisingRpcOpsProxy.kt$ExceptionSerialisingRpcOpsProxy.ErrorSerialisingInvocationHandler$private MaxLineLength:ExceptionSerialisingRpcOpsProxy.kt$ExceptionSerialisingRpcOpsProxy.ErrorSerialisingInvocationHandler$val serialisable = (superclasses(error::class.java) + error::class.java).any { it.isAnnotationPresent(CordaSerializable::class.java) || it.interfaces.any { it.isAnnotationPresent(CordaSerializable::class.java) } } MaxLineLength:ExceptionsErrorCodeFunctions.kt$CompositeMessage$private - MaxLineLength:ExceptionsErrorCodeFunctions.kt$cause != null && !visited.contains(cause) -> Objects.hash(*fields, cause.staticLocationBasedHash(hashedFields, visited + cause)) MaxLineLength:ExceptionsErrorCodeFunctions.kt$error != null && level.isInRange(Level.FATAL, Level.WARN) -> CompositeMessage("$formattedMessage [errorCode=${error.errorCode()}, moreInformationAt=${error.errorCodeLocationUrl()}]", format, parameters, throwable) MaxLineLength:ExceptionsErrorCodeFunctions.kt$fun Throwable.errorCodeLocationUrl() MaxLineLength:ExceptionsErrorCodeFunctions.kt$private - MaxLineLength:ExceptionsSerializationTest.kt$ExceptionsSerializationTest - MaxLineLength:ExchangeRateModel.kt$ExchangeRate$ fun exchangeAmount(amount: Amount<Currency>, to: Currency) - MaxLineLength:Expect.kt$ fun <E> parallel(expectations: List<ExpectCompose<E>>): ExpectCompose<E> - MaxLineLength:Expect.kt$ fun <E> parallel(vararg expectations: ExpectCompose<E>): ExpectCompose<E> - MaxLineLength:Expect.kt$ fun <E> sequence(vararg expectations: ExpectCompose<E>): ExpectCompose<E> - MaxLineLength:Expect.kt$/** * Internally we create a "lazy" state automaton. The outgoing edges are state.getExpectedEvents() modulo additional * matching logic. When an event comes we extract the first edge that matches using state.nextState(event), which * returns the next state and the piece of dsl to be run on the event. If nextState() returns null it means the event * didn't match at all, in this case we either fail (if isStrict=true) or carry on with the same state (if isStrict=false) * * TODO Think about pre-compiling the state automaton, possibly introducing regexp constructs. This requires some * thinking, as the [parallel] construct blows up the state space factorially, so we need some clever lazy expansion * of states. */ var state = ExpectComposeState.fromExpectCompose(expectCompose()) - MaxLineLength:Expect.kt$/** * This file defines a simple DSL for testing non-deterministic sequence of events arriving on an [Observable]. * * [sequence] is used to impose ordering invariants on the stream, whereas [parallel] allows events to arrive in any order. * * The only restriction on [parallel] is that we should be able to discriminate which branch to take based on the * arrived event's type and optionally custom matching logic. If this is ambiguous the first matching piece of DSL will * be run. * * [sequence]s and [parallel]s can be nested arbitrarily * * Example usage: * * val stream: Observable<SomeEvent> = (..) * stream.expectEvents { * sequence( * expect { event: SomeEvent.A -> require(event.isOk()) }, * parallel( * expect { event.SomeEvent.B -> }, * expect { event.SomeEvent.C -> } * ) * ) * } * * The above will test our expectation that the stream should first emit an A, and then a B and C in unspecified order. */ private val log: Logger = LoggerFactory.getLogger("Expect") - MaxLineLength:Expect.kt$log.info("$event :: ${expectedStates.map { it.simpleName }} -> ${next?.second?.getExpectedEvents()?.map { it.simpleName }}") - MaxLineLength:Explorer.kt$Explorer${ // Make sure that the explorer has cordapps on its class path. This is only necessary because currently apps // require the original class files to deserialise states: Kryo serialisation doesn't let us write generic // tools that work with serialised data structures. But the AMQP serialisation revamp will fix this by // integrating the class carpenter, so, we can eventually get rid of this function. // // Note: does not copy dependencies because we should soon be making all apps fat jars and dependencies implicit. // // TODO: Remove this code when serialisation has been upgraded. val cordappsDir = config.explorerDir / NodeConfig.CORDAPP_DIR_NAME cordappsDir.createDirectories() config.cordappsDir.list { it.forEachOrdered { path -> val destPath = cordappsDir / path.fileName.toString() try { // Try making a symlink to make things faster and use less disk space. Files.createSymbolicLink(destPath, path) } catch (e: UnsupportedOperationException) { // OS doesn't support symbolic links? path.copyTo(destPath, REPLACE_EXISTING) } catch (e: java.nio.file.FileAlreadyExistsException) { // OK, don't care ... } catch (e: IOException) { // Windows 10 might not allow this user to create a symlink log.warn("Failed to create symlink '{}' for '{}': {}", destPath, path, e.message) path.copyTo(destPath, REPLACE_EXISTING) } } } } - MaxLineLength:ExposeJpaToFlowsTests.kt$ExposeJpaToFlowsTests$FooSchemaV1 : MappedSchema - MaxLineLength:ExposeJpaToFlowsTests.kt$ExposeJpaToFlowsTests.FooSchemaV1$PersistentFoo : Serializable - MaxLineLength:FastThreadLocalTest.kt$FastThreadLocalTest$private - MaxLineLength:FetchDataFlow.kt$FetchAttachmentsFlow$otherSide: FlowSession - MaxLineLength:FetchDataFlow.kt$FetchAttachmentsFlow${ // This can happen when another transaction will insert the same attachment during this transaction. // The outcome is the same (the attachment is imported), so we can ignore this exception. logger.debug { "Attachment ${attachment.id} already inserted." } } MaxLineLength:FetchDataFlow.kt$FetchAttachmentsFlow.FetchedAttachment$private - MaxLineLength:FetchDataFlow.kt$FetchAttachmentsFlow.FetchedAttachment.Token$override fun fromToken(context: SerializeAsTokenContext) MaxLineLength:FetchDataFlow.kt$FetchDataFlow$IllegalTransactionRequest : FlowException - MaxLineLength:FetchDataFlow.kt$FetchDataFlow$MissingNetworkParameters : FlowException - MaxLineLength:FetchDataFlow.kt$FetchDataFlow$logger.debug { "Requesting ${toFetch.size} dependency(s) for verification from ${otherSideSession.counterparty.name}" } - MaxLineLength:FetchDataFlow.kt$FetchDataFlow$maybeItems += otherSideSession.sendAndReceive<List<W>>(Request.Data(NonEmptySet.of(hash), dataType)).unwrap { it } - MaxLineLength:FetchDataFlow.kt$FetchDataFlow${ // We skip the validation here (with unwrap { it }) because we will do it below in validateFetchResponse. // The only thing checked is the object type. It is a protocol violation to send results out of order. // TODO We need to page here after large messages will work. maybeItems += otherSideSession.sendAndReceive<List<W>>(Request.Data(NonEmptySet.of(hash), dataType)).unwrap { it } } - MaxLineLength:FetchDataFlow.kt$FetchNetworkParametersFlow : FetchDataFlow MaxLineLength:FetchDataFlow.kt$FetchNetworkParametersFlow$otherSide: FlowSession MaxLineLength:FetchDataFlow.kt$FetchTransactionsFlow : FetchDataFlow - MaxLineLength:FiberDeserializationCheckingInterceptor.kt$FiberDeserializationCheckingInterceptor$val (continuation, nextState) = delegate.executeTransition(fiber, previousState, event, transition, actionExecutor) MaxLineLength:FiberUtils.kt$// TODO: This method uses a built-in Quasar function to make a map of all ThreadLocals. This is probably inefficient, but the only API readily available. fun <V, T> Fiber<V>.swappedOutThreadLocalValue(threadLocal: ThreadLocal<T>): T? - MaxLineLength:FiberUtils.kt$private val fiberThreadLocalsField: Field = Fiber::class.java.getDeclaredField("fiberLocals").apply { this.isAccessible = true } - MaxLineLength:FinalityFlow.kt$FinalityFlow : FlowLogic - MaxLineLength:FinalityFlow.kt$FinalityFlow$"${session.counterparty} has finished prematurely and we're trying to send them the finalised transaction. " - MaxLineLength:FinalityFlow.kt$FinalityFlow$"Do not provide flow sessions for the local node. FinalityFlow will record the notarised transaction locally." - MaxLineLength:FinalityFlow.kt$FinalityFlow$/** * Notarise the given transaction and broadcast it to all the participants. * * @param transaction What to commit. * @param sessions A collection of [FlowSession]s for each non-local participant of the transaction. Sessions to non-participants can * also be provided. */ @JvmOverloads constructor( transaction: SignedTransaction, sessions: Collection<FlowSession>, progressTracker: ProgressTracker = tracker() ) : this(transaction, emptyList(), progressTracker, sessions, true) - MaxLineLength:FinalityFlow.kt$FinalityFlow$/** * Notarise the given transaction and broadcast it to all the participants. * * @param transaction What to commit. * @param sessions A collection of [FlowSession]s for each non-local participant. * @param oldParticipants An **optional** collection of parties for participants who are still using the old API. * * You will only need to use this parameter if you have upgraded your CorDapp from the V3 FinalityFlow API but are required to provide * backwards compatibility with participants running V3 nodes. If you're writing a new CorDapp then this does not apply and this * parameter should be ignored. */ @Deprecated(DEPRECATION_MSG) constructor( transaction: SignedTransaction, sessions: Collection<FlowSession>, oldParticipants: Collection<Party>, progressTracker: ProgressTracker ) : this(transaction, oldParticipants, progressTracker, sessions, true) MaxLineLength:FinalityFlow.kt$FinalityFlow$@Deprecated(DEPRECATION_MSG) constructor(transaction: SignedTransaction, extraRecipients: Set<Party>) : this(transaction, extraRecipients, tracker(), emptyList(), false) MaxLineLength:FinalityFlow.kt$FinalityFlow$@Deprecated(DEPRECATION_MSG) constructor(transaction: SignedTransaction, progressTracker: ProgressTracker) : this(transaction, emptySet(), progressTracker, emptyList(), false) - MaxLineLength:FinalityFlow.kt$FinalityFlow$if (notary != null) transaction.verifySignaturesExcept(notary.owningKey) else transaction.verifyRequiredSignatures() - MaxLineLength:FinalityFlow.kt$FinalityFlow$logger - MaxLineLength:FinalityFlow.kt$FinalityFlow$require(it.isEmpty()) { "The following parties are specified both in flow sessions and in the oldParticipants list: $it" } - MaxLineLength:FinalityFlow.kt$FinalityFlow$val commandDataTypes = transaction.tx.commands.asSequence().mapNotNull { it.value::class.qualifiedName }.distinct() - MaxLineLength:FinalityFlow.kt$FinalityFlow.Companion$"accept notarised transactions without first checking their relevancy. Instead, use one of the constructors " - MaxLineLength:FinalityFlow.kt$FinalityFlow.Companion$private const - MaxLineLength:FinalityFlow.kt$ReceiveFinalityFlow : FlowLogic MaxLineLength:FinalityFlow.kt$ReceiveFinalityFlow$private val statesToRecord: StatesToRecord = ONLY_RELEVANT MaxLineLength:FinalityFlow.kt$ReceiveFinalityFlow$return subFlow(object : ReceiveTransactionFlow(otherSideSession, checkSufficientSignatures = true, statesToRecord = statesToRecord) { override fun checkBeforeRecording(stx: SignedTransaction) { require(expectedTxId == null || expectedTxId == stx.id) { "We expected to receive transaction with ID $expectedTxId but instead got ${stx.id}. Transaction was" + "not recorded and nor its states sent to the vault." } } }) - MaxLineLength:FinalityFlow.kt$ReceiveFinalityFlow.<no name provided>$"We expected to receive transaction with ID $expectedTxId but instead got ${stx.id}. Transaction was" - MaxLineLength:FinalityFlowMigration.kt$ExistingInitiatingFlow : FlowLogic - MaxLineLength:FinalityFlowMigration.kt$ExistingInitiatingFlow${ // Otherwise they're at least on version 2 and so we can send the finalised transaction on the existing session. subFlow(FinalityFlow(fullySignedTx, session)) } - MaxLineLength:FinalityFlowMigration.kt$ExistingResponderFlow${ // The other side is not using the old CorDapp so call ReceiveFinalityFlow to record the finalised transaction. // If SignTransactionFlow is used then we can verify the tranaction we receive for recording is the same one // that was just signed. subFlow(ReceiveFinalityFlow(otherSide, expectedTxId = txWeJustSigned.id)) } - MaxLineLength:FinalityFlowTests.kt$FinalityFlowTests$override val mockNet = InternalMockNetwork(cordappsForAllNodes = listOf(FINANCE_CONTRACTS_CORDAPP, enclosedCordapp())) - MaxLineLength:FinalityHandlerTest.kt$FinalityHandlerTest$( legalName = BOB_NAME, // The node disables the FinalityHandler completely if there are no old CorDapps loaded, so we need to add // a token old CorDapp to keep the handler running. additionalCordapps = setOf(DUMMY_CONTRACTS_CORDAPP.copy(targetPlatformVersion = 3)) ) - MaxLineLength:FinalityHandlerTest.kt$FinalityHandlerTest$val alice = mockNet.createNode(InternalMockNodeParameters(legalName = ALICE_NAME, additionalCordapps = FINANCE_CORDAPPS)) - MaxLineLength:FinalityHandlerTest.kt$FinalityHandlerTest${ // Setup a network where only Alice has the finance CorDapp and it sends a cash tx to Bob who doesn't have the // CorDapp. Bob's FinalityHandler will error when validating the tx. val alice = mockNet.createNode(InternalMockNodeParameters(legalName = ALICE_NAME, additionalCordapps = FINANCE_CORDAPPS)) var bob = mockNet.createNode(InternalMockNodeParameters( legalName = BOB_NAME, // The node disables the FinalityHandler completely if there are no old CorDapps loaded, so we need to add // a token old CorDapp to keep the handler running. additionalCordapps = setOf(DUMMY_CONTRACTS_CORDAPP.copy(targetPlatformVersion = 3)) )) val stx = alice.issueCashTo(bob) val finalityHandlerId = bob.trackFinalityHandlerId().run { alice.finaliseWithOldApi(stx) getOrThrow() } bob.assertFlowSentForObservationDueToConstraintError(finalityHandlerId) assertThat(bob.getTransaction(stx.id)).isNull() bob = mockNet.restartNode(bob) // Since we've not done anything to fix the orignal error, we expect the finality handler to be sent to the hospital // again on restart bob.assertFlowSentForObservationDueToConstraintError(finalityHandlerId) assertThat(bob.getTransaction(stx.id)).isNull() } MaxLineLength:FinanceJSONSupport.kt$CalendarDeserializer$StringArrayDeserializer.instance.deserialize(parser, context).fold(BusinessCalendar.EMPTY) { acc, name -> acc + loadTestCalendar(name) } - MaxLineLength:FinanceJSONSupport.kt$ExpressionSerializer$override fun serialize(expr: Expression, generator: JsonGenerator, provider: SerializerProvider) - MaxLineLength:FinanceTypes.kt$DateRollConvention - MaxLineLength:FinanceTypes.kt$DealState$ fun generateAgreement(notary: Party): TransactionBuilder - MaxLineLength:FinanceTypes.kt$Tenor$return BusinessCalendar.calculateDaysBetween(startDate, adjustedMaturityDate, DayCountBasisYear.Y360, DayCountBasisDay.DActual) - MaxLineLength:FinanceTypes.kt$Tenor$val match = regex.matchEntire(name)?.groupValues ?: throw IllegalArgumentException("Unrecognised tenor name: $name") - MaxLineLength:FinanceTypesTest.kt$FinanceTypesTest$exampleTenors.all { Tenor(it).name.isNotEmpty() } MaxLineLength:FinanceTypesTest.kt$FinanceTypesTest$val ret = BusinessCalendar.createGenericSchedule(startDate = LocalDate.of(2014, 11, 25), period = Frequency.Monthly, noOfAdditionalPeriods = 3) - MaxLineLength:FinanceWorkflowsUtils.kt$BusinessCalendar(stream.reader().readText().split(",").map { BusinessCalendar.parseDateFromString(it) }.toSortedSet()) MaxLineLength:FinanceWorkflowsUtils.kt$val stream = UnknownCalendar::class.java.getResourceAsStream("net/corda/finance/workflows/utils/${name}HolidayCalendar.txt") ?: throw UnknownCalendar(name) - MaxLineLength:FingerPrinterTesting.kt$FingerPrinterTestingTests$val customSerializerRegistry: CustomSerializerRegistry = CachingCustomSerializerRegistry(descriptorBasedSerializerRegistry) - MaxLineLength:FingerPrinterTesting.kt$FingerPrinterTestingTests$val typeModel = ConfigurableLocalTypeModel(WhitelistBasedTypeModelConfiguration(AllWhitelist, customSerializerRegistry)) MaxLineLength:FixingFlow.kt$FixingFlow.Fixer$@Suspendable override - MaxLineLength:FixingFlow.kt$FixingFlow.Fixer$override - MaxLineLength:FixingFlow.kt$FixingFlow.Fixer$val addFixing = object : RatesFixFlow(ptx, handshake.payload.oracle, fixOf, BigDecimal.ZERO, BigDecimal.ONE) { @Suspendable override fun beforeSigning(fix: Fix) { newDeal.generateFix(ptx, StateAndRef(txState, handshake.payload.ref), fix) // We set the transaction's time-window: it may be that none of the contracts need this! // But it can't hurt to have one. ptx.setTimeWindow(serviceHub.clock.instant(), 30.seconds) } @Suspendable override fun filtering(elem: Any): Boolean { return when (elem) { // Only expose Fix commands in which the oracle is on the list of requested signers // to the oracle node, to avoid leaking privacy is Command<*> -> handshake.payload.oracle.owningKey in elem.signers && elem.value is Fix else -> false } } } MaxLineLength:FixingFlow.kt$FixingFlow.FixingRoleDecider$val counterparty = serviceHub.identityService.wellKnownPartyFromAnonymous(parties[1]) ?: throw IllegalStateException("Cannot resolve floater party") - MaxLineLength:FixingFlow.kt$FixingFlow.Floater$override val progressTracker: ProgressTracker = TwoPartyDealFlow.Primary.tracker() - MaxLineLength:FlattenedList.kt$FlattenedList${ // TODO this assumes that if wasAdded() == true then we are adding elements to the getFrom() position val removeStart = c.from val removeRange = c.removed.size val removeEnd = c.from + removeRange val iterator = indexMap.iterator() for (entry in iterator) { val (wrapped, pair) = entry val (index, listener) = pair if (index >= removeStart) { if (index < removeEnd) { wrapped.observableValue.removeListener(listener) iterator.remove() } else { // Shift indices entry.setValue(Pair(index - removeRange, listener)) } } } nextRemove(removeStart, removed.map { it.value }) } MaxLineLength:FlattenedList.kt$FlattenedList<A> : TransformationList - MaxLineLength:FlowAsyncOperationTests.kt$FlowAsyncOperationTests.WorkerServiceTask$private MaxLineLength:FlowCheckpointCordapp.kt$SendMessageFlow : FlowLogic - MaxLineLength:FlowCheckpointCordapp.kt$SendMessageFlow$val txBuilder = TransactionBuilder(notary).withItems(StateAndContract(messageState, MESSAGE_CONTRACT_PROGRAM_ID), txCommand) - MaxLineLength:FlowCheckpointCordapp.kt$SendMessageFlow.Companion$fun tracker() - MaxLineLength:FlowCheckpointVersionNodeStartupCheckTest.kt$FlowCheckpointVersionNodeStartupCheckTest$( // The part of the log message generated by CheckpointIncompatibleException.FlowVersionIncompatibleException "that is incompatible with the current installed version of" ) - MaxLineLength:FlowCheckpointVersionNodeStartupCheckTest.kt$FlowCheckpointVersionNodeStartupCheckTest$assertThat(defaultCordapp.jarFile.hash).isNotEqualTo(modifiedCordapp.jarFile.hash) - MaxLineLength:FlowCheckpointVersionNodeStartupCheckTest.kt$FlowCheckpointVersionNodeStartupCheckTest$bob.rpc.stateMachinesFeed().let { it.updates.map { it.id }.startWith(it.snapshot.map { it.id }) }.toBlocking().first() - MaxLineLength:FlowCookbook.kt$InitiatorFlow : FlowLogic MaxLineLength:FlowCookbook.kt$InitiatorFlow$val fullySignedTx: SignedTransaction = subFlow(CollectSignaturesFlow(twiceSignedTx, setOf(counterpartySession, regulatorSession), SIGS_GATHERING.childProgressTracker())) MaxLineLength:FlowCookbook.kt$InitiatorFlow$val notarisedTx1: SignedTransaction = subFlow(FinalityFlow(fullySignedTx, listOf(counterpartySession), FINALISATION.childProgressTracker())) - MaxLineLength:FlowCookbook.kt$InitiatorFlow$val notarisedTx2: SignedTransaction = subFlow(FinalityFlow(fullySignedTx, partySessions, FINALISATION.childProgressTracker())) - MaxLineLength:FlowCookbook.kt$InitiatorFlow$val otherIdentity2: PartyAndCertificate = serviceHub.keyManagementService.freshKeyAndCert(ourIdentityAndCert, false) - MaxLineLength:FlowCookbook.kt$InitiatorFlow$val otherIdentity: PartyAndCertificate = serviceHub.keyManagementService.freshKeyAndCert(ourIdentityAndCert, false) - MaxLineLength:FlowCookbook.kt$InitiatorFlow$val packet2: UntrustworthyData<Boolean> = counterpartySession.sendAndReceive<Boolean>("You can send and receive any class!") - MaxLineLength:FlowCookbook.kt$InitiatorFlow$val txState: TransactionState<DummyState> = TransactionState(ourOutputState, DummyContract.PROGRAM_ID, specificNotary) - MaxLineLength:FlowCookbook.kt$ResponderFlow${ // The ``ResponderFlow` has all the same APIs available. It looks // up network information, sends and receives data, and constructs // transactions in exactly the same way. /**----------------------------- * SENDING AND RECEIVING DATA * -----------------------------**/ progressTracker.currentStep = RECEIVING_AND_SENDING_DATA // We need to respond to the messages sent by the initiator: // 1. They sent us an ``Any`` instance // 2. They waited to receive an ``Integer`` instance back // 3. They sent a ``String`` instance and waited to receive a // ``Boolean`` instance back // Our side of the flow must mirror these calls. // DOCSTART 08 val any: Any = counterpartySession.receive<Any>().unwrap { data -> data } val string: String = counterpartySession.sendAndReceive<String>(99).unwrap { data -> data } counterpartySession.send(true) // DOCEND 08 /**---------------------------------------- * RESPONDING TO COLLECT_SIGNATURES_FLOW * ----------------------------------------**/ progressTracker.currentStep = SIGNING // The responder will often need to respond to a call to // ``CollectSignaturesFlow``. It does so my invoking its own // ``SignTransactionFlow`` subclass. // DOCSTART 16 val signTransactionFlow: SignTransactionFlow = object : SignTransactionFlow(counterpartySession) { override fun checkTransaction(stx: SignedTransaction) = requireThat { // Any additional checking we see fit... val outputState = stx.tx.outputsOfType<DummyState>().single() require(outputState.magicNumber == 777) } } val idOfTxWeSigned = subFlow(signTransactionFlow).id // DOCEND 16 /**----------------------------- * FINALISING THE TRANSACTION * -----------------------------**/ progressTracker.currentStep = FINALISATION // As the final step the responder waits to receive the notarised transaction from the sending party // Since it knows the ID of the transaction it just signed, the transaction ID is specified to ensure the correct // transaction is received and recorded. // DOCSTART ReceiveFinalityFlow subFlow(ReceiveFinalityFlow(counterpartySession, expectedTxId = idOfTxWeSigned)) // DOCEND ReceiveFinalityFlow } - MaxLineLength:FlowException.kt$FlowException : CordaExceptionIdentifiableException - MaxLineLength:FlowFrameworkPersistenceTests.kt$FlowFrameworkPersistenceTests$aliceNode = mockNet.createNode(InternalMockNodeParameters(legalName = ALICE_NAME, flowManager = aliceFlowManager)) MaxLineLength:FlowFrameworkPersistenceTests.kt$FlowFrameworkPersistenceTests$assertEquals(0, charlieNode.internals.checkpointStorage.checkpoints().size, "Checkpoints left after restored flow should have ended") - MaxLineLength:FlowFrameworkPersistenceTests.kt$FlowFrameworkPersistenceTests$assertEquals(0, node2b.internals.checkpointStorage.checkpoints().size, "Checkpoints left after restored flow should have ended") MaxLineLength:FlowFrameworkPersistenceTests.kt$FlowFrameworkPersistenceTests$assertEquals(payload + 1, secondFlow.getOrThrow().receivedPayload2, "Received payload does not match the expected second value on Node 2") MaxLineLength:FlowFrameworkPersistenceTests.kt$FlowFrameworkPersistenceTests$assertEquals(payload, secondFlow.getOrThrow().receivedPayload, "Received payload does not match the (restarted) first value on Node 2") - MaxLineLength:FlowFrameworkPersistenceTests.kt$FlowFrameworkPersistenceTests$assertEquals(payload2 + 1, firstAgain.receivedPayload2, "Received payload does not match the expected second value on Node 3") - MaxLineLength:FlowFrameworkPersistenceTests.kt$FlowFrameworkPersistenceTests$mockNet.messagingNetwork.sentMessages.toSessionTransfers().filter { it.isPayloadTransfer }.forEach { sentCount++ } - MaxLineLength:FlowFrameworkPersistenceTests.kt$FlowFrameworkPersistenceTests${ val payload = random63BitValue() val payload2 = random63BitValue() var sentCount = 0 mockNet.messagingNetwork.sentMessages.toSessionTransfers().filter { it.isPayloadTransfer }.forEach { sentCount++ } val charlieNode = mockNet.createNode(InternalMockNodeParameters(legalName = CHARLIE_NAME)) val secondFlow = charlieNode.registerCordappFlowFactory(PingPongFlow::class) { PingPongFlow(it, payload2) } mockNet.runNetwork() val charlie = charlieNode.info.singleIdentity() // Kick off first send and receive bobNode.services.startFlow(PingPongFlow(charlie, payload)) bobNode.database.transaction { assertEquals(1, bobNode.internals.checkpointStorage.checkpoints().size) } // Make sure the add() has finished initial processing. bobNode.internals.disableDBCloseOnStop() // Restart node and thus reload the checkpoint and resend the message with same UUID bobNode.dispose() bobNode.database.transaction { assertEquals(1, bobNode.internals.checkpointStorage.checkpoints().size) // confirm checkpoint bobNode.services.networkMapCache.clearNetworkMapCache() } val node2b = mockNet.createNode(InternalMockNodeParameters(bobNode.internals.id)) bobNode.internals.manuallyCloseDB() val (firstAgain, fut1) = node2b.getSingleFlow<PingPongFlow>() // Run the network which will also fire up the second flow. First message should get deduped. So message data stays in sync. mockNet.runNetwork() fut1.getOrThrow() val receivedCount = receivedSessionMessages.count { it.isPayloadTransfer } // Check flows completed cleanly and didn't get out of phase assertEquals(4, receivedCount, "Flow should have exchanged 4 unique messages")// Two messages each way // can't give a precise value as every addMessageHandler re-runs the undelivered messages assertTrue(sentCount > receivedCount, "Node restart should have retransmitted messages") node2b.database.transaction { assertEquals(0, node2b.internals.checkpointStorage.checkpoints().size, "Checkpoints left after restored flow should have ended") } charlieNode.database.transaction { assertEquals(0, charlieNode.internals.checkpointStorage.checkpoints().size, "Checkpoints left after restored flow should have ended") } assertEquals(payload2, firstAgain.receivedPayload, "Received payload does not match the first value on Node 3") assertEquals(payload2 + 1, firstAgain.receivedPayload2, "Received payload does not match the expected second value on Node 3") assertEquals(payload, secondFlow.getOrThrow().receivedPayload, "Received payload does not match the (restarted) first value on Node 2") assertEquals(payload + 1, secondFlow.getOrThrow().receivedPayload2, "Received payload does not match the expected second value on Node 2") } - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$CommitReceiverFlow : FlowLogic - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$CommitterFlow : FlowLogic - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$SuspendThrowingActionExecutor : ActionExecutor - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$WaitForLedgerCommitFlow : FlowLogic - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$aliceNode.registerCordappFlowFactory(WaitForLedgerCommitFlow::class) { ExceptionFlow { throw Exception("Error") } } - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$aliceNode.sendSessionMessage(InitialSessionMessage(SessionId(random63BitValue()), 0, "not.a.real.Class", 1, "", null), bob) - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$aliceNode.sendSessionMessage(InitialSessionMessage(SessionId(random63BitValue()), 0, String::class.java.name, 1, "", null), bob) - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$assertThat((lastMessage.payload as RejectSessionMessage).message).isEqualTo("${String::class.java.name} is not a flow") - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$assertThat(committerStx.getOrThrow()).isEqualTo(waiterStx.getOrThrow()).isEqualTo(commitReceiverStx.getOrThrow()) MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$assertThat(receivedSessionMessages).hasSize(1) - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$assertThatExceptionOfType(MyFlowException::class.java) .isThrownBy { receivingFiber.resultFuture.getOrThrow() } .withMessage("Nothing useful") .withStackTraceContaining(ReceiveFlow::class.java.name) - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$assertThatExceptionOfType(MyPeerFlowException::class.java) .isThrownBy { receivingFiber.resultFuture.getOrThrow() } .has(Condition(Predicate<MyPeerFlowException> { it.peer == alice }, "subclassed peer field has original value")) - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$bobNode.registerCordappFlowFactory(UpgradedFlow::class, initiatedFlowVersion = 1) { InitiatedSendFlow("Old initiated", it) } - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$bobNode.smm.flowHospital.dropSessionInit(sessionInitRecord.id) - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$fiber.transientValues = TransientReference(fiber.transientValues!!.value.copy(actionExecutor = throwingActionExecutor)) - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests$val throwingActionExecutor = SuspendThrowingActionExecutor(exceptionDuringSuspend, fiber.transientValues!!.value.actionExecutor) - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests.ConditionalExceptionFlow$private - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests.IncorrectCustomSendFlow$@InitiatingFlow private - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests.UpgradedFlow$@InitiatingFlow(version = 2) private - MaxLineLength:FlowFrameworkTests.kt$FlowFrameworkTests.WaitForOtherSideEndBeforeSendAndReceive$@Transient val receivedOtherFlowEnd: Semaphore - MaxLineLength:FlowFrameworkTests.kt$InitiatedSendFlow$internal open MaxLineLength:FlowFrameworkTests.kt$PingPongFlow$@InitiatingFlow internal - MaxLineLength:FlowFrameworkTests.kt$PingPongFlow$constructor(otherPartySession: FlowSession, payload: Long) : this(otherPartySession.counterparty, payload, otherPartySession) MaxLineLength:FlowFrameworkTests.kt$SendAndReceiveFlow$@InitiatingFlow internal - MaxLineLength:FlowFrameworkTests.kt$SendAndReceiveFlow$constructor(otherPartySession: FlowSession, payload: Any) : this(otherPartySession.counterparty, payload, otherPartySession) - MaxLineLength:FlowFrameworkTests.kt$internal MaxLineLength:FlowFrameworkTests.kt$internal fun errorMessage(errorResponse: FlowException? = null) MaxLineLength:FlowFrameworkTests.kt$internal fun sessionConfirm(flowVersion: Int = 1) MaxLineLength:FlowFrameworkTests.kt$internal infix fun Pair<Int, SessionMessage>.to(node: TestStartedNode): SessionTransfer - MaxLineLength:FlowFrameworkTests.kt$internal infix fun TestStartedNode.sent(message: SessionMessage): Pair<Int, SessionMessage> - MaxLineLength:FlowFrameworkTripartyTests.kt$FlowFrameworkTripartyTests$charlieNode.registerCordappFlowFactory(ReceiveFlow::class) { ExceptionFlow { MyFlowException("Nothing useful") } } - MaxLineLength:FlowFrameworkTripartyTests.kt$FlowFrameworkTripartyTests$val actualForNode = receivedSessionMessages.filter { it.from == node.internals.id || it.to == node.network.myAddress } - MaxLineLength:FlowHandle.kt$FlowProgressHandle<A> : FlowHandle - MaxLineLength:FlowHandle.kt$FlowProgressHandleImpl$// For API compatibility fun copy(id: StateMachineRunId, returnValue: CordaFuture<A>, progress: Observable<String>): FlowProgressHandleImpl<A> - MaxLineLength:FlowHandle.kt$FlowProgressHandleImpl$override val stepsTreeFeed: DataFeed<List<Pair<Int, String>>, List<Pair<Int, String>>>? = null - MaxLineLength:FlowHandle.kt$FlowProgressHandleImpl$return copy(id = id, returnValue = returnValue, progress = progress, stepsTreeFeed = null, stepsTreeIndexFeed = null) - MaxLineLength:FlowInitiator.kt$FlowInitiator : Principal - MaxLineLength:FlowInitiator.kt$FlowInitiator$/** * Returns an [InvocationContext], which is equivalent to this object but expressed using the successor to this * class hierarchy (which is now deprecated). The returned object has less information than it could have, so * prefer to use fetch an invocation context directly if you can (e.g. in [net.corda.core.messaging.StateMachineInfo]) */ val invocationContext: InvocationContext get() { val unknownName = CordaX500Name("UNKNOWN", "UNKNOWN", "GB") var actor: Actor? = null val origin: InvocationOrigin when (this) { is FlowInitiator.RPC -> { actor = Actor(Actor.Id(this.username), AuthServiceId("UNKNOWN"), unknownName) origin = InvocationOrigin.RPC(actor) } is FlowInitiator.Peer -> origin = InvocationOrigin.Peer(this.party.name) is FlowInitiator.Service -> origin = InvocationOrigin.Service(this.serviceClassName, unknownName) FlowInitiator.Shell -> origin = InvocationOrigin.Shell is FlowInitiator.Scheduled -> origin = InvocationOrigin.Scheduled(this.scheduledState) } return InvocationContext.newInstance(origin = origin, actor = actor) } - MaxLineLength:FlowLogic.kt$FlowLogic$ @Deprecated("Use FlowSession.getCounterpartyFlowInfo()", level = DeprecationLevel.WARNING) @Suspendable fun getFlowInfo(otherParty: Party): FlowInfo - MaxLineLength:FlowLogic.kt$FlowLogic$ @Deprecated("Use FlowSession.sendAndReceive()", level = DeprecationLevel.WARNING) @Suspendable open fun <R : Any> sendAndReceive(receiveType: Class<R>, otherParty: Party, payload: Any): UntrustworthyData<R> MaxLineLength:FlowLogic.kt$FlowLogic$ @Suspendable @JvmOverloads open fun <R : Any> receiveAll(receiveType: Class<R>, sessions: List<FlowSession>, maySkipCheckpoint: Boolean = false): List<UntrustworthyData<R>> MaxLineLength:FlowLogic.kt$FlowLogic$ @Suspendable @JvmOverloads open fun receiveAllMap(sessions: Map<FlowSession, Class<out Any>>, maySkipCheckpoint: Boolean = false): Map<FlowSession, UntrustworthyData<Any>> - MaxLineLength:FlowLogic.kt$FlowLogic$ @Suspendable fun waitForStateConsumption(stateRefs: Set<StateRef>) - MaxLineLength:FlowLogic.kt$FlowLogic$ @Throws(FlowException::class) fun checkFlowPermission(permissionName: String, extraAuditData: Map<String, String>) - MaxLineLength:FlowLogic.kt$FlowLogic$ fun recordAuditEvent(eventType: String, comment: String, extraAuditData: Map<String, String>) - MaxLineLength:FlowLogic.kt$FlowLogic$ fun trackStepsTree(): DataFeed<List<Pair<Int, String>>, List<Pair<Int, String>>>? - MaxLineLength:FlowLogic.kt$FlowLogic$ fun trackStepsTreeIndex(): DataFeed<Int, Int>? - MaxLineLength:FlowLogic.kt$FlowLogic$/** * @suppress * Internal only. Reference to the [co.paralleluniverse.fibers.Fiber] instance that is the top level controller for * the entire flow. When inside a flow this is equivalent to [co.paralleluniverse.strands.Strand.currentStrand]. This * is public only because it must be accessed across module boundaries. */ var stateMachine: FlowStateMachine<*> @CordaInternal get() = _stateMachine ?: throw IllegalStateException( "You cannot access the flow's state machine until the flow has been started.") @CordaInternal set(value) { _stateMachine = value } - MaxLineLength:FlowLogic.kt$FlowLogic$/** * Override this to provide a [ProgressTracker]. If one is provided and stepped, the framework will do something * helpful with the progress reports e.g record to the audit service. If this flow is invoked as a subflow of another, * then the tracker will be made a child of the current step in the parent. If it's null, this flow doesn't track * progress. * * Note that this has to return a tracker before the flow is invoked. You can't change your mind half way * through. */ open val progressTracker: ProgressTracker? = DEFAULT_TRACKER() - MaxLineLength:FlowLogic.kt$FlowLogic$/** * Specifies the identity to use for this flow. This will be one of the multiple identities that belong to this node. * This is the same as calling `ourIdentityAndCert.party`. * @see NodeInfo.legalIdentities * * Note: The current implementation returns the single identity of the node. This will change once multiple identities * is implemented. */ val ourIdentity: Party get() = stateMachine.ourIdentity - MaxLineLength:FlowLogic.kt$FlowLogic$/** * Specifies the identity, with certificate, to use for this flow. This will be one of the multiple identities that * belong to this node. * @see NodeInfo.legalIdentitiesAndCerts * * Note: The current implementation returns the single identity of the node. This will change once multiple identities * is implemented. */ val ourIdentityAndCert: PartyAndCertificate get() { return serviceHub.myInfo.legalIdentitiesAndCerts.find { it.party == stateMachine.ourIdentity } ?: throw IllegalStateException("Identity specified by ${stateMachine.id} (${stateMachine.ourIdentity}) is not one of ours!") } MaxLineLength:FlowLogic.kt$FlowLogic$?: MaxLineLength:FlowLogic.kt$FlowLogic$@Suspendable @JvmOverloads open - MaxLineLength:FlowLogic.kt$FlowLogic$@Suspendable internal - MaxLineLength:FlowLogic.kt$FlowLogic$private - MaxLineLength:FlowLogic.kt$FlowLogic.Companion$throw FlowException("Attempt to sleep for longer than 5 minutes is not supported. Consider using SchedulableState.") - MaxLineLength:FlowLogicRef.kt$FlowLogicRef - MaxLineLength:FlowLogicRefFactoryImpl.kt$FlowLogicRefFactoryImpl : SingletonSerializeAsTokenFlowLogicRefFactory MaxLineLength:FlowLogicRefFactoryImpl.kt$FlowLogicRefFactoryImpl$if (ref !is FlowLogicRefImpl) throw IllegalFlowLogicException(ref.javaClass, "FlowLogicRef was not created via correct FlowLogicRefFactory interface") - MaxLineLength:FlowLogicRefFactoryImpl.kt$FlowLogicRefFactoryImpl$open - MaxLineLength:FlowLogicRefFactoryImpl.kt$FlowLogicRefFactoryImpl$private - MaxLineLength:FlowLogicRefFactoryImpl.kt$FlowLogicRefFactoryImpl$protected open - MaxLineLength:FlowLogicRefFactoryImpl.kt$FlowLogicRefFactoryImpl$return (value is Any && parameterAssignableFrom(parameter.type.javaType, value)) || parameter.type.isMarkedNullable - MaxLineLength:FlowLogicRefFactoryImpl.kt$FlowLogicRefImpl$@CordaSerializable data MaxLineLength:FlowManager.kt$FlowManager - MaxLineLength:FlowManager.kt$FlowManager$fun registerInitiatedCoreFlowFactory(initiatingFlowClass: KClass<out FlowLogic<*>>, flowFactory: (FlowSession) -> FlowLogic<*>) MaxLineLength:FlowManager.kt$FlowManager$fun registerInitiatedCoreFlowFactory(initiatingFlowClass: KClass<out FlowLogic<*>>, initiatedFlowClass: KClass<out FlowLogic<*>>?, flowFactory: (FlowSession) -> FlowLogic<*>) MaxLineLength:FlowManager.kt$FlowManager$fun registerInitiatedCoreFlowFactory(initiatingFlowClass: KClass<out FlowLogic<*>>, initiatedFlowClass: KClass<out FlowLogic<*>>?, flowFactory: InitiatedFlowFactory.Core<FlowLogic<*>>) - MaxLineLength:FlowManager.kt$NodeFlowManager$"${InitiatingFlow::class.java.name}.version not applicable for core flows; their version is the node's platform version" - MaxLineLength:FlowManager.kt$NodeFlowManager$// To verify the integrity of the current state, it is important that the tip of the responders is a unique weight // if there are multiple flows with the same weight as the tip, it means that it is impossible to reliably pick one as the responder private fun validateInvariants(toValidate: List<RegisteredFlowContainer>) MaxLineLength:FlowManager.kt$NodeFlowManager$@Synchronized override MaxLineLength:FlowManager.kt$NodeFlowManager$FlowWeightComparator : Comparator - MaxLineLength:FlowManager.kt$NodeFlowManager$log MaxLineLength:FlowManager.kt$NodeFlowManager$log.warn("Multiple flows are registered for InitiatingFlow: $initiatingFlowClass, currently using: ${listOfFlowsForInitiator.first().initiatedFlowClass}") - MaxLineLength:FlowManager.kt$NodeFlowManager$registerInitiatedCoreFlowFactory(initiatingFlowClass, initiatedFlowClass, InitiatedFlowFactory.Core(flowFactory)) - MaxLineLength:FlowManager.kt$NodeFlowManager$throw IllegalArgumentException("$responder must have a constructor accepting a ${FlowSession::class.java.name}") MaxLineLength:FlowManager.kt$NodeFlowManager$val equalWeightAsCurrentTip = toValidate.map { flowWeightComparator.compare(currentTip, it) to it }.filter { it.first == 0 }.map { it.second } - MaxLineLength:FlowManager.kt$NodeFlowManager$val flowToAdd = RegisteredFlowContainer(initiatingFlowClass, initiatedFlowClass, flowFactory, FlowType.CORDAPP) MaxLineLength:FlowManager.kt$NodeFlowManager$val message = "Unable to determine which flow to use when responding to: ${currentTip.initiatingFlowClass.canonicalName}. ${equalWeightAsCurrentTip.map { it.initiatedFlowClass!!.canonicalName }} are all registered with equal weight." - MaxLineLength:FlowManager.kt$NodeFlowManager.FlowWeightComparator$override MaxLineLength:FlowManager.kt$NodeFlowManager.FlowWeightComparator$private open MaxLineLength:FlowMessaging.kt$FlowMessagingImpl$val mightDeadlockDrainingTarget = FlowStateMachineImpl.currentStateMachine()?.context?.origin.let { it is InvocationOrigin.Peer && it.party == target.name } MaxLineLength:FlowMessaging.kt$FlowMessagingImpl$val networkMessage = serviceHub.networkService.createMessage(sessionTopic, serializeSessionMessage(message).bytes, deduplicationId, message.additionalHeaders(party)) - MaxLineLength:FlowMessaging.kt$FlowMessagingImpl$val partyInfo = serviceHub.networkMapCache.getPartyInfo(party) ?: throw IllegalArgumentException("Don't know about $party") MaxLineLength:FlowMessaging.kt$FlowMessagingImpl${ // Handling Kryo and AMQP serialization problems. Unfortunately the two exception types do not share much of a common exception interface. if ((exception is KryoException || exception is NotSerializableException) && message is ExistingSessionMessage && message.payload is ErrorSessionMessage) { val error = message.payload.flowException val rewrappedError = FlowException(error?.message) message.copy(payload = message.payload.copy(flowException = rewrappedError)).serialize() } else { throw exception } } - MaxLineLength:FlowMessaging.kt$FlowMessagingImpl${ // This prevents a "deadlock" in case an initiated flow tries to start a session against a draining node that is also the initiator. // It does not help in case more than 2 nodes are involved in a circle, so the kill switch via RPC should be used in that case. val mightDeadlockDrainingTarget = FlowStateMachineImpl.currentStateMachine()?.context?.origin.let { it is InvocationOrigin.Peer && it.party == target.name } return when { this !is InitialSessionMessage || mightDeadlockDrainingTarget -> emptyMap() else -> mapOf(P2PMessagingHeaders.Type.KEY to P2PMessagingHeaders.Type.SESSION_INIT_VALUE) } } - MaxLineLength:FlowMonitor.kt$FlowMonitor$flow.ioRequest()?.let { request -> warningMessageForFlowWaitingOnIo(request, flow, now) }?.let(logger::info) MaxLineLength:FlowMonitor.kt$FlowMonitor$is FlowIORequest.ExecuteAsyncOperation -> "for asynchronous operation of type ${request.operation::javaClass} to complete" - MaxLineLength:FlowMonitor.kt$FlowMonitor$is FlowIORequest.GetFlowInfo -> "to get flow information from parties ${request.sessions.partiesInvolved()}" - MaxLineLength:FlowMonitor.kt$FlowMonitor$is FlowIORequest.Send -> "to send a message to parties ${request.sessionToMessage.keys.partiesInvolved()}" MaxLineLength:FlowMonitor.kt$FlowMonitor$is FlowIORequest.SendAndReceive -> "to send and receive messages from parties ${request.sessionToMessage.keys.partiesInvolved()}" MaxLineLength:FlowMonitor.kt$FlowMonitor$is FlowIORequest.Sleep -> "to wake up from sleep ending at ${LocalDateTime.ofInstant(request.wakeUpAfter, ZoneId.systemDefault())}" - MaxLineLength:FlowMonitor.kt$FlowMonitor$is FlowIORequest.WaitForLedgerCommit -> "for the ledger to commit transaction with hash ${request.hash}" - MaxLineLength:FlowMonitor.kt$FlowMonitor$private - MaxLineLength:FlowMonitor.kt$FlowMonitor$private fun FlowStateMachineImpl<*>.ioRequest() MaxLineLength:FlowMonitor.kt$FlowMonitor$scheduler!!.scheduleAtFixedRate({ logFlowsWaitingForParty(suspensionLoggingThreshold) }, 0, monitoringPeriod.toMillis(), TimeUnit.MILLISECONDS) MaxLineLength:FlowMonitor.kt$FlowMonitor$val message = StringBuilder("Flow with id ${flow.id.uuid} has been waiting for ${flow.ongoingDuration(now).toMillis() / 1000} seconds ") - MaxLineLength:FlowOverrideTests.kt$FlowOverrideTests$assertThat(nodeB.rpc.startFlow(::Ping, nodeA.nodeInfo.singleIdentity()).returnValue.getOrThrow(), `is`(Pong.PONG)) - MaxLineLength:FlowOverrideTests.kt$FlowOverrideTests$assertThat(nodeB.rpc.startFlow(::Ping, nodeA.nodeInfo.singleIdentity()).returnValue.getOrThrow(), `is`(Pongiest.GORGONZOLA)) MaxLineLength:FlowRetryTest.kt$FlowRetryTest$it.proxy.startFlow(::InitiatorFlow, numSessions, numIterations, nodeBHandle.nodeInfo.singleIdentity()).returnValue.getOrThrow() - MaxLineLength:FlowRetryTest.kt$InitiatorFlow : FlowLogic - MaxLineLength:FlowRetryTest.kt$Step MaxLineLength:FlowSessionImpl.kt$FlowSessionImpl$@Suspendable override - MaxLineLength:FlowSessionImpl.kt$FlowSessionImpl$val responseValues: Map<FlowSession, SerializedBytes<Any>> = getFlowStateMachine().suspend(request, maySkipCheckpoint) - MaxLineLength:FlowStackSnapshot.kt$FlowStackSnapshotFactoryImpl$if (it != null && (it is FlowLogic<*> || it is FlowStateMachine<*> || it is Fiber<*> || it is SerializeAsToken)) { StackFrameDataToken(it::class.java.name) } else { it } MaxLineLength:FlowStackSnapshot.kt$FlowStackSnapshotFactoryImpl$private - MaxLineLength:FlowStackSnapshot.kt$FlowStackSnapshotFactoryImpl$val stackObjects = if (frameObjectsIterator.hasNext() && (annotation == null || !annotation.methodOptimized)) { frameObjectsIterator.next() } else { emptyList() } - MaxLineLength:FlowStackSnapshotTest.kt$FlowStackSnapshotTest$"criteria (specifically: extra objects are introduced to the quasar stack by th Jacoco agent). You can however " - MaxLineLength:FlowStackSnapshotTest.kt$FlowStackSnapshotTest$@Ignore("When running via gradle the Jacoco agent interferes with the quasar instrumentation process and violates tested" + "criteria (specifically: extra objects are introduced to the quasar stack by th Jacoco agent). You can however " + "run these tests via an IDE.") MaxLineLength:FlowStackSnapshotTest.kt$FlowStackSnapshotTest$val a = startNode(rpcUsers = listOf(User(Constants.USER, Constants.PASSWORD, setOf(startFlow<MultiplePersistingSideEffectFlow>())))).get() - MaxLineLength:FlowStackSnapshotTest.kt$FlowStackSnapshotTest$val a = startNode(rpcUsers = listOf(User(Constants.USER, Constants.PASSWORD, setOf(startFlow<NoSideEffectFlow>())))).get() MaxLineLength:FlowStackSnapshotTest.kt$FlowStackSnapshotTest$val a = startNode(rpcUsers = listOf(User(Constants.USER, Constants.PASSWORD, setOf(startFlow<PersistingNoSideEffectFlow>())))).get() MaxLineLength:FlowStackSnapshotTest.kt$FlowStackSnapshotTest$val a = startNode(rpcUsers = listOf(User(Constants.USER, Constants.PASSWORD, setOf(startFlow<PersistingSideEffectFlow>())))).get() - MaxLineLength:FlowStackSnapshotTest.kt$FlowStackSnapshotTest$val a = startNode(rpcUsers = listOf(User(Constants.USER, Constants.PASSWORD, setOf(startFlow<SideEffectFlow>())))).get() - MaxLineLength:FlowStackSnapshotTest.kt$StackSnapshotFrame$@CordaSerializable data - MaxLineLength:FlowStateMachine.kt$FlowStateMachine$@Suspendable fun <SUSPENDRETURN : Any> suspend(ioRequest: FlowIORequest<SUSPENDRETURN>, maySkipCheckpoint: Boolean): SUSPENDRETURN - MaxLineLength:FlowStateMachineImpl.kt$"${InitiatingFlow::class.java.name}. See https://docs.corda.net/api-flows.html#flowlogic-annotations." - MaxLineLength:FlowStateMachineImpl.kt$?: - MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl$"Transaction context is missing. This might happen if a suspendable method is not annotated with @Suspendable annotation." - MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl$/** * Return the logger for this state machine. The logger name incorporates [id] and so including it in the log message * is not necessary. */ override val logger = log - MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl$@Suspendable private - MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl$Thread.currentThread().contextClassLoader = (serviceHub.cordappProvider as CordappProviderImpl).cordappLoader.appClassLoader MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl$errorAndTerminate("Caught unrecoverable error from flow. Forcibly terminating the JVM, this might leave resources open, and most likely will.", t) MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl$require(continuation == FlowContinuation.ProcessEvents){"Expected a continuation of type ${FlowContinuation.ProcessEvents}, found $continuation "} - MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl$throw FlowPermissionException("User ${context.principal()} not permissioned for $permissionName on flow $id") - MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl$val (continuation, newState) = transitionExecutor.executeTransition(this, oldState, event, transition, actionExecutor) - MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl$val permissionGranted = true // TODO define permission control service on ServiceHubInternal and actually check authorization. - MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl$val serializationContext = TransientReference(getTransientField(TransientValues::checkpointSerializationContext)) MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl${ // This sets the Cordapp classloader on the contextClassLoader of the current thread. // Needed because in previous versions of the finance app we used Thread.contextClassLoader to resolve services defined in cordapps. Thread.currentThread().contextClassLoader = (serviceHub.cordappProvider as CordappProviderImpl).cordappLoader.appClassLoader val result = logic.call() suspend(FlowIORequest.WaitForSessionConfirmations, maySkipCheckpoint = true) Try.Success(result) } - MaxLineLength:FlowStateMachineImpl.kt$FlowStateMachineImpl.Companion$private val SERIALIZER_BLOCKER = Fiber::class.java.getDeclaredField("SERIALIZER_BLOCKER").apply { isAccessible = true }.get(null) - MaxLineLength:FlowStateMachineImpl.kt$if (found != null) throw IllegalArgumentException("${InitiatingFlow::class.java.name} can only be annotated once") MaxLineLength:FlowTestsUtils.kt$ @Suspendable fun <R : Any> FlowLogic<*>.receiveAll(receiveType: Class<R>, session: FlowSession, vararg sessions: FlowSession): List<UntrustworthyData<R>> MaxLineLength:FlowTestsUtils.kt$ @Suspendable fun FlowLogic<*>.receiveAll(session: Pair<FlowSession, Class<out Any>>, vararg sessions: Pair<FlowSession, Class<out Any>>): Map<FlowSession, UntrustworthyData<Any>> MaxLineLength:FlowTestsUtils.kt$ @Suspendable inline fun <reified R : Any> FlowLogic<*>.receiveAll(session: FlowSession, vararg sessions: FlowSession): List<UntrustworthyData<R>> - MaxLineLength:FlowTestsUtils.kt$@Suppress("UNCHECKED_CAST") infix MaxLineLength:FlowTestsUtils.kt$@Suspendable inline MaxLineLength:FlowTestsUtils.kt$Answer<out R : Any> : SimpleAnswer MaxLineLength:FlowTestsUtils.kt$SimpleAnswer$abstract - MaxLineLength:FlowTestsUtils.kt$flowFactory: (FlowSession) -> T MaxLineLength:FlowTestsUtils.kt$return this.internals.registerInitiatedFlowFactory(initiatingFlowClass, initiatedFlowClass, InitiatedFlowFactory.Core(flowFactory), track) - MaxLineLength:FlowWatchPrintingSubscriber.kt$FlowWatchPrintingSubscriber$val header = RowElement(true).add("Id", "Flow name", "Initiator", "Status").style(Decoration.bold.fg(Color.black).bg(Color.white)) MaxLineLength:FlowsDrainingModeContentionTest.kt$FlowsDrainingModeContentionTest$val flow = nodeA.rpc.startFlow(::ProposeTransactionAndWaitForCommit, message, nodeARpcInfo, nodeB.nodeInfo.singleIdentity(), defaultNotaryIdentity) - MaxLineLength:FlowsExecutionModeRpcTest.kt$FlowsExecutionModeRpcTest$val user = User("mark", "dadada", setOf(invokeRpc("setFlowsDrainingModeEnabled"), invokeRpc("isFlowsDrainingModeEnabled"))) MaxLineLength:FlowsExecutionModeRpcTest.kt$FlowsExecutionModeTests$private - MaxLineLength:FoundNode.kt$FoundNode$val name: String = configFile.parentFile.name.toLowerCase().replace(Constants.ALPHA_NUMERIC_ONLY_REGEX, "") - MaxLineLength:FungibleAsset.kt$InsufficientBalanceException : FlowException - MaxLineLength:FxTransactionBuildTutorial.kt$ForeignExchangeFlow$val sum = it.filter { it.owner.let { it is Party && serviceHub.myInfo.isLegalIdentity(it) } }.map { it.amount.quantity }.sum() MaxLineLength:FxTransactionBuildTutorial.kt$ForeignExchangeRemoteFlow$val ourKey = serviceHub.keyManagementService.filterMyKeys(ourInputState.flatMap { it.state.data.participants }.map { it.owningKey }).single() MaxLineLength:FxTransactionBuildTutorial.kt$private MaxLineLength:FxTransactionBuildTutorial.kt$val eligibleStates = serviceHub.vaultService.tryLockFungibleStatesForSpending(lockId, fullCriteria, amountRequired.withoutIssuer(), Cash.State::class.java) - MaxLineLength:FxTransactionBuildTutorial.kt$val logicalExpression = builder { CashSchemaV1.PersistentCashState::currency.equal(amountRequired.token.product.currencyCode) } MaxLineLength:FxTransactionBuildTutorial.kt$val ourParties = ourKeys.map { serviceHub.identityService.partyFromKey(it) ?: throw IllegalStateException("Unable to resolve party from key") } - MaxLineLength:GenerateHelpers.kt$return generateAmount(1, max, Generator.pure(Issued(PartyAndReference(issuer, OpaqueBytes.of(0)), currency))).combine( Generator.pickOne(possibleRecipients) ) { amount, recipient -> PaymentRequest(amount.withoutIssuer(), recipient, true, setOf(issuer)) } MaxLineLength:GenerateNodeInfoCli.kt$GenerateNodeInfoCli : NodeCliCommand - MaxLineLength:GenerateRpcSslCertsCli.kt$GenerateRpcSslCerts$println("You need to distribute this file along with the password in a secure way to all RPC clients.") MaxLineLength:GenerateRpcSslCertsCli.kt$GenerateRpcSslCertsCli : NodeCliCommand MaxLineLength:Generator.kt$Generator$fun <B, C, D, E, R> combine(other1: Generator<B>, other2: Generator<C>, other3: Generator<D>, other4: Generator<E>, function: (A, B, C, D, E) -> R) - MaxLineLength:Generator.kt$Generator$fun <B, C, D, R> combine(other1: Generator<B>, other2: Generator<C>, other3: Generator<D>, function: (A, B, C, D) -> R) MaxLineLength:Generator.kt$Generator$product<R>(other1.product(other2.product(other3.product(other4.product(pure({ e -> { d -> { c -> { b -> { a -> function(a, b, c, d, e) } } } } })))))) - MaxLineLength:Generator.kt$Generator$product<R>(other1.product(other2.product(other3.product(pure({ d -> { c -> { b -> { a -> function(a, b, c, d) } } } }))))) - MaxLineLength:Generator.kt$Generator.Companion$fun <A> replicatePoisson(meanSize: Double, generator: Generator<A>, atLeastOne: Boolean = false) - MaxLineLength:Generator.kt$Generator<out A> - MaxLineLength:GenericsTests.kt$GenericsTests$LTransactionState<T1, T2, T3 : BaseState<T1, T2>, out T4: BaseState<T1, T2>> - MaxLineLength:GenericsTests.kt$GenericsTests$StateWrapper<T1, T2, T3 : BaseState<T1, T2>, out T4: BaseState<T1, T2>> - MaxLineLength:GenericsTests.kt$GenericsTests$val bytes = SerializationOutput(factory).serializeAndReturnSchema(Wrapper(1, G1("hi"), G2("poop"))).apply { printSchema() } - MaxLineLength:GetBalances.kt$CashSchemaV1.PersistentCashState::pennies - MaxLineLength:GetBalances.kt$require(rows.otherResults[1] == currency.currencyCode){"Currency on rows returned by query does not match expected"} - MaxLineLength:GetBalances.kt$val sum = builder { CashSchemaV1.PersistentCashState::pennies.sum(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency)) } - MaxLineLength:GetBalances.kt${ val sum = builder { CashSchemaV1.PersistentCashState::pennies.sum(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency)) } val sumCriteria = QueryCriteria.VaultCustomQueryCriteria(sum) val ccyIndex = builder { CashSchemaV1.PersistentCashState::currency.equal(currency.currencyCode) } // This query should only return cash states the calling node is a participant of (meaning they can be modified/spent). val ccyCriteria = QueryCriteria.VaultCustomQueryCriteria(ccyIndex, relevancyStatus = Vault.RelevancyStatus.RELEVANT) return sumCriteria.and(ccyCriteria) } - MaxLineLength:GetBalances.kt${ val sum = builder { CashSchemaV1.PersistentCashState::pennies.sum(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency), orderBy = Sort.Direction.DESC) } // This query should only return cash states the calling node is a participant of (meaning they can be modified/spent). return QueryCriteria.VaultCustomQueryCriteria(sum, relevancyStatus = Vault.RelevancyStatus.RELEVANT) } MaxLineLength:GlobalTestPortAllocation.kt$System.getProperty(enablingSystemProperty)?.toBoolean() ?: System.getenv(enablingEnvVar)?.toBoolean() == true -> GlobalTestPortAllocation MaxLineLength:GlobalTestPortAllocation.kt$return System.getProperty(startingPortSystemProperty)?.toIntOrNull() ?: System.getenv(startingPortEnvVariable)?.toIntOrNull() ?: startingPortDefaultValue - MaxLineLength:GuiUtilities.kt$ fun <T> stringConverter(fromStringFunction: ((String?) -> T)? = null, toStringFunction: (T) -> String): StringConverter<T> MaxLineLength:GuiUtilities.kt$// TODO: This is a temporary fix for the UI to show the correct issuer identity, this will break when we start randomizing keys. More work is needed here when the identity work is done. fun StateAndRef<Cash.State>.resolveIssuer(): ObservableValue<Party?> MaxLineLength:GuiUtilities.kt$fun PublicKey.toKnownParty() - MaxLineLength:H2SecurityTests.kt$H2SecurityTests$driver - MaxLineLength:H2SecurityTests.kt$H2SecurityTests$startNode MaxLineLength:H2SecurityTests.kt$H2SecurityTests$startNode(customOverrides = mapOf(h2AddressKey to "${InetAddress.getLocalHost().hostAddress}:${getFreePort()}")).getOrThrow() - MaxLineLength:H2SecurityTests.kt$H2SecurityTests$startNode(customOverrides = mapOf(h2AddressKey to "${InetAddress.getLocalHost().hostName}:${getFreePort()}")).getOrThrow() - MaxLineLength:H2SecurityTests.kt$H2SecurityTests$val nodeHandle = startNode(rpcUsers = listOf(user), customOverrides = mapOf(h2AddressKey to "localhost:$port", dbPasswordKey to "x")).getOrThrow() - MaxLineLength:HTTPNetworkRegistrationService.kt$HTTPNetworkRegistrationService$HTTP_UNAUTHORIZED -> throw CertificateRequestException("Certificate signing request has been rejected: ${conn.errorMessage}") - MaxLineLength:HTTPNetworkRegistrationService.kt$HTTPNetworkRegistrationService$else -> throw IOException("Error while connecting to the Doorman. Http response status code was ${conn.responseCode}.") MaxLineLength:HTTPNetworkRegistrationService.kt$HTTPNetworkRegistrationService$in TRANSIENT_ERROR_STATUS_CODES -> throw ServiceUnavailableException("Could not connect with Doorman. Http response status code was ${conn.responseCode}.") - MaxLineLength:HandleExceptionUnwrapper.kt$HandleExceptionUnwrapper$invokeStatic("sandbox/java/lang/DJVM", "catch", "(Ljava/lang/Throwable;)Lsandbox/java/lang/Throwable;") - MaxLineLength:HandleExceptionUnwrapper.kt$HandleExceptionUnwrapper$invokeStatic("sandbox/java/lang/DJVM", "finally", "(Ljava/lang/Throwable;)Lsandbox/java/lang/Throwable;") MaxLineLength:HardRestartTest.kt$HardRestartTest$startNode(providedName = DUMMY_BANK_B_NAME, rpcUsers = listOf(demoUser), customOverrides = mapOf("p2pAddress" to "localhost:${b.rpcAddress.port}")) MaxLineLength:HardRestartTest.kt$HardRestartTest$val rpc = tlRpc.get() ?: CordaRPCClient(a.rpcAddress).start(demoUser.username, demoUser.password).proxy.also { tlRpc.set(it) } - MaxLineLength:HardRestartTest.kt$HardRestartTest$val string = rpc.startFlow(::RecursiveA, b.nodeInfo.singleIdentity(), 10).returnValue.getOrThrow() - MaxLineLength:HashLookupCommandTest.kt$HashLookupCommandTest$testCommand(session, command = "hashLookup ${SecureHash.randomSHA256()}", expected = "No matching transaction found") - MaxLineLength:HashLookupCommandTest.kt$HashLookupCommandTest$testCommand(session, command = "hashLookup ${txId.sha256()}", expected = "Found a matching transaction with Id: $txId") MaxLineLength:HibernateColumnConverterTests.kt$HibernateColumnConverterTests$// AbstractPartyToX500NameAsStringConverter could cause circular flush of Hibernate session because it is invoked during flush, and a // cache miss was doing a flush. This also checks that loading during flush does actually work. @Test fun `issue some cash on a notary that exists only in the database to check cache loading works in our identity column converters during flush of vault update`() - MaxLineLength:HibernateColumnConverterTests.kt$HibernateColumnConverterTests${ val expected = 500.DOLLARS val ref = OpaqueBytes.of(0x01) // Create parallel set of key and identity services so that the values are not cached, forcing the node caches to do a lookup. val identityService = PersistentIdentityService(TestingNamedCacheFactory()) val originalIdentityService: PersistentIdentityService = services.identityService as PersistentIdentityService identityService.database = originalIdentityService.database identityService.start(originalIdentityService.trustRoot) val keyService = E2ETestKeyManagementService(identityService) keyService.start(setOf(myself.keyPair)) // New identity for a notary (doesn't matter that it's for Bank Of Corda... since not going to use it as an actual notary etc). val newKeyAndCert = keyService.freshKeyAndCert(services.myInfo.legalIdentitiesAndCerts[0], false) val randomNotary = Party(myself.name, newKeyAndCert.owningKey) val ourIdentity = services.myInfo.legalIdentities.first() val builder = TransactionBuilder(notary.party) val issuer = services.myInfo.legalIdentities.first().ref(ref) val signers = Cash().generateIssue(builder, expected.issuedBy(issuer), ourIdentity, randomNotary) val tx: SignedTransaction = services.signInitialTransaction(builder, signers) services.recordTransactions(tx) val output = tx.tx.outputsOfType<Cash.State>().single() assertEquals(expected.`issued by`(ourIdentity.ref(ref)), output.amount) } - MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration$ fun sessionFactoryForSchemas(key: Set<MappedSchema>): SessionFactory - MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration$// TODO: require mechanism to set schemaOptions (databaseSchema, tablePrefix) which are not global to session schema.mappedTypes.forEach { config.addAnnotatedClass(it) } - MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration$Configuration(metadataSources).setProperty("hibernate.connection.provider_class", NodeDatabaseConnectionProvider::class.java.name) .setProperty("hibernate.format_sql", "true") .setProperty("hibernate.hbm2ddl.auto", hbm2dll) .setProperty("javax.persistence.validation.mode", "none") .setProperty("hibernate.connection.isolation", databaseConfig.transactionIsolationLevel.jdbcValue.toString()) MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration$CordaMaterializedBlobType : AbstractSingleColumnStandardBasicType - MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration$CordaPrimitiveByteArrayTypeDescriptor : PrimitiveByteArrayTypeDescriptor MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration$CordaWrapperBinaryType : AbstractSingleColumnStandardBasicType MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration$MapBlobToPostgresByteA : AbstractSingleColumnStandardBasicType MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration$private MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration$private val sessionFactories = cacheFactory.buildNamed<Set<MappedSchema>, SessionFactory>(Caffeine.newBuilder(), "HibernateConfiguration_sessionFactories") MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration$val config = Configuration(metadataSources).setProperty("hibernate.connection.provider_class", NodeDatabaseConnectionProvider::class.java.name) .setProperty("hibernate.format_sql", "true") .setProperty("hibernate.hbm2ddl.auto", hbm2dll) .setProperty("javax.persistence.validation.mode", "none") .setProperty("hibernate.connection.isolation", databaseConfig.transactionIsolationLevel.jdbcValue.toString()) - MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration${ "update" } - MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration${ logger.info("Creating session factory for schemas: $schemas") val serviceRegistry = BootstrapServiceRegistryBuilder().build() val metadataSources = MetadataSources(serviceRegistry) val hbm2dll: String = if(databaseConfig.initialiseSchema && databaseConfig.initialiseAppSchema == SchemaInitializationType.UPDATE) { "update" } else if((!databaseConfig.initialiseSchema && databaseConfig.initialiseAppSchema == SchemaInitializationType.UPDATE) || databaseConfig.initialiseAppSchema == SchemaInitializationType.VALIDATE) { "validate" } else { "none" } // We set a connection provider as the auto schema generation requires it. The auto schema generation will not // necessarily remain and would likely be replaced by something like Liquibase. For now it is very convenient though. val config = Configuration(metadataSources).setProperty("hibernate.connection.provider_class", NodeDatabaseConnectionProvider::class.java.name) .setProperty("hibernate.format_sql", "true") .setProperty("hibernate.hbm2ddl.auto", hbm2dll) .setProperty("javax.persistence.validation.mode", "none") .setProperty("hibernate.connection.isolation", databaseConfig.transactionIsolationLevel.jdbcValue.toString()) schemas.forEach { schema -> // TODO: require mechanism to set schemaOptions (databaseSchema, tablePrefix) which are not global to session schema.mappedTypes.forEach { config.addAnnotatedClass(it) } } val sessionFactory = buildSessionFactory(config, metadataSources, customClassLoader) logger.info("Created session factory for schemas: $schemas") // export Hibernate JMX statistics if (databaseConfig.exportHibernateJMXStatistics) initStatistics(sessionFactory) return sessionFactory } MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration.Companion$// register custom converters fun buildHibernateMetadata(metadataBuilder: MetadataBuilder, jdbcUrl:String, attributeConverters: Collection<AttributeConverter<*, *>>): Metadata - MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration.Companion$attributeConverters.forEach { applyAttributeConverter(it) } // Register a tweaked version of `org.hibernate.type.MaterializedBlobType` that truncates logged messages. // to avoid OOM when large blobs might get logged. applyBasicType(CordaMaterializedBlobType, CordaMaterializedBlobType.name) applyBasicType(CordaWrapperBinaryType, CordaWrapperBinaryType.name) // Create a custom type that will map a blob to byteA in postgres and as a normal blob for all other dbms. // This is required for the Checkpoints as a workaround for the issue that postgres has on azure. if (jdbcUrl.contains(":postgresql:", ignoreCase = true)) { applyBasicType(MapBlobToPostgresByteA, MapBlobToPostgresByteA.name) } else { applyBasicType(MapBlobToNormalBlob, MapBlobToNormalBlob.name) } return build() - MaxLineLength:HibernateConfiguration.kt$HibernateConfiguration.NodeDatabaseConnectionProvider$override fun isUnwrappableAs(unwrapType: Class<*>?): Boolean MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$cashStates = vaultFiller.fillWithSomeTestCash(100.DOLLARS, issuerServices, numStates, issuer.ref(1), rng = Random(0L)).states.toList() MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$criteriaQuery.where(criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), vaultCashStates.get<PersistentStateRef>("stateRef"))) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$criteriaQuery.where(criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), vaultLinearStates.get<PersistentStateRef>("stateRef"))) @@ -5955,37 +3601,21 @@ MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$database = configureDatabase(dataSourceProps, DatabaseConfig(initialiseSchema = initialiseSchema), identityService::wellKnownPartyFromX500Name, identityService::wellKnownPartyFromAnonymous, schemaService) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$println("${it.stateRef} with owner ${cashState.owner.owningKey.toBase58String()} and participants ${cashState.participants.map { it.owningKey.toBase58String() }}") MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$println("${vaultState.stateRef} : [${_dummyLinearStates.externalId} ${_dummyLinearStates.uuid}] : [${_vaultLinearStates.externalId} ${_vaultLinearStates.uuid}]") - MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$private fun sessionFactoryForSchemas(vararg schemas: MappedSchema) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val andDummyLinearStatesPredicate = criteriaBuilder.and(andDummyLinearStatesPredicate1, criteriaBuilder.and(andDummyLinearStatesPredicate2, andDummyLinearStatesPredicate3)) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val andDummyLinearStatesPredicate1 = criteriaBuilder.and(criteriaBuilder.equal(dummyLinearStates.get<String>("linearString"), "123")) - MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val andDummyLinearStatesPredicate2 = criteriaBuilder.and(criteriaBuilder.equal(dummyLinearStates.get<Long>("linearNumber"), 123L)) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val andDummyLinearStatesPredicate3 = criteriaBuilder.and(criteriaBuilder.equal(dummyLinearStates.get<Boolean>("linearBoolean"), true)) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val andLinearStatesPredicate1 = criteriaBuilder.and(criteriaBuilder.equal(vaultLinearStates.get<String>("externalId"), uniqueID456.externalId)) - MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val andLinearStatesPredicate2 = criteriaBuilder.and(criteriaBuilder.equal(vaultLinearStates.get<UUID>("uuid"), uniqueID456.id)) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val cashStates = vaultFiller.fillWithSomeTestCash(100.DOLLARS, issuerServices, 2, issuer.ref(1), ALICE, Random(0L)).states - MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val cordappPackages = listOf("net.corda.testing.internal.vault", "net.corda.finance.contracts.asset", "net.corda.finance.schemas") - MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val joinCashStateToParty = cashStatesSchema.joinSet<SampleCashSchemaV3.PersistentCashState, String>("participants") MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val joinPredicate = criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), vaultLinearStates.get<PersistentStateRef>("stateRef")) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val joinPredicate1 = criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), vaultLinearStates.get<PersistentStateRef>("stateRef")) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val joinPredicate2 = criteriaBuilder.and(criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), dummyLinearStates.get<PersistentStateRef>("stateRef"))) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val joinVaultStatesToCash = criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), cashStatesSchema.get<PersistentStateRef>("stateRef")) - MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val moreCash = vaultFiller.fillWithSomeTestCash(100.DOLLARS, services, 2, identity.ref(0), identity, Random(0L)).states MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$val schemaService = NodeSchemaService(extraSchemas = setOf(CashSchemaV1, SampleCashSchemaV1, SampleCashSchemaV2, SampleCashSchemaV3, DummyLinearStateSchemaV1, DummyLinearStateSchemaV2, DummyDealStateSchemaV1)) - MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest$vaultFiller.fillWithSomeTestLinearStates(1, externalId = "123", linearString = "123", linearNumber = 123, linearBoolean = true) MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest.<no name provided>$override val vaultService = NodeVaultService(Clock.systemUTC(), keyManagementService, servicesForResolution, database, schemaService, cordappClassloader).apply { start() } - MaxLineLength:HibernateConfigurationTest.kt$HibernateConfigurationTest.<no name provided>${ for (stx in txs) { (validatedTransactions as WritableTransactionStorage).addTransaction(stx) } // Refactored to use notifyAll() as we have no other unit test for that method with multiple transactions. vaultService.notifyAll(statesToRecord, txs.map { it.tx }) } - MaxLineLength:HibernateQueryCriteriaParser.kt$AbstractQueryCriteriaParser$LIKE_IGNORE_CASE -> criteriaBuilder.like(criteriaBuilder.upper(column), columnPredicate.rightLiteral.toUpperCase()) - MaxLineLength:HibernateQueryCriteriaParser.kt$AbstractQueryCriteriaParser$NOT_IN_IGNORE_CASE -> criteriaBuilder.not(criteriaBuilder.upper(column).`in`(literal.map { it.toUpperCase() })) - MaxLineLength:HibernateQueryCriteriaParser.kt$AbstractQueryCriteriaParser$NOT_LIKE_IGNORE_CASE -> criteriaBuilder.notLike(criteriaBuilder.upper(column), columnPredicate.rightLiteral.toUpperCase()) MaxLineLength:HibernateQueryCriteriaParser.kt$AbstractQueryCriteriaParser$abstract - MaxLineLength:HibernateQueryCriteriaParser.kt$AbstractQueryCriteriaParser$private MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateAttachmentQueryCriteriaParser$AbstractQueryCriteriaParser<AttachmentQueryCriteria, AttachmentsQueryCriteriaParser, AttachmentSort>(), AttachmentsQueryCriteriaParser - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateAttachmentQueryCriteriaParser$Sort.Direction.DESC -> orderCriteria.add(criteriaBuilder.desc(root.get<String>(sortAttribute.columnName))) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateAttachmentQueryCriteriaParser$private val criteriaQuery: CriteriaQuery<NodeAttachmentService.DBAttachment> MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateAttachmentQueryCriteriaParser$val joinDBAttachmentToContractClassNames = root.joinList<NodeAttachmentService.DBAttachment, ContractClassName>("contractClassNames") - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$Sort.Direction.ASC -> criteriaBuilder.asc(criteriaBuilder.literal<Int>(orderByColumnPosition - shiftLeft)) - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$Sort.Direction.DESC -> criteriaBuilder.desc(criteriaBuilder.literal<Int>(orderByColumnPosition - shiftLeft)) - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$Triple(VaultSchemaV1.VaultStates::class.java, sortAttribute.attributeParent, sortAttribute.attributeChild) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$commonPredicates.replace(predicateID, criteriaBuilder.and(vaultStates.get<String>(VaultSchemaV1.VaultStates::contractStateClassName.name).`in`(contractStateTypes.plus(existingTypes)))) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$commonPredicates.replace(predicateID, criteriaBuilder.and(vaultStates.get<Vault.ConstraintInfo.Type>(VaultSchemaV1.VaultStates::constraintType.name).`in`(criteria.constraintTypes.plus(existingTypes)))) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$commonPredicates.replace(predicateID, criteriaBuilder.equal(vaultStates.get<Vault.RelevancyStatus>(VaultSchemaV1.VaultStates::relevancyStatus.name), criteria.relevancyStatus)) @@ -5995,42 +3625,27 @@ MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$commonPredicates[predicateID] = criteriaBuilder.equal(vaultStates.get<Vault.RelevancyStatus>(VaultSchemaV1.VaultStates::relevancyStatus.name), criteria.relevancyStatus) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$commonPredicates[predicateID] = criteriaBuilder.equal(vaultStates.get<Vault.StateStatus>(VaultSchemaV1.VaultStates::stateStatus.name), criteria.status) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), entityRoot.get<IndirectStatePersistable<*>>("compositeKey").get<PersistentStateRef>("stateRef")) - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), entityRoot.get<PersistentStateRef>("stateRef")) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$elem MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$if (path is SingularAttributePath) //remove the same columns from different joins to match the single column in 'group by' only (from the last join) aggregateExpressions.removeAll { elem -> if (elem is SingularAttributePath) elem.attribute.javaMember == path.attribute.javaMember else false } - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$is SortAttribute.Custom -> Triple(sortAttribute.entityStateClass, sortAttribute.entityStateColumnName, null) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$log.warn("Enriching previous attribute [${VaultSchemaV1.VaultStates::constraintType.name}] values [$existingTypes] with [${criteria.constraintTypes}]") MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$log.warn("Enriching previous attribute [${VaultSchemaV1.VaultStates::contractStateClassName.name}] values [$existingTypes] with [$contractStateTypes]") MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$log.warn("Overriding previous attribute [${VaultSchemaV1.VaultStates::relevancyStatus.name}] value $existingStatus with ${criteria.status}") MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$log.warn("Overriding previous attribute [${VaultSchemaV1.VaultStates::stateStatus.name}] value $existingStatus with ${criteria.status}") MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$orderCriteria.add(criteriaBuilder.asc(sortEntityRoot.get<String>(entityStateAttributeParent).get<String>(entityStateAttributeChild))) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$orderCriteria.add(criteriaBuilder.desc(sortEntityRoot.get<String>(entityStateAttributeParent).get<String>(entityStateAttributeChild))) - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$override - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$predicateSet.add(criteriaBuilder.and(vaultStates.get<String>("lockId").`in`(softLocking.lockIds.map { it.toString() }))) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$private - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$private val commonPredicates = mutableMapOf<Pair<String, Operator>, Predicate>() // schema attribute Name, operator -> predicate MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$shiftLeft += columnNumberBeforeRemoval - aggregateExpressions.size MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$sorting.copy(columns = sorting.columns + Sort.SortColumn(SortAttribute.Standard(Sort.CommonStateAttribute.STATE_REF), Sort.Direction.ASC)) - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val actualSorting = if (sorting.columns.none { it.sortAttribute == SortAttribute.Standard(Sort.CommonStateAttribute.STATE_REF) }) { sorting.copy(columns = sorting.columns + Sort.SortColumn(SortAttribute.Standard(Sort.CommonStateAttribute.STATE_REF), Sort.Direction.ASC)) } else { sorting } - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val combinedPredicates = commonPredicates.values.plus(predicateSet).plus(constraintPredicates).plus(joinPredicates) - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val existingStatus = ((commonPredicates[predicateID] as ComparisonPredicate).rightHandOperand as LiteralExpression).literal MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val existingTypes = (commonPredicates[predicateID]!!.expressions[0] as InPredicate<*>).values.map { (it as LiteralExpression).literal }.toSet() MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val joinPredicate = criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), entityRoot.get<PersistentStateRef>("stateRef")) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val joinPredicate = criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), vaultFungibleStates.get<PersistentStateRef>("stateRef")) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val joinPredicate = criteriaBuilder.equal(vaultStates.get<PersistentStateRef>("stateRef"), vaultLinearStates.get<PersistentStateRef>("stateRef")) - MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val participantsPredicate = criteriaBuilder.and(entityRoot.get<VaultSchemaV1.PersistentParty>("x500Name").`in`(participants)) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val predicateConstraintData = criteriaBuilder.equal(vaultStates.get<Vault.ConstraintInfo>(VaultSchemaV1.VaultStates::constraintData.name), constraint.data()) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val predicateConstraintType = criteriaBuilder.equal(vaultStates.get<Vault.ConstraintInfo>(VaultSchemaV1.VaultStates::constraintType.name), constraint.type()) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val statePartyJoin = criteriaBuilder.equal(vaultStates.get<VaultSchemaV1.VaultStates>("stateRef"), entityRoot.get<VaultSchemaV1.PersistentParty>("compositeKey").get<PersistentStateRef>("stateRef")) MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser$val vaultStates: Root<VaultSchemaV1.VaultStates> MaxLineLength:HibernateQueryCriteriaParser.kt$HibernateQueryCriteriaParser${ @Suppress("UNCHECKED_CAST") column as Path<Long?>? val aggregateExpression = when (columnPredicate.type) { AggregateFunctionType.SUM -> criteriaBuilder.sum(column) AggregateFunctionType.AVG -> criteriaBuilder.avg(column) AggregateFunctionType.COUNT -> criteriaBuilder.count(column) AggregateFunctionType.MAX -> criteriaBuilder.max(column) AggregateFunctionType.MIN -> criteriaBuilder.min(column) } //TODO investigate possibility to avoid producing redundant joins in SQL for multiple aggregate functions against the same table aggregateExpressions.add(aggregateExpression) // Some databases may not support aggregate expression in 'group by' clause e.g. 'group by sum(col)', // Hibernate Criteria Builder can't produce alias 'group by col_alias', and the only solution is to use a positional parameter 'group by 1' val orderByColumnPosition = aggregateExpressions.size var shiftLeft = 0 // add optional group by clauses expression.groupByColumns?.let { columns -> val groupByExpressions = columns.map { _column -> val path = root.get<Any?>(getColumnName(_column)) val columnNumberBeforeRemoval = aggregateExpressions.size if (path is SingularAttributePath) //remove the same columns from different joins to match the single column in 'group by' only (from the last join) aggregateExpressions.removeAll { elem -> if (elem is SingularAttributePath) elem.attribute.javaMember == path.attribute.javaMember else false } shiftLeft += columnNumberBeforeRemoval - aggregateExpressions.size //record how many times a duplicated column was removed (from the previous 'parseAggregateFunction' run) aggregateExpressions.add(path) path } criteriaQuery.groupBy(groupByExpressions) } // optionally order by this aggregate function expression.orderBy?.let { val orderCriteria = when (expression.orderBy!!) { // when adding column position of 'group by' shift in case columns were removed Sort.Direction.ASC -> criteriaBuilder.asc(criteriaBuilder.literal<Int>(orderByColumnPosition - shiftLeft)) Sort.Direction.DESC -> criteriaBuilder.desc(criteriaBuilder.literal<Int>(orderByColumnPosition - shiftLeft)) } criteriaQuery.orderBy(orderCriteria) } return aggregateExpression } - MaxLineLength:HospitalisingInterceptor.kt$HospitalisingInterceptor : TransitionExecutor - MaxLineLength:HospitalisingInterceptor.kt$HospitalisingInterceptor$val (continuation, nextState) = delegate.executeTransition(fiber, previousState, event, transition, actionExecutor) MaxLineLength:HttpApi.kt$HttpApi.Companion$fun fromHostAndPort(hostAndPort: NetworkHostAndPort, base: String, protocol: String = "http", mapper: ObjectMapper = defaultMapper): HttpApi - MaxLineLength:HttpUtils.kt$HttpUtils$inline - MaxLineLength:HttpUtils.kt$HttpUtils$throw IOException("${request.method()} to ${request.url()} returned a ${response.code()}: ${response.body()?.string()}") - MaxLineLength:IOUFlow.kt$IOUFlow$val fullySignedTx = subFlow(CollectSignaturesFlow(signedTx, listOf(otherPartySession), CollectSignaturesFlow.tracker())) - MaxLineLength:IRS.kt$FixedRatePaymentEvent$"FixedRatePaymentEvent $accrualStartDate -> $accrualEndDate : $dayCountFactor : $days : $date : $notional : $rate : $flow" MaxLineLength:IRS.kt$FixedRatePaymentEvent$override val flow: Amount<Currency> get() = Amount(dayCountFactor.times(BigDecimal(notional.quantity)).times(rate.ratioUnit!!.value).toLong(), notional.token) MaxLineLength:IRS.kt$FloatingRatePaymentEvent$override fun asCSV(): String MaxLineLength:IRS.kt$FloatingRatePaymentEvent$override fun toString(): String @@ -6041,275 +3656,121 @@ MaxLineLength:IRS.kt$IRS$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBOR", tradeDate, Tenor("9M")), 1.0.bd)))) MaxLineLength:IRS.kt$IRS$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBOR", tradeDate.plusYears(1), Tenor("3M")), 1.0.bd)))) MaxLineLength:IRS.kt$IRS$command(highStreetBank.owningKey, UniversalContract.Commands.Fix(listOf(net.corda.finance.contracts.Fix(FixOf("LIBORx", tradeDate, Tenor("3M")), 1.0.bd)))) - MaxLineLength:IRS.kt$IRS$val nextFloating = interest(notional, "act/365", fix("LIBOR", start, Tenor("3M")), start, end) MaxLineLength:IRS.kt$InterestRateSwap : Contract - MaxLineLength:IRS.kt$InterestRateSwap$ private fun getFloatingLegPaymentsDifferences(payments1: Map<LocalDate, Event>, payments2: Map<LocalDate, Event>): List<Pair<LocalDate, Pair<FloatingRatePaymentEvent, FloatingRatePaymentEvent>>> - MaxLineLength:IRS.kt$InterestRateSwap$"All notionals must be non zero" using (irs.fixedLeg.notional.quantity > 0 && irs.floatingLeg.notional.quantity > 0) - MaxLineLength:IRS.kt$InterestRateSwap$"The changed payments dates are aligned" using (oldFloatingRatePaymentEvent.date == newFixedRatePaymentEvent.date) - MaxLineLength:IRS.kt$InterestRateSwap$"The currency of the notionals must be the same" using (irs.fixedLeg.notional.token == irs.floatingLeg.notional.token) MaxLineLength:IRS.kt$InterestRateSwap$"The effective date is before the termination date for the fixed leg" using (irs.fixedLeg.effectiveDate < irs.fixedLeg.terminationDate) MaxLineLength:IRS.kt$InterestRateSwap$"The effective date is before the termination date for the floating leg" using (irs.floatingLeg.effectiveDate < irs.floatingLeg.terminationDate) MaxLineLength:IRS.kt$InterestRateSwap$"The fix payment has the same currency as the notional" using (newFixedRatePaymentEvent.flow.token == irs.floatingLeg.notional.token) MaxLineLength:IRS.kt$InterestRateSwap$"The fixed leg parties are constant" using (irs.fixedLeg.fixedRatePayer == prevIrs.fixedLeg.fixedRatePayer) MaxLineLength:IRS.kt$InterestRateSwap$"The fixed leg payment schedule is constant" using (irs.calculation.fixedLegPaymentSchedule == prevIrs.calculation.fixedLegPaymentSchedule) - MaxLineLength:IRS.kt$InterestRateSwap$"The fixing is for the next required date" using (prevIrs.calculation.nextFixingDate() == fixValue.of.forDay) - MaxLineLength:IRS.kt$InterestRateSwap$"The new payment has the correct rate" using (newFixedRatePaymentEvent.rate.ratioUnit!!.value == fixValue.value) - MaxLineLength:IRS.kt$InterestRateSwap$"There is at least one difference in the IRS floating leg payment schedules" using !paymentDifferences.isEmpty() - MaxLineLength:IRS.kt$InterestRateSwap$Calculation MaxLineLength:IRS.kt$InterestRateSwap$TransactionBuilder(notary) .addCommand(Command(Commands.Agree(), listOf(state.floatingLeg.floatingRatePayer.owningKey, state.fixedLeg.fixedRatePayer.owningKey))) MaxLineLength:IRS.kt$InterestRateSwap$private MaxLineLength:IRS.kt$InterestRateSwap$tx.addCommand(Commands.Refix(fixing), listOf(irs.state.data.floatingLeg.floatingRatePayer.owningKey, irs.state.data.fixedLeg.fixedRatePayer.owningKey)) MaxLineLength:IRS.kt$InterestRateSwap$val (oldFloatingRatePaymentEvent, newFixedRatePaymentEvent) = paymentDifferences.single().second // Ignore the date of the changed rate (we checked that earlier). - MaxLineLength:IRS.kt$InterestRateSwap$val groups: List<LedgerTransaction.InOutGroup<State, UniqueIdentifier>> = tx.groupStates { state -> state.linearId } MaxLineLength:IRS.kt$InterestRateSwap$val paymentDifferences = getFloatingLegPaymentsDifferences(prevIrs.calculation.floatingLegPaymentSchedule, irs.calculation.floatingLegPaymentSchedule) MaxLineLength:IRS.kt$InterestRateSwap.Calculation$return floatingLegPaymentSchedule.filter { it.value.rate is ReferenceRate }.// TODO - a better way to determine what fixings remain to be fixed minBy { it.value.fixingDate.toEpochDay() }?.value?.fixingDate - MaxLineLength:IRS.kt$InterestRateSwap.Commands$Mature : TypeOnlyCommandDataCommands MaxLineLength:IRS.kt$InterestRateSwap.Common$val valuationDateDescription: String MaxLineLength:IRS.kt$InterestRateSwap.CommonLeg$"PaymentRule=$paymentRule,PaymentDelay=$paymentDelay,PaymentCalendar=$paymentCalendar,InterestPeriodAdjustment=$interestPeriodAdjustment" MaxLineLength:IRS.kt$InterestRateSwap.CommonLeg$"TerminationDateAdjustment=$terminationDateAdjustment,DayCountBasis=$dayCountBasisDay/$dayCountBasisYear,DayInMonth=$dayInMonth," - MaxLineLength:IRS.kt$InterestRateSwap.CommonLeg$dayCountBasisDay - MaxLineLength:IRS.kt$InterestRateSwap.CommonLeg$effectiveDateAdjustment MaxLineLength:IRS.kt$InterestRateSwap.CommonLeg$return "Notional=$notional,PaymentFrequency=$paymentFrequency,EffectiveDate=$effectiveDate,EffectiveDateAdjustment:$effectiveDateAdjustment,TerminatationDate=$terminationDate," + "TerminationDateAdjustment=$terminationDateAdjustment,DayCountBasis=$dayCountBasisDay/$dayCountBasisYear,DayInMonth=$dayInMonth," + "PaymentRule=$paymentRule,PaymentDelay=$paymentDelay,PaymentCalendar=$paymentCalendar,InterestPeriodAdjustment=$interestPeriodAdjustment" - MaxLineLength:IRS.kt$InterestRateSwap.FixedLeg$dayCountBasisDay - MaxLineLength:IRS.kt$InterestRateSwap.FixedLeg$override MaxLineLength:IRS.kt$InterestRateSwap.FloatingLeg$"FixingPeriondOffset=$fixingPeriodOffset,ResetRule=$resetRule,FixingsPerPayment=$fixingsPerPayment,FixingCalendar=$fixingCalendar," - MaxLineLength:IRS.kt$InterestRateSwap.FloatingLeg$"rollConvention=$rollConvention,FixingRollConvention=$fixingRollConvention,ResetDayInMonth=$resetDayInMonth" - MaxLineLength:IRS.kt$InterestRateSwap.FloatingLeg$( var floatingRatePayer: AbstractParty, notional: Amount<Currency>, paymentFrequency: Frequency, effectiveDate: LocalDate, effectiveDateAdjustment: DateRollConvention?, terminationDate: LocalDate, terminationDateAdjustment: DateRollConvention?, dayCountBasisDay: DayCountBasisDay, dayCountBasisYear: DayCountBasisYear, dayInMonth: Int, paymentRule: PaymentRule, paymentDelay: Int, paymentCalendar: BusinessCalendar, interestPeriodAdjustment: AccrualAdjustment, var rollConvention: DateRollConvention, var fixingRollConvention: DateRollConvention, var resetDayInMonth: Int, var fixingPeriodOffset: Int, var resetRule: PaymentRule, var fixingsPerPayment: Frequency, var fixingCalendar: BusinessCalendar, var index: String, var indexSource: String, var indexTenor: Tenor ) - MaxLineLength:IRS.kt$InterestRateSwap.FloatingLeg$dayCountBasisDay MaxLineLength:IRS.kt$InterestRateSwap.State$InterestRateSwap().generateFix(ptx, StateAndRef(TransactionState(this, IRS_PROGRAM_ID, oldState.state.notary, constraint = AlwaysAcceptAttachmentConstraint), oldState.ref), fix) - MaxLineLength:IRS.kt$InterestRateSwap.State$override - MaxLineLength:IRS.kt$InterestRateSwap.State$return ScheduledActivity(flowLogicRefFactory.create("net.corda.irs.flows.FixingFlow\$FixingRoleDecider", thisStateRef), instant) MaxLineLength:IRS.kt$InterestRateSwap.State$val instant = suggestInterestRateAnnouncementTimeWindow(index = nextFixingOf.name, source = floatingLeg.indexSource, date = nextFixingOf.forDay).fromTime!! MaxLineLength:IRS.kt$InterestRateSwap.State${ val nextFixingOf = nextFixingOf() ?: return null // This is perhaps not how we should determine the time point in the business day, but instead expect the schedule to detail some of these aspects val instant = suggestInterestRateAnnouncementTimeWindow(index = nextFixingOf.name, source = floatingLeg.indexSource, date = nextFixingOf.forDay).fromTime!! return ScheduledActivity(flowLogicRefFactory.create("net.corda.irs.flows.FixingFlow\$FixingRoleDecider", thisStateRef), instant) } - MaxLineLength:IRS.kt$PaymentEvent : Event MaxLineLength:IRS.kt$RatePaymentEvent$// TODO : Fix below (use daycount convention for division, not hardcoded 360 etc) val dayCountFactor: BigDecimal get() = (BigDecimal(days).divide(BigDecimal(360.0), 8, RoundingMode.HALF_UP)).setScale(4, RoundingMode.HALF_UP) - MaxLineLength:IRS.kt$RatePaymentEvent$open fun asCSV() - MaxLineLength:IRS.kt$RatePaymentEvent$val days: Int get() = BusinessCalendar.calculateDaysBetween(accrualStartDate, accrualEndDate, dayCountBasisYear, dayCountBasisDay) - MaxLineLength:IRS.kt$UnknownType MaxLineLength:IRSDemo.kt$Role.Trade -> IRSDemoClientApi(NetworkHostAndPort("localhost", 10007)).runTrade(value, CordaX500Name.parse("O=Notary Service,L=Zurich,C=CH")) MaxLineLength:IRSDemoDockerTest.kt$IRSDemoDockerTest.Companion$DockerComposeRule.builder() .files(DockerComposeFiles.from( System.getProperty("CORDAPP_DOCKER_COMPOSE"), System.getProperty("WEB_DOCKER_COMPOSE"))) .waitingForService("web-a", HealthChecks.toRespondOverHttp(8080, { port -> port.inFormat("http://\$HOST:\$EXTERNAL_PORT") })) - MaxLineLength:IRSDemoDockerTest.kt$IRSDemoDockerTest.Companion$throw IllegalStateException("System property $property not set. Please refer to README file for proper setup instructions.") - MaxLineLength:IRSDemoTest.kt$IRSDemoTest$InterestRateSwapStateDeserializer : JsonDeserializer - MaxLineLength:IRSDemoTest.kt$IRSDemoTest$return IOUtils.toString(Thread.currentThread().contextClassLoader.getResourceAsStream(filename), Charsets.UTF_8.name()) MaxLineLength:IRSDemoTest.kt$IRSDemoTest$val (controllerApi, nodeAApi, nodeBApi) = listOf(controller, nodeA, nodeB).zip(listOf(controllerAddr, nodeAAddr, nodeBAddr)).map { val mapper = JacksonSupport.createDefaultMapper(it.first.rpc) registerFinanceJSONMappers(mapper) registerIRSModule(mapper) HttpApi.fromHostAndPort(it.second, "api/irs", mapper = mapper) } MaxLineLength:IRSDemoTest.kt$IRSDemoTest.InterestRateSwapStateDeserializer$InterestRateSwap.State(fixedLeg = fixedLeg, floatingLeg = floatingLeg, calculation = calculation, common = common, linearId = linearId, oracle = oracle) - MaxLineLength:IRSExport.kt$this.calculation.floatingLegPaymentSchedule.toSortedMap().values.joinToString("\n") { it.asCSV() } - MaxLineLength:IRSState.kt$IRSState$override val linearId: UniqueIdentifier = UniqueIdentifier(swap.id.first + swap.id.second) MaxLineLength:IRSState.kt$IRSState$return TransactionBuilder(notary).withItems(StateAndContract(state, IRS_PROGRAM_ID), Command(OGTrade.Commands.Agree(), participants.map { it.owningKey })) MaxLineLength:IRSTests.kt$"(floatingLeg.notional.pennies * (calculation.fixingSchedule.get(context.getDate('currentDate')).rate.ratioUnit.value))" MaxLineLength:IRSTests.kt$( // TODO: this seems to fail quite dramatically //expression = "fixedLeg.notional * fixedLeg.fixedRate", // TODO: How I want it to look //expression = "( fixedLeg.notional * (fixedLeg.fixedRate)) - (floatingLeg.notional * (rateSchedule.get(context.getDate('currentDate'))))", // How it's ended up looking, which I think is now broken but it's a WIP. expression = Expression("( fixedLeg.notional.pennies * (fixedLeg.fixedRate.ratioUnit.value)) -" + "(floatingLeg.notional.pennies * (calculation.fixingSchedule.get(context.getDate('currentDate')).rate.ratioUnit.value))"), floatingLegPaymentSchedule = mutableMapOf(), fixedLegPaymentSchedule = mutableMapOf() ) - MaxLineLength:IRSTests.kt$IRSTests$ fun tradegroups(): LedgerDSL<TestTransactionDSLInterpreter, TestLedgerDSLInterpreter> MaxLineLength:IRSTests.kt$IRSTests$( "fixedLeg.notional.quantity", "fixedLeg.fixedRate.ratioUnit", "fixedLeg.fixedRate.ratioUnit.value", "floatingLeg.notional.quantity", "fixedLeg.fixedRate", "currentBusinessDate", "calculation.floatingLegPaymentSchedule.get(currentBusinessDate)", "fixedLeg.notional.token.currencyCode", "fixedLeg.notional.quantity * 10", "fixedLeg.notional.quantity * fixedLeg.fixedRate.ratioUnit.value", "(fixedLeg.notional.token.currencyCode.equals('GBP')) ? 365 : 360 ", "(fixedLeg.notional.quantity * (fixedLeg.fixedRate.ratioUnit.value))" // "calculation.floatingLegPaymentSchedule.get(context.getDate('currentDate')).rate" // "calculation.floatingLegPaymentSchedule.get(context.getDate('currentDate')).rate.ratioUnit.value", //"( fixedLeg.notional.pennies * (fixedLeg.fixedRate.ratioUnit.value)) - (floatingLeg.notional.pennies * (calculation.fixingSchedule.get(context.getDate('currentDate')).rate.ratioUnit.value))", // "( fixedLeg.notional * fixedLeg.fixedRate )" ) - MaxLineLength:IRSTests.kt$IRSTests$attachments(IRS_PROGRAM_ID) input(IRS_PROGRAM_ID, oldIRS) // Templated tweak for reference. A corrent fixing applied should be ok tweak { command(ORACLE_PUBKEY, InterestRateSwap.Commands.Refix(Fix(FixOf("ICE LIBOR", ld, Tenor("3M")), bd))) timeWindow(TEST_TX_TIME) output(IRS_PROGRAM_ID, newIRS) this.verifies() } // This test makes sure that verify confirms the fixing was applied and there is a difference in the old and new tweak { command(ORACLE_PUBKEY, InterestRateSwap.Commands.Refix(Fix(FixOf("ICE LIBOR", ld, Tenor("3M")), bd))) timeWindow(TEST_TX_TIME) output(IRS_PROGRAM_ID, oldIRS) this `fails with` "There is at least one difference in the IRS floating leg payment schedules" } // This tests tries to sneak in a change to another fixing (which may or may not be the latest one) tweak { command(ORACLE_PUBKEY, InterestRateSwap.Commands.Refix(Fix(FixOf("ICE LIBOR", ld, Tenor("3M")), bd))) timeWindow(TEST_TX_TIME) val firstResetKey = newIRS.calculation.floatingLegPaymentSchedule.keys.toList()[1] val firstResetValue = newIRS.calculation.floatingLegPaymentSchedule[firstResetKey] val modifiedFirstResetValue = firstResetValue!!.copy(notional = Amount(firstResetValue.notional.quantity, Currency.getInstance("JPY"))) output(IRS_PROGRAM_ID, newIRS.copy( newIRS.fixedLeg, newIRS.floatingLeg, newIRS.calculation.copy(floatingLegPaymentSchedule = newIRS.calculation.floatingLegPaymentSchedule.plus( Pair(firstResetKey, modifiedFirstResetValue))), newIRS.common)) this `fails with` "There is only one change in the IRS floating leg payment schedule" } // This tests modifies the payment currency for the fixing tweak { command(ORACLE_PUBKEY, InterestRateSwap.Commands.Refix(Fix(FixOf("ICE LIBOR", ld, Tenor("3M")), bd))) timeWindow(TEST_TX_TIME) val latestReset = newIRS.calculation.floatingLegPaymentSchedule.filter { it.value.rate is FixedRate }.maxBy { it.key } val modifiedLatestResetValue = latestReset!!.value.copy(notional = Amount(latestReset.value.notional.quantity, Currency.getInstance("JPY"))) output(IRS_PROGRAM_ID, newIRS.copy( newIRS.fixedLeg, newIRS.floatingLeg, newIRS.calculation.copy(floatingLegPaymentSchedule = newIRS.calculation.floatingLegPaymentSchedule.plus( Pair(latestReset.key, modifiedLatestResetValue))), newIRS.common)) this `fails with` "The fix payment has the same currency as the notional" } - MaxLineLength:IRSTests.kt$IRSTests$newIRS.calculation - MaxLineLength:IRSTests.kt$IRSTests$output(IRS_PROGRAM_ID, irs.copy(calculation = irs.calculation.copy(fixedLegPaymentSchedule = emptySchedule))) - MaxLineLength:IRSTests.kt$IRSTests$output(IRS_PROGRAM_ID, irs.copy(calculation = irs.calculation.copy(floatingLegPaymentSchedule = emptySchedule))) - MaxLineLength:IRSTests.kt$IRSTests$private val notaryServices = MockServices(cordappPackages, dummyNotary, mock(), networkParameters, dummyNotary.keyPair) - MaxLineLength:IRSTests.kt$IRSTests$val latestReset = newIRS.calculation.floatingLegPaymentSchedule.filter { it.value.rate is FixedRate }.maxBy { it.key } MaxLineLength:IRSTests.kt$IRSTests$val modifiedFirstResetValue = firstResetValue!!.copy(notional = Amount(firstResetValue.notional.quantity, Currency.getInstance("JPY"))) MaxLineLength:IRSTests.kt$IRSTests$val modifiedIRS = irs.copy(fixedLeg = irs.fixedLeg.copy(notional = Amount(irs.fixedLeg.notional.quantity, Currency.getInstance("JPY")))) MaxLineLength:IRSTests.kt$IRSTests$val modifiedIRS = irs.copy(fixedLeg = irs.fixedLeg.copy(notional = Amount(irs.floatingLeg.notional.quantity + 1, irs.floatingLeg.notional.token))) - MaxLineLength:IRSTests.kt$IRSTests$val modifiedIRS1 = irs.copy(fixedLeg = irs.fixedLeg.copy(terminationDate = irs.fixedLeg.effectiveDate.minusDays(1))) - MaxLineLength:IRSTests.kt$IRSTests$val modifiedIRS2 = irs.copy(floatingLeg = irs.floatingLeg.copy(terminationDate = irs.floatingLeg.effectiveDate.minusDays(1))) - MaxLineLength:IRSTests.kt$IRSTests$val modifiedIRS3 = irs.copy(floatingLeg = irs.floatingLeg.copy(terminationDate = irs.fixedLeg.terminationDate.minusDays(1))) - MaxLineLength:IRSTests.kt$IRSTests$val modifiedIRS4 = irs.copy(floatingLeg = irs.floatingLeg.copy(effectiveDate = irs.fixedLeg.effectiveDate.minusDays(1))) MaxLineLength:IRSTests.kt$IRSTests$val modifiedLatestResetValue = latestReset!!.value.copy(notional = Amount(latestReset.value.notional.quantity, Currency.getInstance("JPY"))) - MaxLineLength:IRSTests.kt$IRSTests${ val dummyIRS = singleIRS() val stuffToPrint: ArrayList<String> = arrayListOf( "fixedLeg.notional.quantity", "fixedLeg.fixedRate.ratioUnit", "fixedLeg.fixedRate.ratioUnit.value", "floatingLeg.notional.quantity", "fixedLeg.fixedRate", "currentBusinessDate", "calculation.floatingLegPaymentSchedule.get(currentBusinessDate)", "fixedLeg.notional.token.currencyCode", "fixedLeg.notional.quantity * 10", "fixedLeg.notional.quantity * fixedLeg.fixedRate.ratioUnit.value", "(fixedLeg.notional.token.currencyCode.equals('GBP')) ? 365 : 360 ", "(fixedLeg.notional.quantity * (fixedLeg.fixedRate.ratioUnit.value))" // "calculation.floatingLegPaymentSchedule.get(context.getDate('currentDate')).rate" // "calculation.floatingLegPaymentSchedule.get(context.getDate('currentDate')).rate.ratioUnit.value", //"( fixedLeg.notional.pennies * (fixedLeg.fixedRate.ratioUnit.value)) - (floatingLeg.notional.pennies * (calculation.fixingSchedule.get(context.getDate('currentDate')).rate.ratioUnit.value))", // "( fixedLeg.notional * fixedLeg.fixedRate )" ) for (i in stuffToPrint) { println(i) val z = dummyIRS.evaluateCalculation(LocalDate.of(2016, 9, 15), Expression(i)) println(z.javaClass) println(z) println("-----------") } // This does not throw an exception in the test itself; it evaluates the above and they will throw if they do not pass. } MaxLineLength:IRSTests.kt$InterestRateSwap.State(fixedLeg = fixedLeg, floatingLeg = floatingLeg, calculation = calculation, common = common, oracle = DUMMY_PARTY) MaxLineLength:IRSTests.kt$dailyInterestAmount = Expression("(CashAmount * InterestRate ) / (fixedLeg.notional.currency.currencyCode.equals('GBP')) ? 365 : 360") - MaxLineLength:IRSTests.kt$resolutionTime = "2:00pm London time on the first LocalBusiness Day following the date on which the notice is given " MaxLineLength:IRSTests.kt$return InterestRateSwap.State(fixedLeg = fixedLeg, floatingLeg = floatingLeg, calculation = calculation, common = common, oracle = DUMMY_PARTY) MaxLineLength:IRSTests.kt${ // 10y swap, we pay 1.3% fixed 30/360 semi, rec 3m usd libor act/360 Q on 25m notional (mod foll/adj on both sides) // I did a mock up start date 10/03/2015 – 10/03/2025 so you have 5 cashflows on float side that have been preset the rest are unknown val fixedLeg = InterestRateSwap.FixedLeg( fixedRatePayer = MEGA_CORP, notional = 25000000.DOLLARS, paymentFrequency = Frequency.SemiAnnual, effectiveDate = LocalDate.of(2015, 3, 10), effectiveDateAdjustment = null, terminationDate = LocalDate.of(2025, 3, 10), terminationDateAdjustment = null, fixedRate = FixedRate(PercentageRatioUnit("1.3")), dayCountBasisDay = DayCountBasisDay.D30, dayCountBasisYear = DayCountBasisYear.Y360, rollConvention = DateRollConvention.ModifiedFollowing, dayInMonth = 10, paymentRule = PaymentRule.InArrears, paymentDelay = 0, paymentCalendar = BusinessCalendar.EMPTY, interestPeriodAdjustment = AccrualAdjustment.Adjusted ) val floatingLeg = InterestRateSwap.FloatingLeg( floatingRatePayer = MINI_CORP, notional = 25000000.DOLLARS, paymentFrequency = Frequency.Quarterly, effectiveDate = LocalDate.of(2015, 3, 10), effectiveDateAdjustment = null, terminationDate = LocalDate.of(2025, 3, 10), terminationDateAdjustment = null, dayCountBasisDay = DayCountBasisDay.DActual, dayCountBasisYear = DayCountBasisYear.Y360, rollConvention = DateRollConvention.ModifiedFollowing, fixingRollConvention = DateRollConvention.ModifiedFollowing, dayInMonth = 10, resetDayInMonth = 10, paymentRule = PaymentRule.InArrears, paymentDelay = 0, paymentCalendar = BusinessCalendar.EMPTY, interestPeriodAdjustment = AccrualAdjustment.Adjusted, fixingPeriodOffset = 2, resetRule = PaymentRule.InAdvance, fixingsPerPayment = Frequency.Quarterly, fixingCalendar = BusinessCalendar.EMPTY, index = "USD LIBOR", indexSource = "TEL3750", indexTenor = Tenor("3M") ) val calculation = InterestRateSwap.Calculation( // TODO: this seems to fail quite dramatically //expression = "fixedLeg.notional * fixedLeg.fixedRate", // TODO: How I want it to look //expression = "( fixedLeg.notional * (fixedLeg.fixedRate)) - (floatingLeg.notional * (rateSchedule.get(context.getDate('currentDate'))))", // How it's ended up looking, which I think is now broken but it's a WIP. expression = Expression("( fixedLeg.notional.pennies * (fixedLeg.fixedRate.ratioUnit.value)) -" + "(floatingLeg.notional.pennies * (calculation.fixingSchedule.get(context.getDate('currentDate')).rate.ratioUnit.value))"), floatingLegPaymentSchedule = mutableMapOf(), fixedLegPaymentSchedule = mutableMapOf() ) val common = InterestRateSwap.Common( baseCurrency = EUR, eligibleCurrency = EUR, eligibleCreditSupport = "Cash in an Eligible Currency", independentAmounts = Amount(0, EUR), threshold = Amount(0, EUR), minimumTransferAmount = Amount(250000 * 100, EUR), rounding = Amount(10000 * 100, EUR), valuationDateDescription = "Every Local Business Day", notificationTime = "2:00pm London", resolutionTime = "2:00pm London time on the first LocalBusiness Day following the date on which the notice is given ", interestRate = ReferenceRate("T3270", Tenor("6M"), "EONIA"), addressForTransfers = "", exposure = UnknownType(), localBusinessDay = loadTestCalendar("London"), tradeID = "trade2", hashLegalDocs = "put hash here", dailyInterestAmount = Expression("(CashAmount * InterestRate ) / (fixedLeg.notional.currency.currencyCode.equals('GBP')) ? 365 : 360") ) return InterestRateSwap.State(fixedLeg = fixedLeg, floatingLeg = floatingLeg, calculation = calculation, common = common, oracle = DUMMY_PARTY) } MaxLineLength:IRSTradeFlow.kt$IRSTradeFlow.Requester$val notary = serviceHub.networkMapCache.notaryIdentities.first() // TODO We should pass the notary as a parameter to the flow, not leave it to random choice. - MaxLineLength:IRSUtils.kt$PercentageRatioUnit$open MaxLineLength:IRSUtils.kt$net.corda.irs.contract.IRSUtils.kt MaxLineLength:IRSUtils.kt$operator - MaxLineLength:IRSUtils.kt$operator fun kotlin.Int.times(other: FixedRate): Int - MaxLineLength:Id.kt$Id.Companion$ @DeleteForDJVM @JvmStatic fun <V : Any> newInstance(value: V, entityType: String? = null, timestamp: Instant = now()) - MaxLineLength:IdempotentFlowTests.kt$IdempotentFlowTests.TimedSubflow$subFlowExecutionCounter.incrementAndGet() MaxLineLength:IdenticonRenderer.kt$IdenticonRenderer$private MaxLineLength:IdenticonRenderer.kt$IdenticonRenderer$private val patchFlags = byteArrayOf(PATCH_SYMMETRIC, 0, 0, 0, PATCH_SYMMETRIC, 0, 0, 0, PATCH_SYMMETRIC, 0, 0, 0, 0, 0, 0, (PATCH_SYMMETRIC + PATCH_INVERTED).toByte()) - MaxLineLength:IdenticonRenderer.kt$IdenticonRenderer.Patch$return byteArray.map(Byte::toInt).map { it % PATCH_GRIDS * (patchSize / PATCH_CELLS) - patchSize / 2 }.toDoubleArray() - MaxLineLength:IdenticonRenderer.kt$IdenticonRenderer.Patch$return byteArray.map(Byte::toInt).map { it / PATCH_GRIDS * (patchSize / PATCH_CELLS) - patchSize / 2 }.toDoubleArray() - MaxLineLength:IdenticonRenderer.kt$IdenticonRenderer.PatchColor$private - MaxLineLength:IdentityService.kt$IdentityService$ fun wellKnownPartyFromX500Name(name: CordaX500Name): Party? - MaxLineLength:IdentityService.kt$IdentityService$@Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) - MaxLineLength:IdentityService.kt$IdentityService${ // The original version of this would return the party as-is if it was a Party (rather than AnonymousParty), // however that means that we don't verify that we know who owns the key. As such as now enforce turning the key // into a party, and from there figure out the well known party. val candidate = partyFromKey(party.owningKey) // TODO: This should be done via the network map cache, which is the authoritative source of well known identities return if (candidate != null) { require(party.nameOrNull() == null || party.nameOrNull() == candidate.name) { "Candidate party $candidate does not match expected $party" } wellKnownPartyFromX500Name(candidate.name) } else { null } } MaxLineLength:IdentityServiceInternal.kt$IdentityServiceInternal$ @Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) fun verifyAndRegisterIdentity(identity: PartyAndCertificate, isNewRandomIdentity: Boolean): PartyAndCertificate? MaxLineLength:IdentityServiceInternal.kt$IdentityServiceInternal$ @Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) fun verifyAndRegisterIdentity(trustAnchor: TrustAnchor, identity: PartyAndCertificate, isNewRandomIdentity: Boolean = false): PartyAndCertificate? - MaxLineLength:IdentityServiceInternal.kt$IdentityServiceInternal$ fun justVerifyAndRegisterIdentity(identity: PartyAndCertificate, isNewRandomIdentity: Boolean = false) - MaxLineLength:IdentityServiceInternal.kt$IdentityServiceInternal$@Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) MaxLineLength:IdentityServiceInternal.kt$IdentityServiceInternal$log.warn("Certificate validation failed for ${identity.name} against trusted root ${trustAnchor.trustedCert.subjectX500Principal}.") MaxLineLength:IdentityServiceInternal.kt$IdentityServiceInternal$val components = listOfNotNull(x500name.commonName, x500name.organisationUnit, x500name.organisation, x500name.locality, x500name.state, x500name.country) - MaxLineLength:IdentityServiceInternal.kt$IdentityServiceInternal${ private companion object { val log = contextLogger() } /** This method exists so it can be mocked with doNothing, rather than having to make up a possibly invalid return value. */ fun justVerifyAndRegisterIdentity(identity: PartyAndCertificate, isNewRandomIdentity: Boolean = false) { verifyAndRegisterIdentity(identity, isNewRandomIdentity) } /** * Verify and then store an identity. * * @param identity a party and the certificate path linking them to the network trust root. * @param isNewRandomIdentity true if the identity will not have been registered before (e.g. because it is randomly generated by ourselves). * @return the issuing entity, if known. * @throws IllegalArgumentException if the certificate path is invalid. */ @Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) fun verifyAndRegisterIdentity(identity: PartyAndCertificate, isNewRandomIdentity: Boolean): PartyAndCertificate? // We can imagine this being a query over a lucene index in future. // // Kostas says: When exactMatch = false, we can easily use the Jaro-Winkler distance metric as it is best suited for short // strings such as entity/company names, and to detect small typos. We can also apply it for city // or any keyword related search in lists of records (not raw text - for raw text we need indexing) // and we can return results in hierarchical order (based on normalised String similarity 0.0-1.0). /** Check if [x500name] matches the [query]. */ fun x500Matches(query: String, exactMatch: Boolean, x500name: CordaX500Name): Boolean { val components = listOfNotNull(x500name.commonName, x500name.organisationUnit, x500name.organisation, x500name.locality, x500name.state, x500name.country) return components.any { (exactMatch && it == query) || (!exactMatch && it.contains(query, ignoreCase = true)) } } /** * Verifies that an identity is valid. * * @param trustAnchor The trust anchor that will verify the identity's validity * @param identity The identity to verify * @param isNewRandomIdentity true if the identity will not have been registered before (e.g. because it is randomly generated by ourselves). */ @Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) fun verifyAndRegisterIdentity(trustAnchor: TrustAnchor, identity: PartyAndCertificate, isNewRandomIdentity: Boolean = false): PartyAndCertificate? { // Validate the chain first, before we do anything clever with it val identityCertChain = identity.certPath.x509Certificates try { identity.verify(trustAnchor) } catch (e: CertPathValidatorException) { log.warn("Certificate validation failed for ${identity.name} against trusted root ${trustAnchor.trustedCert.subjectX500Principal}.") log.warn("Certificate path :") identityCertChain.reversed().forEachIndexed { index, certificate -> val space = (0 until index).joinToString("") { " " } log.warn("$space${certificate.subjectX500Principal}") } throw e } // Ensure we record the first identity of the same name, first val wellKnownCert = identityCertChain.single { CertRole.extract(it)?.isWellKnown ?: false } if (wellKnownCert != identity.certificate && !isNewRandomIdentity) { val idx = identityCertChain.lastIndexOf(wellKnownCert) val firstPath = X509Utilities.buildCertPath(identityCertChain.slice(idx until identityCertChain.size)) verifyAndRegisterIdentity(trustAnchor, PartyAndCertificate(firstPath)) } return registerIdentity(identity, isNewRandomIdentity) } fun registerIdentity(identity: PartyAndCertificate, isNewRandomIdentity: Boolean = false): PartyAndCertificate? } MaxLineLength:IdentitySyncFlow.kt$IdentitySyncFlow.Receive$// Store the received confidential identities in the identity service so we have a record of which well known identity they map to. serviceHub.identityService.verifyAndRegisterIdentity(identity) - MaxLineLength:IdentitySyncFlow.kt$IdentitySyncFlow.Receive$val unknownIdentities = allIdentities.filter { serviceHub.identityService.wellKnownPartyFromAnonymous(it) == null } - MaxLineLength:IdentitySyncFlow.kt$IdentitySyncFlow.Receive${ progressTracker.currentStep = RECEIVING_IDENTITIES val allIdentities = otherSideSession.receive<List<AbstractParty>>().unwrap { it } val unknownIdentities = allIdentities.filter { serviceHub.identityService.wellKnownPartyFromAnonymous(it) == null } progressTracker.currentStep = RECEIVING_CERTIFICATES val missingIdentities = otherSideSession.sendAndReceive<List<PartyAndCertificate>>(unknownIdentities) // Batch verify the identities we've received, so we know they're all correct before we start storing them in // the identity service missingIdentities.unwrap { identities -> identities.forEach { it.verify(serviceHub.identityService.trustAnchor) } identities }.forEach { identity -> // Store the received confidential identities in the identity service so we have a record of which well known identity they map to. serviceHub.identityService.verifyAndRegisterIdentity(identity) } } MaxLineLength:IdentitySyncFlow.kt$IdentitySyncFlow.Send$confidentialIdentities .map { Pair(it, serviceHub.identityService.certificateFromKey(it.owningKey)) } // Filter down to confidential identities of our well known identity // TODO: Consider if this too restrictive - we perhaps should be checking the name on the signing certificate in the certificate path instead .filter { it.second?.name == ourIdentity.name } MaxLineLength:IdentitySyncFlow.kt$IdentitySyncFlow.Send$require(req.all { it in identityCertificates.keys }) { "${otherSideSession.counterparty} requested a confidential identity not part of transaction: ${tx.id}" } MaxLineLength:IdentitySyncFlow.kt$IdentitySyncFlow.Send$throw IllegalStateException("Counterparty requested a confidential identity for which we do not have the certificate path: ${tx.id}") MaxLineLength:IdentitySyncFlow.kt$IdentitySyncFlow.Send$val requestedIdentities: List<AbstractParty> = otherSideSession.sendAndReceive<List<AbstractParty>>(identityCertificates.keys.toList()).unwrap { req -> require(req.all { it in identityCertificates.keys }) { "${otherSideSession.counterparty} requested a confidential identity not part of transaction: ${tx.id}" } req } - MaxLineLength:IdentitySyncFlowTests.kt$IdentitySyncFlowTests$aliceNode.database.transaction { aliceNode.services.identityService.verifyAndRegisterIdentity(confidentialIdentCert) } MaxLineLength:IdentitySyncFlowTests.kt$IdentitySyncFlowTests$assertNotNull(aliceNode.database.transaction { aliceNode.services.identityService.wellKnownPartyFromAnonymous(confidentialIdentity) }) - MaxLineLength:IdentitySyncFlowTests.kt$IdentitySyncFlowTests$assertNull(bobNode.database.transaction { bobNode.services.identityService.wellKnownPartyFromAnonymous(confidentialIdentity) }) - MaxLineLength:IdentitySyncFlowTests.kt$IdentitySyncFlowTests$val confidentialIdentCert = charlieNode.services.identityService.certificateFromKey(confidentialIdentity.owningKey)!! - MaxLineLength:IdentitySyncFlowTests.kt$IdentitySyncFlowTests$val issueFlow = aliceNode.services.startFlow(CashIssueAndPaymentFlow(1000.DOLLARS, ref, alice, anonymous, notary)).resultFuture - MaxLineLength:IdentitySyncFlowTests.kt$IdentitySyncFlowTests$val issueFlow = charlieNode.services.startFlow(CashIssueAndPaymentFlow(1000.DOLLARS, ref, charlie, anonymous, notary)) - MaxLineLength:IdentitySyncFlowTests.kt$IdentitySyncFlowTests$val payTx = charlieNode.services.startFlow(CashPaymentFlow(1000.DOLLARS, alice, anonymous)).resultFuture.getOrThrow().stx - MaxLineLength:IdentityUtils.kt$ // Cannot use @JvmOverloads in interface @Throws(IllegalArgumentException::class) fun groupAbstractPartyByWellKnownParty(serviceHub: ServiceHub, parties: Collection<AbstractParty>): Map<Party, List<AbstractParty>> MaxLineLength:IdentityUtils.kt$ // Cannot use @JvmOverloads in interface @Throws(IllegalArgumentException::class) fun groupPublicKeysByWellKnownParty(serviceHub: ServiceHub, publicKeys: Collection<PublicKey>): Map<Party, List<PublicKey>> MaxLineLength:IdentityUtils.kt$ @Throws(IllegalArgumentException::class) fun groupAbstractPartyByWellKnownParty(serviceHub: ServiceHub, parties: Collection<AbstractParty>, ignoreUnrecognisedParties: Boolean): Map<Party, List<AbstractParty>> MaxLineLength:IdentityUtils.kt$ @Throws(IllegalArgumentException::class) fun groupPublicKeysByWellKnownParty(serviceHub: ServiceHub, publicKeys: Collection<PublicKey>, ignoreUnrecognisedParties: Boolean): Map<Party, List<PublicKey>> MaxLineLength:IdentityUtils.kt$ fun <T> excludeHostNode(serviceHub: ServiceHub, map: Map<Party, T>): Map<Party, T> MaxLineLength:IdentityUtils.kt$(serviceHub.identityService.wellKnownPartyFromAnonymous(it) ?: if (ignoreUnrecognisedParties) return@mapNotNull null else throw IllegalArgumentException("Could not find Party for $it")) to it MaxLineLength:IdentityUtils.kt$groupAbstractPartyByWellKnownParty(serviceHub, publicKeys.map { AnonymousParty(it) }, ignoreUnrecognisedParties).mapValues { it.value.map { it.owningKey } } - MaxLineLength:InMemoryIdentityService.kt$InMemoryIdentityService$@Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) MaxLineLength:InMemoryIdentityService.kt$InMemoryIdentityService$@Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) override - MaxLineLength:InMemoryIdentityService.kt$InMemoryIdentityService$override - MaxLineLength:InMemoryIdentityService.kt$InMemoryIdentityService$override val trustRoot: X509Certificate - MaxLineLength:InMemoryIdentityServiceTests.kt$InMemoryIdentityServiceTests$ @Test fun `assert ownership`() - MaxLineLength:InMemoryIdentityServiceTests.kt$InMemoryIdentityServiceTests$ @Test fun `get anonymous identity by key`() MaxLineLength:InMemoryIdentityServiceTests.kt$InMemoryIdentityServiceTests$listOf("Org A", "Org B", "Org C") .map { getTestPartyAndCertificate(CordaX500Name(organisation = it, locality = "London", country = "GB"), generateKeyPair().public) } MaxLineLength:InMemoryIdentityServiceTests.kt$InMemoryIdentityServiceTests$val alicente = getTestPartyAndCertificate(CordaX500Name(organisation = "Alicente Worldwide", locality = "London", country = "GB"), generateKeyPair().public) - MaxLineLength:InMemoryIdentityServiceTests.kt$InMemoryIdentityServiceTests.Companion$fun createService(vararg identities: PartyAndCertificate) - MaxLineLength:InMemoryMessagingNetwork.kt$InMemoryMessagingNetwork$@Synchronized private - MaxLineLength:InMemoryMessagingNetwork.kt$InMemoryMessagingNetwork$DistributedServiceHandle : MessageRecipientGroup - MaxLineLength:InMemoryMessagingNetwork.kt$InMemoryMessagingNetwork$MessageTransfer - MaxLineLength:InMemoryMessagingNetwork.kt$InMemoryMessagingNetwork$ServicePeerAllocationStrategy MaxLineLength:InMemoryMessagingNetwork.kt$InMemoryMessagingNetwork$peersMapping[messagingService.myAddress.name] = messagingService.myAddress MaxLineLength:InMemoryMessagingNetwork.kt$InMemoryMessagingNetwork$private val servicePeerAllocationStrategy: ServicePeerAllocationStrategy = InMemoryMessagingNetwork.ServicePeerAllocationStrategy.Random() MaxLineLength:InMemoryMessagingNetwork.kt$InMemoryMessagingNetwork.Companion$servicePeerAllocationStrategy: ServicePeerAllocationStrategy = InMemoryMessagingNetwork.ServicePeerAllocationStrategy.Random() - MaxLineLength:InMemoryMessagingNetwork.kt$InMemoryMessagingNetwork.MessageTransfer.Companion$internal MaxLineLength:InMemoryTransactionVerifierService.kt$InMemoryTransactionVerifierService : SingletonSerializeAsTokenTransactionVerifierServiceTransactionVerifierServiceInternalAutoCloseable - MaxLineLength:InfrequentlyMutatedCache.kt$InfrequentlyMutatedCache$ fun get(key: K, valueGetter: (K) -> V): V - MaxLineLength:InfrequentlyMutatedCache.kt$InfrequentlyMutatedCache$// This protects against the cache purging something that is marked as invalid and thus we "forget" it shouldn't be cached. private val currentlyInvalid = ConcurrentHashMap<K, Wrapper.Invalidated<V>>() - MaxLineLength:InfrequentlyMutatedCache.kt$InfrequentlyMutatedCache<K : Any, V : Any> - MaxLineLength:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$// This should not get cached, as the transaction that invalidated it in the other thread has completed but we might // not see the new value in our transaction since it started first. val result1 = cache.get("foo") { 1 } assertEquals(1, result1) val result2 = cache.get("foo") { 3 } assertEquals(3, result2) // Now allow other thread to commit transaction phaser.arriveAndAwaitAdvance() // and wait for commit to be complete phaser.arriveAndAwaitAdvance() // This should get cached, as the transaction that invalidated it in the other thread has completed but we might // not see the new value in our transaction since it started first. val result3 = cache.get("foo") { 3 } assertEquals(3, result3) val result4 = cache.get("foo") { 4 } assertEquals(4, result4) - MaxLineLength:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$// This will cache "2" cache.get("foo") { 2 } invalidateInOtherThread("foo") // This should not get cached, as the transaction that invalidated it in the other thread has completed but we might // not see the new value in our transaction since it started first. val result = cache.get("foo") { 1 } assertEquals(1, result) MaxLineLength:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$@Test fun `fourth get outside first transaction from empty cache with invalidate in other thread in the middle returns result of second loader`() - MaxLineLength:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$@Test fun `fourth get outside first transaction from empty cache with invalidate in the middle returns result of third loader`() - MaxLineLength:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$@Test fun `fourth get outside first transaction from empty cache with nested invalidate in the middle returns result of third loader`() - MaxLineLength:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$@Test fun `getIfPresent outside first transaction from empty cache with invalidate in the middle returns result of third loader`() - MaxLineLength:InfrequentlyMutatedCacheTest.kt$InfrequentlyMutatedCacheTest$@Test fun `third get outside first transaction from empty cache with invalidate in the middle returns result of third loader`() MaxLineLength:InitialRegistrationCli.kt$InitialRegistration : RunAfterNodeInitialisationNodeStartupLogging - MaxLineLength:InitialRegistrationCli.kt$InitialRegistration$e.logAsUnexpected( "Could not delete the marker file that was created for `initial-registration`.", print = logger::warn) MaxLineLength:InitialRegistrationCli.kt$InitialRegistration$println("Node was started before with `--initial-registration`, but the registration was not completed.\nResuming registration.") MaxLineLength:InitialRegistrationCli.kt$InitialRegistration$println("Successfully registered Corda node with compatibility zone, node identity keys and certificates are stored in '${conf.certificatesDirectory}', it is advised to backup the private keys and certificates.") - MaxLineLength:InitialRegistrationCli.kt$InitialRegistration$require(networkRootTrustStorePath.exists()) { "Network root trust store path: '$networkRootTrustStorePath' doesn't exist" } MaxLineLength:InitialRegistrationCli.kt$InitialRegistration${ // Null checks for [compatibilityZoneURL], [rootTruststorePath] and [rootTruststorePassword] has been done in [CmdLineOptions.loadConfig] attempt { registerWithNetwork(config) }.doOnFailure(Consumer(this::handleRegistrationError)) as Try.Success // At this point the node registration was successful. We can delete the marker file. deleteNodeRegistrationMarker(baseDirectory) } MaxLineLength:InitialRegistrationCli.kt$InitialRegistrationCli : CliWrapperBase MaxLineLength:InitialRegistrationCli.kt$InitialRegistrationCli$@Option(names = ["-p", "--network-root-truststore-password"], description = ["Network root trust store password obtained from network operator."], required = true) - MaxLineLength:InitialRegistrationCli.kt$InitialRegistrationCli$@Option(names = ["-t", "--network-root-truststore"], description = ["Network root trust store obtained from network operator."]) MaxLineLength:InitialRegistrationCli.kt$InitialRegistrationCli$return startup.initialiseAndRun(cmdLineOptions, InitialRegistration(cmdLineOptions.baseDirectory, networkRootTrustStorePath, networkRootTrustStorePassword, startup)) MaxLineLength:InitialRegistrationCli.kt$InitialRegistrationCli$val networkRootTrustStorePath: Path = networkRootTrustStorePathParameter ?: cmdLineOptions.baseDirectory / "certificates" / "network-root-truststore.jks" - MaxLineLength:InitiatedBy.kt$InitiatedBy - MaxLineLength:InitiatingFlow.kt$InitiatingFlow MaxLineLength:InstallShellExtensionsParser.kt$InstallShellExtensionsParser : CliWrapperBase - MaxLineLength:InstallShellExtensionsParser.kt$ShellExtensionsGenerator$// If on Windows, Path.toString() returns a path with \ instead of /, but for bash Windows users we want to convert those back to /'s private fun Path.toStringWithDeWindowsfication(): String - MaxLineLength:InstallShellExtensionsParser.kt$ShellExtensionsGenerator$loggerFor<InstallShellExtensionsParser>().warn("Failed to run command: ${commandAndArgs.joinToString(" ")}; $exception") MaxLineLength:InstallShellExtensionsParser.kt$ShellExtensionsGenerator$printWarning("Cannot install shell extension for bash major version earlier than $minSupportedBashVersion. Please upgrade your bash version. Aliases should still work.") MaxLineLength:InstallShellExtensionsParser.kt$ShellExtensionsGenerator$println("Installation complete, ${parent.alias} is available in bash, but autocompletion was not installed because of an old version of bash.") - MaxLineLength:InstallShellExtensionsParser.kt$ShellExtensionsGenerator$println("Restart bash for this to take effect, or run `. ~/.bashrc` in bash or `. ~/.zshrc` in zsh to re-initialise your shell now") - MaxLineLength:InstallShellExtensionsParser.kt$ShellExtensionsGenerator$private fun jarVersion(alias: String) - MaxLineLength:InstallShellExtensionsParser.kt$ShellExtensionsGenerator.SettingsFile$println("Updating settings in ${filePath.fileName} - existing settings file has been backed up to $backupFilePath") - MaxLineLength:Instances.kt$Instances MaxLineLength:InstantSerializer.kt$InstantSerializer : Proxy - MaxLineLength:InstantSerializer.kt$InstantSerializer$override fun fromProxy(proxy: InstantProxy): Instant - MaxLineLength:InstructionRule.kt$InstructionRule$final override - MaxLineLength:InteractiveShell.kt$InteractiveShell$@JvmStatic fun runRPCFromString(input: List<String>, out: RenderPrintWriter, context: InvocationContext<out Any>, cordaRPCOps: CordaRPCOps, inputObjectMapper: ObjectMapper): Any? MaxLineLength:InteractiveShell.kt$InteractiveShell$ExternalResolver.INSTANCE.addCommand("flow", "Commands to work with flows. Flows are how you can change the ledger.", FlowShellCommand::class.java) MaxLineLength:InteractiveShell.kt$InteractiveShell$ExternalResolver.INSTANCE.addCommand("hashLookup", "Checks if a transaction with matching Id hash exists.", HashLookupShellCommand::class.java) MaxLineLength:InteractiveShell.kt$InteractiveShell$ExternalResolver.INSTANCE.addCommand("output-format", "Commands to inspect and update the output format.", OutputFormatCommand::class.java) MaxLineLength:InteractiveShell.kt$InteractiveShell$ExternalResolver.INSTANCE.addCommand("run", "Runs a method from the CordaRPCOps interface on the node.", RunShellCommand::class.java) - MaxLineLength:InteractiveShell.kt$InteractiveShell$connection.forceClose() // This will only show up in the standalone Shell, because the embedded one is killed as part of a node's shutdown. display { println("...done, quitting the shell now.") } onExit.invoke() MaxLineLength:InteractiveShell.kt$InteractiveShell$errors.add("${getPrototype()}: Wrong number of arguments (${args.size} provided, ${ctor.genericParameterTypes.size} needed)") - MaxLineLength:InteractiveShell.kt$InteractiveShell$out.println("Please use the 'flow' command to interact with flows rather than the 'run' command.", Color.yellow) - MaxLineLength:InteractiveShell.kt$InteractiveShell$private - MaxLineLength:InteractiveShell.kt$InteractiveShell$shell = ShellLifecycle(configuration.commandsDirectory).start(config, configuration.user, configuration.password) - MaxLineLength:InteractiveShell.kt$InteractiveShell$val args = parser.parseArguments(clazz.name, paramNamesFromConstructor.zip(ctor.genericParameterTypes), inputData) - MaxLineLength:InteractiveShell.kt$InteractiveShell$val mapElement: (Any?) -> String = { element -> outputMapper.writerWithDefaultPrettyPrinter().writeValueAsString(element) } MaxLineLength:InteractiveShell.kt$InteractiveShell$val stateObservable = runFlowFromString({ clazz, args -> rpcOps.startTrackedFlowDynamic(clazz, *args) }, inputData, flowClazz, inputObjectMapper) MaxLineLength:InteractiveShell.kt$InteractiveShell${ private val log = LoggerFactory.getLogger(javaClass) private lateinit var rpcOps: (username: String, credentials: String) -> CordaRPCOps private lateinit var ops: CordaRPCOps private lateinit var connection: CordaRPCConnection private var shell: Shell? = null private var classLoader: ClassLoader? = null private lateinit var shellConfiguration: ShellConfiguration private var onExit: () -> Unit = {} @JvmStatic fun getCordappsClassloader() = classLoader enum class OutputFormat { JSON, YAML } /** * Starts an interactive shell connected to the local terminal. This shell gives administrator access to the node * internals. */ fun startShell(configuration: ShellConfiguration, classLoader: ClassLoader? = null) { rpcOps = { username: String, credentials: String -> val client = CordaRPCClient(hostAndPort = configuration.hostAndPort, configuration = CordaRPCClientConfiguration.DEFAULT.copy( maxReconnectAttempts = 1 ), sslConfiguration = configuration.ssl, classLoader = classLoader) this.connection = client.start(username, credentials) connection.proxy } _startShell(configuration, classLoader) } private fun _startShell(configuration: ShellConfiguration, classLoader: ClassLoader? = null) { shellConfiguration = configuration InteractiveShell.classLoader = classLoader val runSshDaemon = configuration.sshdPort != null val config = Properties() if (runSshDaemon) { // Enable SSH access. Note: these have to be strings, even though raw object assignments also work. config["crash.ssh.port"] = configuration.sshdPort?.toString() config["crash.auth"] = "corda" configuration.sshHostKeyDirectory?.apply { val sshKeysDir = configuration.sshHostKeyDirectory.createDirectories() config["crash.ssh.keypath"] = (sshKeysDir / "hostkey.pem").toString() config["crash.ssh.keygen"] = "true" } } ExternalResolver.INSTANCE.addCommand("output-format", "Commands to inspect and update the output format.", OutputFormatCommand::class.java) ExternalResolver.INSTANCE.addCommand("run", "Runs a method from the CordaRPCOps interface on the node.", RunShellCommand::class.java) ExternalResolver.INSTANCE.addCommand("flow", "Commands to work with flows. Flows are how you can change the ledger.", FlowShellCommand::class.java) ExternalResolver.INSTANCE.addCommand("start", "An alias for 'flow start'", StartShellCommand::class.java) ExternalResolver.INSTANCE.addCommand("hashLookup", "Checks if a transaction with matching Id hash exists.", HashLookupShellCommand::class.java) shell = ShellLifecycle(configuration.commandsDirectory).start(config, configuration.user, configuration.password) } fun runLocalShell(onExit: () -> Unit = {}) { this.onExit = onExit val terminal = TerminalFactory.create() val consoleReader = ConsoleReader("Corda", FileInputStream(FileDescriptor.`in`), System.out, terminal) val jlineProcessor = JLineProcessor(terminal.isAnsiSupported, shell, consoleReader, System.out) InterruptHandler { jlineProcessor.interrupt() }.install() thread(name = "Command line shell processor", isDaemon = true) { Emoji.renderIfSupported { try { jlineProcessor.run() } catch (e: IndexOutOfBoundsException) { log.warn("Cannot parse malformed command.") } } } thread(name = "Command line shell terminator", isDaemon = true) { // Wait for the shell to finish. jlineProcessor.closed() log.info("Command shell has exited") terminal.restore() onExit.invoke() } } class ShellLifecycle(private val shellCommands: Path) : PluginLifeCycle() { fun start(config: Properties, localUserName: String = "", localUserPassword: String = ""): Shell { val classLoader = this.javaClass.classLoader val classpathDriver = ClassPathMountFactory(classLoader) val fileDriver = FileMountFactory(Utils.getCurrentDirectory()) val extraCommandsPath = shellCommands.toAbsolutePath().createDirectories() val commandsFS = FS.Builder() .register("file", fileDriver) .mount("file:$extraCommandsPath") .register("classpath", classpathDriver) .mount("classpath:/net/corda/tools/shell/") .mount("classpath:/crash/commands/") .build() val confFS = FS.Builder() .register("classpath", classpathDriver) .mount("classpath:/crash") .build() val discovery = object : ServiceLoaderDiscovery(classLoader) { override fun getPlugins(): Iterable<CRaSHPlugin<*>> { // Don't use the Java language plugin (we may not have tools.jar available at runtime), this // will cause any commands using JIT Java compilation to be suppressed. In CRaSH upstream that // is only the 'jmx' command. return super.getPlugins().filterNot { it is JavaLanguage } + CordaAuthenticationPlugin(rpcOps) } } val attributes = emptyMap<String, Any>() val context = PluginContext(discovery, attributes, commandsFS, confFS, classLoader) context.refresh() this.config = config start(context) ops = makeRPCOps(rpcOps, localUserName, localUserPassword) return context.getPlugin(ShellFactory::class.java).create(null, CordaSSHAuthInfo(false, ops, StdoutANSIProgressRenderer)) } } fun nodeInfo() = try { ops.nodeInfo() } catch (e: UndeclaredThrowableException) { throw e.cause ?: e } @JvmStatic fun setOutputFormat(outputFormat: OutputFormat) { this.outputFormat = outputFormat } @JvmStatic fun getOutputFormat(): OutputFormat { return outputFormat } fun createYamlInputMapper(rpcOps: CordaRPCOps): ObjectMapper { // Return a standard Corda Jackson object mapper, configured to use YAML by default and with extra // serializers. return JacksonSupport.createDefaultMapper(rpcOps, YAMLFactory(), true).apply { val rpcModule = SimpleModule().apply { addDeserializer(InputStream::class.java, InputStreamDeserializer) addDeserializer(UniqueIdentifier::class.java, UniqueIdentifierDeserializer) } registerModule(rpcModule) } } private fun createOutputMapper(outputFormat: OutputFormat): ObjectMapper { val factory = when(outputFormat) { OutputFormat.JSON -> JsonFactory() OutputFormat.YAML -> YAMLFactory().disable(YAMLGenerator.Feature.WRITE_DOC_START_MARKER) } return JacksonSupport.createNonRpcMapper(factory).apply { // Register serializers for stateful objects from libraries that are special to the RPC system and don't // make sense to print out to the screen. For classes we own, annotations can be used instead. val rpcModule = SimpleModule().apply { addSerializer(Observable::class.java, ObservableSerializer) addSerializer(InputStream::class.java, InputStreamSerializer) } registerModule(rpcModule) disable(SerializationFeature.FAIL_ON_EMPTY_BEANS) enable(SerializationFeature.INDENT_OUTPUT) } } // TODO: A default renderer could be used, instead of an object mapper. See: http://www.crashub.org/1.3/reference.html#_renderers private var outputFormat = OutputFormat.YAML @VisibleForTesting lateinit var latch: CountDownLatch private set /** * Called from the 'flow' shell command. Takes a name fragment and finds a matching flow, or prints out * the list of options if the request is ambiguous. Then parses [inputData] as constructor arguments using * the [runFlowFromString] method and starts the requested flow. Ctrl-C can be used to cancel. */ @JvmStatic fun runFlowByNameFragment(nameFragment: String, inputData: String, output: RenderPrintWriter, rpcOps: CordaRPCOps, ansiProgressRenderer: ANSIProgressRenderer, inputObjectMapper: ObjectMapper = createYamlInputMapper(rpcOps)) { val matches = try { rpcOps.registeredFlows().filter { nameFragment in it } } catch (e: PermissionException) { output.println(e.message ?: "Access denied", Color.red) return } if (matches.isEmpty()) { output.println("No matching flow found, run 'flow list' to see your options.", Color.red) return } else if (matches.size > 1 && matches.find { it.endsWith(nameFragment)} == null) { output.println("Ambiguous name provided, please be more specific. Your options are:") matches.forEachIndexed { i, s -> output.println("${i + 1}. $s", Color.yellow) } return } val flowName = matches.find { it.endsWith(nameFragment)} ?: matches.single() val flowClazz: Class<FlowLogic<*>> = if (classLoader != null) { uncheckedCast(Class.forName(flowName, true, classLoader)) } else { uncheckedCast(Class.forName(flowName)) } try { // Show the progress tracker on the console until the flow completes or is interrupted with a // Ctrl-C keypress. val stateObservable = runFlowFromString({ clazz, args -> rpcOps.startTrackedFlowDynamic(clazz, *args) }, inputData, flowClazz, inputObjectMapper) latch = CountDownLatch(1) ansiProgressRenderer.render(stateObservable, latch::countDown) // Wait for the flow to end and the progress tracker to notice. By the time the latch is released // the tracker is done with the screen. while (!Thread.currentThread().isInterrupted) { try { latch.await() break } catch (e: InterruptedException) { try { rpcOps.killFlow(stateObservable.id) } finally { Thread.currentThread().interrupt() break } } } output.println("Flow completed with result: ${stateObservable.returnValue.get()}") } catch (e: NoApplicableConstructor) { output.println("No matching constructor found:", Color.red) e.errors.forEach { output.println("- $it", Color.red) } } catch (e: PermissionException) { output.println(e.message ?: "Access denied", Color.red) } catch (e: ExecutionException) { // ignoring it as already logged by the progress handler subscriber } finally { InputStreamDeserializer.closeAll() } } class NoApplicableConstructor(val errors: List<String>) : CordaException(this.toString()) { override fun toString() = (listOf("No applicable constructor for flow. Problems were:") + errors).joinToString(System.lineSeparator()) } /** * Tidies up a possibly generic type name by chopping off the package names of classes in a hard-coded set of * hierarchies that are known to be widely used and recognised, and also not have (m)any ambiguous names in them. * * This is used for printing error messages when something doesn't match. */ private fun maybeAbbreviateGenericType(type: Type, extraRecognisedPackage: String): String { val packagesToAbbreviate = listOf("java.", "net.corda.core.", "kotlin.", extraRecognisedPackage) fun shouldAbbreviate(typeName: String) = packagesToAbbreviate.any { typeName.startsWith(it) } fun abbreviated(typeName: String) = if (shouldAbbreviate(typeName)) typeName.split('.').last() else typeName fun innerLoop(type: Type): String = when (type) { is ParameterizedType -> { val args: List<String> = type.actualTypeArguments.map(::innerLoop) abbreviated(type.rawType.typeName) + '<' + args.joinToString(", ") + '>' } is GenericArrayType -> { innerLoop(type.genericComponentType) + "[]" } is Class<*> -> { if (type.isArray) abbreviated(type.simpleName) else abbreviated(type.name).replace('$', '.') } else -> type.toString() } return innerLoop(type) } @JvmStatic fun killFlowById(id: String, output: RenderPrintWriter, rpcOps: CordaRPCOps, inputObjectMapper: ObjectMapper = createYamlInputMapper(rpcOps)) { try { val runId = try { inputObjectMapper.readValue(id, StateMachineRunId::class.java) } catch (e: JsonMappingException) { output.println("Cannot parse flow ID of '$id' - expecting a UUID.", Color.red) log.error("Failed to parse flow ID", e) return } if (rpcOps.killFlow(runId)) { output.println("Killed flow $runId", Color.yellow) } else { output.println("Failed to kill flow $runId", Color.red) } } finally { output.flush() } } // TODO: This utility is generally useful and might be better moved to the node class, or an RPC, if we can commit to making it stable API. /** * Given a [FlowLogic] class and a string in one-line Yaml form, finds an applicable constructor and starts * the flow, returning the created flow logic. Useful for lightweight invocation where text is preferable * to statically typed, compiled code. * * See the [StringToMethodCallParser] class to learn more about limitations and acceptable syntax. * * @throws NoApplicableConstructor if no constructor could be found for the given set of types. */ @Throws(NoApplicableConstructor::class) fun <T> runFlowFromString(invoke: (Class<out FlowLogic<T>>, Array<out Any?>) -> FlowProgressHandle<T>, inputData: String, clazz: Class<out FlowLogic<T>>, om: ObjectMapper): FlowProgressHandle<T> { // For each constructor, attempt to parse the input data as a method call. Use the first that succeeds, // and keep track of the reasons we failed so we can print them out if no constructors are usable. val parser = StringToMethodCallParser(clazz, om) val errors = ArrayList<String>() val classPackage = clazz.packageName for (ctor in clazz.constructors) { var paramNamesFromConstructor: List<String>? = null fun getPrototype(): List<String> { val argTypes = ctor.genericParameterTypes.map { it: Type -> // If the type name is in the net.corda.core or java namespaces, chop off the package name // because these hierarchies don't have (m)any ambiguous names and the extra detail is just noise. maybeAbbreviateGenericType(it, classPackage) } return paramNamesFromConstructor!!.zip(argTypes).map { (name, type) -> "$name: $type" } } try { // Attempt construction with the given arguments. paramNamesFromConstructor = parser.paramNamesFromConstructor(ctor) val args = parser.parseArguments(clazz.name, paramNamesFromConstructor.zip(ctor.genericParameterTypes), inputData) if (args.size != ctor.genericParameterTypes.size) { errors.add("${getPrototype()}: Wrong number of arguments (${args.size} provided, ${ctor.genericParameterTypes.size} needed)") continue } return invoke(clazz, args) } catch (e: StringToMethodCallParser.UnparseableCallException.MissingParameter) { errors.add("${getPrototype()}: missing parameter ${e.paramName}") } catch (e: StringToMethodCallParser.UnparseableCallException.TooManyParameters) { errors.add("${getPrototype()}: too many parameters") } catch (e: StringToMethodCallParser.UnparseableCallException.ReflectionDataMissing) { val argTypes = ctor.genericParameterTypes.map { it.typeName } errors.add("$argTypes: <constructor missing parameter reflection data>") } catch (e: StringToMethodCallParser.UnparseableCallException) { val argTypes = ctor.genericParameterTypes.map { it.typeName } errors.add("$argTypes: ${e.message}") } } throw NoApplicableConstructor(errors) } // TODO Filtering on error/success when we will have some sort of flow auditing, for now it doesn't make much sense. @JvmStatic fun runStateMachinesView(out: RenderPrintWriter, rpcOps: CordaRPCOps): Any? { val proxy = rpcOps val (stateMachines, stateMachineUpdates) = proxy.stateMachinesFeed() val currentStateMachines = stateMachines.map { StateMachineUpdate.Added(it) } val subscriber = FlowWatchPrintingSubscriber(out) stateMachineUpdates.startWith(currentStateMachines).subscribe(subscriber) var result: Any? = subscriber.future if (result is Future<*>) { if (!result.isDone) { out.cls() out.println("Waiting for completion or Ctrl-C ... ") out.flush() } try { result = result.get() } catch (e: InterruptedException) { Thread.currentThread().interrupt() } catch (e: ExecutionException) { throw e.rootCause } catch (e: InvocationTargetException) { throw e.rootCause } } return result } @JvmStatic fun runRPCFromString(input: List<String>, out: RenderPrintWriter, context: InvocationContext<out Any>, cordaRPCOps: CordaRPCOps, inputObjectMapper: ObjectMapper): Any? { val cmd = input.joinToString(" ").trim { it <= ' ' } if (cmd.startsWith("startflow", ignoreCase = true)) { // The flow command provides better support and startFlow requires special handling anyway due to // the generic startFlow RPC interface which offers no type information with which to parse the // string form of the command. out.println("Please use the 'flow' command to interact with flows rather than the 'run' command.", Color.yellow) return null } else if (cmd.substringAfter(" ").trim().equals("gracefulShutdown", ignoreCase = true)) { return InteractiveShell.gracefulShutdown(out, cordaRPCOps) } var result: Any? = null try { InputStreamSerializer.invokeContext = context val parser = StringToMethodCallParser(CordaRPCOps::class.java, inputObjectMapper) val call = parser.parse(cordaRPCOps, cmd) result = call.call() if (result != null && result !== kotlin.Unit && result !is Void) { result = printAndFollowRPCResponse(result, out, outputFormat) } if (result is Future<*>) { if (!result.isDone) { out.println("Waiting for completion or Ctrl-C ... ") out.flush() } try { result = result.get() } catch (e: InterruptedException) { Thread.currentThread().interrupt() } catch (e: ExecutionException) { throw e.rootCause } catch (e: InvocationTargetException) { throw e.rootCause } } } catch (e: StringToMethodCallParser.UnparseableCallException) { out.println(e.message, Color.red) if (e !is StringToMethodCallParser.UnparseableCallException.NoSuchFile) { out.println("Please try 'man run' to learn what syntax is acceptable") } } catch (e: Exception) { out.println("RPC failed: ${e.rootCause}", Color.red) } finally { InputStreamSerializer.invokeContext = null InputStreamDeserializer.closeAll() } return result } @JvmStatic fun gracefulShutdown(userSessionOut: RenderPrintWriter, cordaRPCOps: CordaRPCOps) { fun display(statements: RenderPrintWriter.() -> Unit) { statements.invoke(userSessionOut) userSessionOut.flush() } var isShuttingDown = false try { display { println("Orchestrating a clean shutdown, press CTRL+C to cancel...") } isShuttingDown = true display { println("...enabling draining mode") println("...waiting for in-flight flows to be completed") } cordaRPCOps.terminate(true) val latch = CountDownLatch(1) cordaRPCOps.pendingFlowsCount().updates.doOnError { error -> log.error(error.message) throw error }.doAfterTerminate(latch::countDown).subscribe( // For each update. { (first, second) -> display { println("...remaining: $first / $second") } }, // On error. { error -> if (!isShuttingDown) { display { println("RPC failed: ${error.rootCause}", Color.red) } } }, // When completed. { connection.forceClose() // This will only show up in the standalone Shell, because the embedded one is killed as part of a node's shutdown. display { println("...done, quitting the shell now.") } onExit.invoke() }) while (!Thread.currentThread().isInterrupted) { try { latch.await() break } catch (e: InterruptedException) { try { cordaRPCOps.setFlowsDrainingModeEnabled(false) display { println("...cancelled clean shutdown.") } } finally { Thread.currentThread().interrupt() break } } } } catch (e: StringToMethodCallParser.UnparseableCallException) { display { println(e.message, Color.red) println("Please try 'man run' to learn what syntax is acceptable") } } catch (e: Exception) { if (!isShuttingDown) { display { println("RPC failed: ${e.rootCause}", Color.red) } } } finally { InputStreamSerializer.invokeContext = null InputStreamDeserializer.closeAll() } } private fun printAndFollowRPCResponse(response: Any?, out: PrintWriter, outputFormat: OutputFormat): CordaFuture<Unit> { val outputMapper = createOutputMapper(outputFormat) val mapElement: (Any?) -> String = { element -> outputMapper.writerWithDefaultPrettyPrinter().writeValueAsString(element) } return maybeFollow(response, mapElement, out) } private class PrintingSubscriber(private val printerFun: (Any?) -> String, private val toStream: PrintWriter) : Subscriber<Any>() { private var count = 0 val future = openFuture<Unit>() init { // The future is public and can be completed by something else to indicate we don't wish to follow // anymore (e.g. the user pressing Ctrl-C). future.then { unsubscribe() } } @Synchronized override fun onCompleted() { toStream.println("Observable has completed") future.set(Unit) } @Synchronized override fun onNext(t: Any?) { count++ toStream.println("Observation $count: " + printerFun(t)) toStream.flush() } @Synchronized override fun onError(e: Throwable) { toStream.println("Observable completed with an error") e.printStackTrace(toStream) future.setException(e) } } private fun maybeFollow(response: Any?, printerFun: (Any?) -> String, out: PrintWriter): CordaFuture<Unit> { // Match on a couple of common patterns for "important" observables. It's tough to do this in a generic // way because observables can be embedded anywhere in the object graph, and can emit other arbitrary // object graphs that contain yet more observables. So we just look for top level responses that follow // the standard "track" pattern, and print them until the user presses Ctrl-C if (response == null) return doneFuture(Unit) if (response is DataFeed<*, *>) { out.println("Snapshot:") out.println(printerFun(response.snapshot)) out.flush() out.println("Updates:") return printNextElements(response.updates, printerFun, out) } if (response is Observable<*>) { return printNextElements(response, printerFun, out) } out.println(printerFun(response)) return doneFuture(Unit) } private fun printNextElements(elements: Observable<*>, printerFun: (Any?) -> String, out: PrintWriter): CordaFuture<Unit> { val subscriber = PrintingSubscriber(printerFun, out) uncheckedCast(elements).subscribe(subscriber) return subscriber.future } } MaxLineLength:InteractiveShell.kt$InteractiveShell.NoApplicableConstructor$override fun toString() - MaxLineLength:InteractiveShell.kt$InteractiveShell.PrintingSubscriber$private - MaxLineLength:InteractiveShell.kt$InteractiveShell.ShellLifecycle$return context.getPlugin(ShellFactory::class.java).create(null, CordaSSHAuthInfo(false, ops, StdoutANSIProgressRenderer)) - MaxLineLength:InteractiveShellIntegrationTest.kt$InteractiveShellIntegrationTest$startNode(rpcUsers = listOf(user), customOverrides = brokerSslOptions.useSslRpcOverrides()).getOrThrow() - MaxLineLength:InteractiveShellTest.kt$FlowA$constructor(amounts: Array<Amount<UserValue>>) : this(amounts.joinToString("++", transform = Amount<UserValue>::toString)) - MaxLineLength:InteractiveShellTest.kt$InteractiveShellTest$input = """amounts: [ { "quantity": 10, "token": { "label": "(1)" } }, { "quantity": 200, "token": { "label": "(2)" } } ]""" - MaxLineLength:InteractiveShellTest.kt$InteractiveShellTest$input = "pair: { first: $100.12, second: df489807f81c8c8829e509e1bcb92e6692b9dd9d624b7456435cb2f51dc82587 }" - MaxLineLength:InteractiveShellTest.kt$InteractiveShellTest$val instance = clazz.getConstructor(*args.map { it!!::class.java }.toTypedArray()).newInstance(*args) as FlowA MaxLineLength:InterestSwapRestAPI.kt$InterestRateSwapAPI - MaxLineLength:InterestSwapRestAPI.kt$InterestRateSwapAPI$val states = vault.filterStatesOfType<InterestRateSwap.State>().filter { it.state.data.linearId.externalId == ref } MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$ fun createNode(parameters: InternalMockNodeParameters = InternalMockNodeParameters(), nodeFactory: (MockNodeArgs) -> MockNode): TestStartedNode - MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$"You can use MockNetwork.waitQuiescent() to wait for all the nodes to process all the messages on their queues instead." - MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$/** * Returns the list of nodes started by the network. Each notary specified when the network is constructed ([notarySpecs] * parameter) maps 1:1 to the notaries returned by this list. */ val notaryNodes: List<TestStartedNode> MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$?: - MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$TestCordappInternal.installCordapps(baseDirectory, parameters.additionalCordapps.toSet(), combinedCordappsForAllNodes) MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$fun createUnstartedNode(parameters: InternalMockNodeParameters = InternalMockNodeParameters(), nodeFactory: (MockNodeArgs) -> MockNode): MockNode - MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$private MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$private val serializationEnv = checkNotNull(setDriverSerialization()) { "Using more than one mock network simultaneously is not supported." } MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$servicePeerAllocationStrategy: InMemoryMessagingNetwork.ServicePeerAllocationStrategy = defaultParameters.servicePeerAllocationStrategy - MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$val messagingNetwork = InMemoryMessagingNetwork.create(networkSendManuallyPumped, servicePeerAllocationStrategy, busyLatch) MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$val node = nodeFactory(MockNodeArgs(config, this, id, parameters.entropyRoot, parameters.version, flowManager = parameters.flowManager)) - MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork$val testDirectory: Path = Paths.get("build") / "mock-network" / getTimestampAsDirectoryName() - MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork.MockNode$(network as MockNodeMessagingService).start(mockNet.messagingNetwork, !mockNet.threadPerNode, id, myNotaryIdentity) MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork.MockNode$fun <T : FlowLogic<*>> registerInitiatedFlowFactory(initiatingFlowClass: Class<out FlowLogic<*>>, initiatedFlowClass: Class<T>, factory: InitiatedFlowFactory<T>, track: Boolean): Observable<T> MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork.MockNode$open - MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork.MockNode$override MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork.MockNode$require(cryptoService is BCCryptoService) { "MockNode supports BCCryptoService only, but it is ${cryptoService.javaClass.name}" } MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork.MockNode${ require(cryptoService is BCCryptoService) { "MockNode supports BCCryptoService only, but it is ${cryptoService.javaClass.name}" } counter = counter.add(BigInteger.ONE) // The StartedMockNode specifically uses EdDSA keys as they are fixed and stored in json files for some tests (e.g IRSSimulation). val keyPair = Crypto.deriveKeyPairFromEntropy(Crypto.EDDSA_ED25519_SHA512, counter) (cryptoService as BCCryptoService).importKey(alias, keyPair) return keyPair.public } MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork.MockNode.TestStartedNodeImpl$override - MaxLineLength:InternalMockNetwork.kt$InternalMockNetwork.MockNode.TestStartedNodeImpl$return smm.changes.filter { it is StateMachineManager.Change.Add }.map { it.logic }.ofType(initiatedFlowClass) - MaxLineLength:InternalMockNetwork.kt$MessagingServiceSpy$val messagingService: MessagingService get() = checkNotNull(_messagingService) { "Spy has not been attached to a node" } - MaxLineLength:InternalMockNetwork.kt$MockNodeFlowManager$override - MaxLineLength:InternalMockNetwork.kt$TestStartedNode$ fun setMessagingServiceSpy(spy: MessagingServiceSpy) MaxLineLength:InternalMockNetwork.kt$TestStartedNode$fun <T : FlowLogic<*>> registerInitiatedFlow(initiatingFlowClass: Class<out FlowLogic<*>>, initiatedFlowClass: Class<T>, track: Boolean = false): Observable<T> MaxLineLength:InternalMockNetworkConfigOverrides.kt$return NotaryConfig(validating = this.validating, extraConfig = this.extraConfig, serviceLegalName = this.serviceLegalName, className = this.className) MaxLineLength:InternalMockNetworkConfigOverrides.kt$this.flowTimeout?.also { fto -> doReturn(FlowTimeoutConfiguration(fto.timeout, fto.maxRestartCount, fto.backoffBase)).whenever(config).flowTimeout } MaxLineLength:InternalMockNetworkIntegrationTests.kt$InternalMockNetworkIntegrationTests$assertEquals(0, startJavaProcess<InternalMockNetworkIntegrationTests>(emptyList(), extraJvmArguments = listOf("-javaagent:$quasar")).waitFor()) - MaxLineLength:InternalMockNetworkTests.kt$InternalMockNetworkTests$node1.network.send(node2.network.createMessage("test.topic", data = bits), rigorousMock<AllPossibleRecipients>()) MaxLineLength:InternalRPCMessagingClient.kt$InternalRPCMessagingClient : SingletonSerializeAsTokenAutoCloseable - MaxLineLength:InternalRPCMessagingClient.kt$InternalRPCMessagingClient$fun init(rpcOps: RPCOps, securityManager: RPCSecurityManager, cacheFactory: NamedCacheFactory) MaxLineLength:InternalRPCMessagingClient.kt$InternalRPCMessagingClient$rpcServer = RPCServer(rpcOps, NODE_RPC_USER, NODE_RPC_USER, locator!!, securityManager, nodeName, rpcServerConfiguration, cacheFactory) - MaxLineLength:InternalSerializationTestHelpers.kt$fun <T> SerializationEnvironment.asTestContextEnv(inheritable: Boolean = false, callable: (SerializationEnvironment) -> T): T - MaxLineLength:InternalTestUtils.kt$ // TODO Rename to cordappWithClasses fun cordappForClasses(vararg classes: Class<*>): CustomCordapp - MaxLineLength:InternalTestUtils.kt$ fun JarOutputStream.addEntry(entry: ZipEntry, input: InputStream) - MaxLineLength:InternalTestUtils.kt$ fun NodeInfo.chooseIdentity(): Party - MaxLineLength:InternalTestUtils.kt$ fun addressMustBeBound(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort, listenProcess: Process? = null) MaxLineLength:InternalTestUtils.kt$ fun cordappWithPackages(vararg packageNames: String): CustomCordapp - MaxLineLength:InternalTestUtils.kt$ fun createDevNodeCaCertPath( legalName: CordaX500Name, nodeKeyPair: KeyPair = generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME), rootCaName: X500Principal = defaultRootCaName, intermediateCaName: X500Principal = defaultIntermediateCaName ): Triple<CertificateAndKeyPair, CertificateAndKeyPair, CertificateAndKeyPair> - MaxLineLength:InternalTestUtils.kt$ fun findCordapp(scanPackage: String): TestCordappImpl - MaxLineLength:InternalTestUtils.kt$/* * The default timeout value of 40 seconds have been chosen based on previous node shutdown time estimate. * It's been observed that nodes can take up to 30 seconds to shut down, so just to stay on the safe side the 60 seconds * timeout has been chosen. */ fun addressMustNotBeBound(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort, timeout: Duration = 40.seconds) MaxLineLength:InternalTestUtils.kt$/** * *Custom* CorDapp containing the contents of the `net.corda.testing.contracts` package, i.e. the dummy contracts. This is not a real CorDapp * in the way that [FINANCE_CONTRACTS_CORDAPP] and [FINANCE_WORKFLOWS_CORDAPP] are. */ @JvmField val DUMMY_CONTRACTS_CORDAPP: CustomCordapp = cordappWithPackages("net.corda.testing.contracts") MaxLineLength:InternalTestUtils.kt$/** * Reference to the finance-contracts CorDapp in this repo. The metadata is taken directly from finance/contracts/build.gradle, including the * fact that the jar is signed. If you need an unsigned jar then use `cordappWithPackages("net.corda.finance.contracts")`. * * You will probably need to use [FINANCE_CORDAPPS] instead to get access to the flows as well. */ @JvmField val FINANCE_CONTRACTS_CORDAPP: TestCordappImpl = findCordapp("net.corda.finance.contracts") MaxLineLength:InternalTestUtils.kt$/** * Reference to the finance-workflows CorDapp in this repo. The metadata is taken directly from finance/workflows/build.gradle, including the * fact that the jar is signed. If you need an unsigned jar then use `cordappWithPackages("net.corda.finance.flows")`. * * You will probably need to use [FINANCE_CORDAPPS] instead to get access to the contract classes as well. */ @JvmField val FINANCE_WORKFLOWS_CORDAPP: TestCordappImpl = findCordapp("net.corda.finance.workflows") - MaxLineLength:InternalTestUtils.kt$ListenProcessDeathException$CordaException("The process that was expected to listen on $hostAndPort has died with status: ${listenProcess.exitValue()}") - MaxLineLength:InternalTestUtils.kt$RPCSecurityManagerImpl(SecurityConfiguration.AuthService.fromUsers(users).copy(id = id), TestingNamedCacheFactory()) - MaxLineLength:InternalTestUtils.kt$fun <T> StartedNodeServices.startFlow(logic: FlowLogic<T>): FlowStateMachine<T> MaxLineLength:InternalTestUtils.kt$fun addressMustBeBoundFuture(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort, listenProcess: Process? = null): CordaFuture<Unit> - MaxLineLength:InternalTestUtils.kt$fun addressMustNotBeBoundFuture(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort): CordaFuture<Unit> - MaxLineLength:InternalTestUtils.kt$manifestAttributes.forEach { manifest[it.key] = it.value } - MaxLineLength:InternalTestUtils.kt$require(classes.isNotEmpty()) { "${receiverClass.name} does not contain any enclosed classes to build a CorDapp out of" } - MaxLineLength:InternalTestUtils.kt$val componentGroups = createComponentGroups(inputs, outputs, commands, attachments, notary, timeWindow, emptyList(), null) MaxLineLength:InternalTestUtils.kt$val persistence = createCordaPersistence(databaseConfig, wellKnownPartyFromX500Name, wellKnownPartyFromAnonymous, schemaService, hikariProperties, cacheFactory, null) - MaxLineLength:InternalTestUtilsTest.kt$InternalTestUtilsTest$assertThat(simplifyScanPackages(listOf("com.foobar", "com.foo"))).containsExactlyInAnyOrder("com.foobar", "com.foo") - MaxLineLength:InternalTestUtilsTest.kt$InternalTestUtilsTest$assertThat(simplifyScanPackages(listOf("com.foobar", "com.foo.bar"))).containsExactlyInAnyOrder("com.foobar", "com.foo.bar") - MaxLineLength:InternalUtils.kt$ @DeleteForDJVM fun <T> Any.declaredField(clazz: Class<*>, name: String): DeclaredField<T> - MaxLineLength:InternalUtils.kt$ @DeleteForDJVM fun <T> Any.declaredField(clazz: KClass<*>, name: String): DeclaredField<T> - MaxLineLength:InternalUtils.kt$ @DeleteForDJVM fun <T> Any.declaredField(name: String): DeclaredField<T> - MaxLineLength:InternalUtils.kt$ @DeleteForDJVM fun <T> KClass<*>.staticField(name: String): DeclaredField<T> MaxLineLength:InternalUtils.kt$ fun <T, U> List<T>.lazyMapped(transform: (T, Int) -> U): List<U> MaxLineLength:InternalUtils.kt$// TODO: Currently the certificate revocation status is not handled here. Nowhere in the code the second parameter is used. Consider adding the support in the future. fun CertPath.validate(trustAnchor: TrustAnchor, checkRevocation: Boolean = false): PKIXCertPathValidatorResult MaxLineLength:InternalUtils.kt$?: - MaxLineLength:InternalUtils.kt$@DeleteForDJVM fun InputStream.copyTo(target: Path, vararg options: CopyOption): Long - MaxLineLength:InternalUtils.kt$DeclaredField<T> - MaxLineLength:InternalUtils.kt$LazyMappedList<T, U> : AbstractList - MaxLineLength:InternalUtils.kt$if (predicate(iterator.next())) throw IllegalArgumentException("Collection contains more than one matching element.") MaxLineLength:InternalUtils.kt$val Class<*>.packageNameOrNull: String? // This intentionally does not go via `package` as that code path is slow and contended and just ends up doing this. get() { val name = this.getName() val i = name.lastIndexOf('.') if (i != -1) { return name.substring(0, i) } else { return null } } - MaxLineLength:Interpolators.kt$CubicSplineInterpolator : Interpolator - MaxLineLength:Interpolators.kt$Polynomial MaxLineLength:InvocationContext.kt$Actor.Companion$@JvmStatic fun service(serviceClassName: String, owningLegalIdentity: CordaX500Name): Actor - MaxLineLength:InvocationContext.kt$InvocationContext MaxLineLength:InvocationContext.kt$InvocationContext$@CordaSerializable data MaxLineLength:InvocationContext.kt$InvocationContext.Companion$ @DeleteForDJVM @JvmStatic fun newInstance(origin: InvocationOrigin, trace: Trace = Trace.newInstance(), actor: Actor? = null, externalTrace: Trace? = null, impersonatedActor: Actor? = null) MaxLineLength:InvocationContext.kt$InvocationContext.Companion$ @DeleteForDJVM @JvmStatic fun peer(party: CordaX500Name, trace: Trace = Trace.newInstance(), externalTrace: Trace? = null, impersonatedActor: Actor? = null): InvocationContext @@ -6319,401 +3780,141 @@ MaxLineLength:InvocationContext.kt$InvocationContext.Companion$ @DeleteForDJVM @JvmStatic fun shell(trace: Trace = Trace.newInstance(), externalTrace: Trace? = null): InvocationContext MaxLineLength:IrsDemoClientApi.kt$IRSDemoClientApi$val fileContents = IOUtils.toString(Thread.currentThread().contextClassLoader.getResourceAsStream("net/corda/irs/simulation/example.rates.txt"), Charsets.UTF_8.name()) MaxLineLength:IrsDemoClientApi.kt$IRSDemoClientApi$val fileContents = IOUtils.toString(javaClass.classLoader.getResourceAsStream("net/corda/irs/web/simulation/example-irs-trade.json"), Charsets.UTF_8.name()) - MaxLineLength:IsolatedTask.kt$IsolatedTask$/** * The class loader to use for loading the [java.util.function.Function] and any referenced code in [SandboxExecutor.run]. */ val classLoader: SandboxClassLoader get() = SandboxRuntimeContext.instance.classLoader - MaxLineLength:IsolatedTask.kt$IsolatedTask${ /** * Run an action in an isolated environment. */ fun <T> run(action: IsolatedTask.() -> T?): Result<T> { val runnable = this val threadName = "DJVM-$identifier-${uniqueIdentifier.getAndIncrement()}" val completionLatch = CountDownLatch(1) var output: T? = null var costs = CostSummary.empty var exception: Throwable? = null thread(name = threadName, isDaemon = true) { logger.trace("Entering isolated runtime environment...") SandboxRuntimeContext(configuration).use { output = try { action(runnable) } catch (ex: Throwable) { logger.error("Exception caught in isolated runtime environment", ex) exception = (ex as? LinkageError)?.cause ?: ex null } costs = CostSummary(runtimeCosts) } logger.trace("Exiting isolated runtime environment...") completionLatch.countDown() } completionLatch.await() val messages = exception.let { when (it) { is SandboxClassLoadingException -> it.messages is SandboxException -> { when (it.exception) { is SandboxClassLoadingException -> it.exception.messages else -> null } } else -> null } } ?: MessageCollection() return Result(threadName, output, costs, messages, exception) } /** * The result of a run of an [IsolatedTask]. * * @property identifier The identifier of the [IsolatedTask]. * @property output The result of the run, if successful. * @property costs Captured runtime costs as reported at the end of the run. * @property messages The messages collated during the run. * @property exception This holds any exceptions that might get thrown during execution. */ data class Result<T>( val identifier: String, val output: T?, val costs: CostSummary, val messages: MessageCollection, val exception: Throwable? ) /** * The class loader to use for loading the [java.util.function.Function] and any referenced code in [SandboxExecutor.run]. */ val classLoader: SandboxClassLoader get() = SandboxRuntimeContext.instance.classLoader // TODO Caching can transcend thread-local contexts by taking the sandbox configuration into account in the key derivation private companion object { /** * An atomically incrementing identifier used to uniquely identify each runnable. */ private val uniqueIdentifier = AtomicLong(0) private val logger = loggerFor<IsolatedTask>() } } - MaxLineLength:IssueCash.kt$IssueCash$BankOfCordaClientApi.requestWebIssue(NetworkHostAndPort("localhost", BOC_WEB_PORT), createParams(amount, NOTARY_NAME)) - MaxLineLength:IssueCash.kt$IssueCash$private - MaxLineLength:IssueCash.kt$IssueCash$return BankOfCordaClientApi.requestRPCIssue(NetworkHostAndPort("localhost", BOC_RPC_PORT), createParams(amount, NOTARY_NAME)) - MaxLineLength:IssueCash.kt$IssueCash$val currency = parser.accepts("currency").withOptionalArg().ofType(String::class.java).describedAs("[GBP|USD|CHF|EUR]") MaxLineLength:IssueCash.kt$IssueCash$val roleArg = parser.accepts("role").withRequiredArg().ofType(Role::class.java).describedAs("[ISSUER|ISSUE_CASH_RPC|ISSUE_CASH_WEB]") - MaxLineLength:IssueCashLoggingTests.kt$IssueCashLoggingTests$nodeA.rpc.startFlow(::CashIssueAndPaymentFlow, amount, ref, recipient, false, defaultNotaryIdentity).returnValue.getOrThrow() MaxLineLength:IssueCashLoggingTests.kt$IssueCashLoggingTests$val linesWithDuplicateInsertionWarningsInA = nodeA.logFile().useLines { lines -> lines.filter(String::containsDuplicateInsertWarning).toList() } MaxLineLength:IssueCashLoggingTests.kt$IssueCashLoggingTests$val linesWithDuplicateInsertionWarningsInB = nodeB.logFile().useLines { lines -> lines.filter(String::containsDuplicateInsertWarning).toList() } - MaxLineLength:IssueCashLoggingTests.kt$private fun String.containsDuplicateInsertWarning(): Boolean - MaxLineLength:IssuerModel.kt$IssuerModel$private val cashAppConfiguration = proxy.map { it?.cordaRPCOps?.startFlow(::CashConfigDataFlow)?.returnValue?.getOrThrow() } MaxLineLength:IssuerModel.kt$IssuerModel$val currencyTypes = ChosenList(cashAppConfiguration.map { it?.issuableCurrencies?.observable() ?: FXCollections.emptyObservableList() }, "currencyTypes") MaxLineLength:IssuerModel.kt$IssuerModel$val supportedCurrencies = ChosenList(cashAppConfiguration.map { it?.supportedCurrencies?.observable() ?: FXCollections.singletonObservableList(defaultCurrency) }, "supportedCurrencies") - MaxLineLength:JacksonSupport.kt$JacksonSupport$ @JvmStatic @JvmOverloads fun createDefaultMapper(rpc: CordaRPCOps, factory: JsonFactory = JsonFactory(), fuzzyIdentityMatch: Boolean = false, fullParties: Boolean = false): ObjectMapper - MaxLineLength:JacksonSupport.kt$JacksonSupport$ @JvmStatic @JvmOverloads fun createInMemoryMapper(identityService: IdentityService, factory: JsonFactory = JsonFactory(), fuzzyIdentityMatch: Boolean = false, fullParties: Boolean = false): ObjectMapper - MaxLineLength:JacksonSupport.kt$JacksonSupport$ @JvmStatic @JvmOverloads fun createNonRpcMapper(factory: JsonFactory = JsonFactory(), fullParties: Boolean = false): ObjectMapper - MaxLineLength:JacksonSupport.kt$JacksonSupport$@CordaInternal @VisibleForTesting internal - MaxLineLength:JacksonSupport.kt$JacksonSupport$@Deprecated("Do not use this as it's not thread safe. Instead get a ObjectMapper instance with one of the create*Mapper methods.") - MaxLineLength:JacksonSupport.kt$JacksonSupport.IdentityObjectMapper$override fun wellKnownPartyFromX500Name(name: CordaX500Name): Party? - MaxLineLength:JacksonSupport.kt$JacksonSupport.PartyDeserializer$?: MaxLineLength:JacksonSupport.kt$JacksonSupport.PartyDeserializer$mapper.wellKnownPartyFromX500Name(principal) ?: throw JsonParseException(parser, "Could not find a Party with name $principal") MaxLineLength:JacksonSupport.kt$JacksonSupport.PartyDeserializer$throw JsonParseException(parser, "No matching Party found, then tried to directly deserialise ${parser.text} as a PublicKey with no success", e) - MaxLineLength:JacksonSupport.kt$JacksonSupport.RpcObjectMapper$@Deprecated("This is an internal class, do not use", replaceWith = ReplaceWith("JacksonSupport.createDefaultMapper")) - MaxLineLength:JacksonSupport.kt$JacksonSupport.X509CertificateSerializer$writeObjectField("keyUsage", value.keyUsage?.asList()?.mapIndexedNotNull { i, flag -> if (flag) keyUsages[i] else null }) - MaxLineLength:JacksonSupport.kt$JacksonSupport.X509CertificateSerializer$writeObjectField("pathLength", value.basicConstraints.let { if (it != Int.MAX_VALUE) it else null }) MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest$TransactionSignature(ByteArray(1), ALICE_PUBKEY, SignatureMetadata(1, Crypto.findSignatureScheme(ALICE_PUBKEY).schemeNumberID), partialMerkleTree) - MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest$TransactionSignature(ByteArray(1), BOB_PUBKEY, SignatureMetadata(1, Crypto.findSignatureScheme(BOB_PUBKEY).schemeNumberID)) - MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest$assertThat(json["class"].textValue()).isEqualTo("net.corda.client.jackson.JacksonSupportTest\$ClassNotOnClasspath") - MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest$assertThat(mapper.convertValue<OpaqueBytes>(BinaryNode(byteArrayOf(1, 2, 3, 4)))).isEqualTo(OpaqueBytes.of(1, 2, 3, 4)) - MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest$assertThat(mapper.convertValue<SerializedBytes<*>>(BinaryNode(serializedBytes.bytes))).isEqualTo(serializedBytes) - MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest$assertThat(mapper.convertValue<SignatureScheme>(TextNode("EDDSA_ED25519_SHA512"))).isSameAs(Crypto.EDDSA_ED25519_SHA512) - MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest$assertThat(mapper.valueToTree<TextNode>(Amount.parseCurrency("£25000000")).textValue()).isEqualTo("25000000.00 GBP") - MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest$fun convertToNodeInfo() - MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest$val transactionSignature = TransactionSignature(secureRandomBytes(128), BOB_PUBKEY, signatureMetadata, partialMerkleTree) MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest$val wtxFields = wtxJson.assertHasOnlyFields("id", "notary", "inputs", "attachments", "outputs", "commands", "timeWindow", "references", "privacySalt", "networkParametersHash") MaxLineLength:JacksonSupportTest.kt$JacksonSupportTest${ val cert: X509Certificate = MINI_CORP.identity.certificate val json = mapper.valueToTree<ObjectNode>(cert) println(mapper.writeValueAsString(json)) assertThat(json["serialNumber"].bigIntegerValue()).isEqualTo(cert.serialNumber) assertThat(json["issuer"].valueAs<X500Principal>(mapper)).isEqualTo(cert.issuerX500Principal) assertThat(json["subject"].valueAs<X500Principal>(mapper)).isEqualTo(cert.subjectX500Principal) // cert.publicKey should be converted to a supported format (this is required because [Certificate] returns keys as SUN EC keys, not BC). assertThat(json["publicKey"].valueAs<PublicKey>(mapper)).isEqualTo(Crypto.toSupportedPublicKey(cert.publicKey)) assertThat(json["notAfter"].valueAs<Date>(mapper)).isEqualTo(cert.notAfter) assertThat(json["notBefore"].valueAs<Date>(mapper)).isEqualTo(cert.notBefore) assertThat(json["encoded"].binaryValue()).isEqualTo(cert.encoded) } - MaxLineLength:JarScanningCordappLoader.kt$CordappLoaderTemplate$"${entry.value.first().first.name}: [ ${entry.value.joinToString { it.second.jarPath.toString() }} ]." - MaxLineLength:JarScanningCordappLoader.kt$CordappLoaderTemplate$throw MultipleCordappsForFlowException("There are multiple CorDapp JARs on the classpath for flow " + "${entry.value.first().first.name}: [ ${entry.value.joinToString { it.second.jarPath.toString() }} ].") MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$"platform version ${it.minimumPlatformVersion} (This node is running version ${versionInfo.platformVersion})." MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$?: - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$RestrictedURL - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$contractInfo != null && workflowInfo != null -> return Cordapp.Info.ContractAndWorkflow(contractInfo, workflowInfo) - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$it.javaClass.location == cordappJarPath.url && it.javaClass.name.startsWith(cordappJarPath.qualifiedNamePrefix) MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$logger MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$override val appClassLoader: URLClassLoader = URLClassLoader(cordappJarPaths.stream().map { it.url }.toTypedArray(), javaClass.classLoader) MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$private val signerKeyFingerprintBlacklist: List<SecureHash.SHA256> = emptyList() - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$return Modifier.isPublic(modifiers) && !isLocalClass && !isAnonymousClass && (!isMemberClass || Modifier.isStatic(modifiers)) - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$return scanResult.getClassesWithAnnotation(FlowLogic::class, StartableByRPC::class).filter { it.isUserInvokable() } - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$throw CordappInvalidVersionException("Target versionId ($versionStr) for attribute $attributeName must not be smaller than 1.") MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$throw CordappInvalidVersionException("Target versionId attribute $attributeName not specified. Please specify a whole number starting from 1.") - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$val blockedCertificates = certificates.filter { it.publicKey.hash.sha256() in signerKeyFingerprintBlacklist } - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$val certificates = it.jarPath.openStream().let(::JarInputStream).use(JarSignatureCollector::collectCertificates) - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$val scanResult = ClassGraph().addClassLoader(appClassLoader).overrideClasspath(cordappJarPath.url).enableAllInfo().pooledScan() - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$val targetPlatformVersion = manifest?.get(CordappImpl.TARGET_PLATFORM_VERSION)?.toIntOrNull() ?: minPlatformVersion - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$versionId = parseVersion(manifest[CordappImpl.CORDAPP_CONTRACT_VERSION], CordappImpl.CORDAPP_CONTRACT_VERSION) - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader$versionId = parseVersion(manifest[CordappImpl.CORDAPP_WORKFLOW_VERSION], CordappImpl.CORDAPP_WORKFLOW_VERSION) - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader.Companion$ fun fromJarUrls(scanJars: List<URL>, versionInfo: VersionInfo = VersionInfo.UNKNOWN, extraCordapps: List<CordappImpl> = emptyList(), cordappsSignerKeyFingerprintBlacklist: List<SecureHash.SHA256> = emptyList()): JarScanningCordappLoader - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader.Companion$cordappsSignerKeyFingerprintBlacklist: List<SecureHash.SHA256> = emptyList() - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader.Companion$signerKeyFingerprintBlacklist: List<SecureHash.SHA256> = emptyList() - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader.RestrictedScanResult$fun <T : Any> getClassesWithAnnotation(type: KClass<T>, annotation: KClass<out Annotation>): List<Class<out T>> - MaxLineLength:JarScanningCordappLoader.kt$JarScanningCordappLoader.RestrictedScanResult$private inner - MaxLineLength:JarScanningCordappLoaderTest.kt$JarScanningCordappLoaderTest$@Test fun `cordapp classloader does not load apps when their min platform version is greater than the node platform version`() MaxLineLength:JarScanningCordappLoaderTest.kt$JarScanningCordappLoaderTest$assertThat(actualCordapp.serializationWhitelists.first().javaClass.name).isEqualTo("net.corda.serialization.internal.DefaultWhitelist") - MaxLineLength:JarScanningCordappLoaderTest.kt$JarScanningCordappLoaderTest$val cordapp = loader.cordapps.single { it.cordappClasses.contains("net.corda.core.internal.cordapp.CordappImpl") } - MaxLineLength:JarScanningCordappLoaderTest.kt$JarScanningCordappLoaderTest$val loader = JarScanningCordappLoader.fromJarUrls(listOf(jar), cordappsSignerKeyFingerprintBlacklist = DEV_PUB_KEY_HASHES) - MaxLineLength:JarScanningCordappLoaderTest.kt$JarScanningCordappLoaderTest$val loader = JarScanningCordappLoader.fromJarUrls(listOf(jar), cordappsSignerKeyFingerprintBlacklist = emptyList()) - MaxLineLength:JarSignatureCollector.kt$JarSignatureCollector$ fun collectCertificates(jar: JarInputStream): List<X509Certificate> - MaxLineLength:JarSignatureCollector.kt$JarSignatureCollector$/** * @see <https://docs.oracle.com/javase/8/docs/technotes/guides/jar/jar.html#Signed_JAR_File> * Additionally accepting *.EC as its valid for [java.util.jar.JarVerifier] and jarsigner @see https://docs.oracle.com/javase/8/docs/technotes/tools/windows/jarsigner.html, * temporally treating META-INF/INDEX.LIST as unsignable entry because [java.util.jar.JarVerifier] doesn't load its signers. */ private val unsignableEntryName = "META-INF/(?:(?:.*[.](?:SF|DSA|RSA|EC)|SIG-.*)|INDEX\\.LIST)".toRegex() MaxLineLength:JarSignatureCollectorTest.kt$JarSignatureCollectorTest$// Signing with EC algorithm produces META-INF/*.EC file name not compatible with JAR File Spec however it's compatible with java.util.JarVerifier // and our JarSignatureCollector @Test fun `one signer with EC algorithm`() - MaxLineLength:JarSignatureCollectorTest.kt$JarSignatureCollectorTest$assertEquals(listOf(key), dir.getJarSigners(FILENAME)) - MaxLineLength:JarSignatureCollectorTest.kt$JarSignatureCollectorTest${ (dir / "volatile").writeLines(listOf("volatile")) dir.createJar(FILENAME, "volatile") val key1 = signAsAlice() assertEquals(listOf(key1), dir.getJarSigners(FILENAME)) (dir / "volatile").writeLines(listOf("garbage")) dir.updateJar(FILENAME, "volatile", "_signable1") // ALICE's signature on volatile is now bad. signAsBob() // The JDK doesn't care that BOB has correctly signed the whole thing, it won't let us process the entry with ALICE's bad signature: assertFailsWith<SecurityException> { dir.getJarSigners(FILENAME) } } - MaxLineLength:JarSignatureTestUtils.kt$JarSignatureTestUtils$executeProcess("jarsigner", "-keystore", "_teststore", "-storepass", storePassword, "-keypass", keyPassword, fileName, alias) MaxLineLength:JarSignatureTestUtils.kt$JarSignatureTestUtils$executeProcess("keytool", "-genkeypair", "-keystore", storeName, "-storepass", storePassword, "-keyalg", keyalg, "-alias", alias, "-keypass", keyPassword, "-dname", name) MaxLineLength:JarSignatureTestUtils.kt$JarSignatureTestUtils$fun Path.generateKey(alias: String = "Test", storePassword: String = "secret!", name: String = CODE_SIGNER.toString(), keyalg: String = "RSA", keyPassword: String = storePassword, storeName: String = "_teststore") : PublicKey - MaxLineLength:JarSignatureTestUtils.kt$JarSignatureTestUtils$fun Path.signJar(fileName: String, alias: String, storePassword: String, keyPassword: String = storePassword): PublicKey MaxLineLength:KMSUtils.kt$require(issuerRole == CertRole.LEGAL_IDENTITY) { "Confidential identities can only be issued from well known identities, provided issuer ${issuer.name} has role $issuerRole" } - MaxLineLength:KeyManagementService.kt$KeyManagementService$ @Suspendable fun freshKey(externalId: UUID): PublicKey - MaxLineLength:KeyManagementService.kt$KeyManagementService$ @Suspendable fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean): PartyAndCertificate - MaxLineLength:KeyManagementService.kt$KeyManagementService$ @Suspendable fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean, externalId: UUID): PartyAndCertificate - MaxLineLength:KeyManagementService.kt$KeyManagementService$ @Suspendable fun sign(bytes: ByteArray, publicKey: PublicKey): DigitalSignature.WithKey - MaxLineLength:KeyManagementService.kt$KeyManagementService$ @Suspendable fun sign(signableData: SignableData, publicKey: PublicKey): TransactionSignature - MaxLineLength:KeyStoreConfigHelpers.kt$"certificates/$DEV_CA_TRUST_STORE_FILE" MaxLineLength:KeyStoreConfigHelpers.kt$// A code signing policy is currently under design. // The following interim key represents a self-signed certificate produced using the Java keytool and located in the gradle cordapp plugins resources key store: // https://github.com/corda/corda-gradle-plugins/blob/master/cordapp/src/main/resources/certificates/cordadevcodesign.jks const val DEV_CORDAPP_CODE_SIGNING_STR = "AA59D829F2CA8FDDF5ABEA40D815F937E3E54E572B65B93B5C216AE6594E7D6B" - MaxLineLength:KeyStoreConfigHelpers.kt$devNodeCa: CertificateAndKeyPair = createDevNodeCa(intermediateCa, legalName) - MaxLineLength:KeyStoreConfigHelpers.kt$fun CertificateStore.storeLegalIdentity(alias: String, keyPair: KeyPair = Crypto.generateKeyPair()): PartyAndCertificate - MaxLineLength:KeyStoreConfigHelpers.kt$fun loadDevCaKeyStore(classLoader: ClassLoader = DevCaHelper::class.java.classLoader): CertificateStore - MaxLineLength:KeyStoreConfigHelpers.kt$fun loadDevCaTrustStore(classLoader: ClassLoader = DevCaHelper::class.java.classLoader): CertificateStore - MaxLineLength:KeyStoreConfigHelpers.kt$nodeKeyPair: KeyPair = generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) MaxLineLength:KeyStoreConfigHelpers.kt$setPrivateKey MaxLineLength:KeyStoreConfigHelpers.kt$val DEV_PUB_KEY_HASHES: List<SecureHash.SHA256> get() = listOf(DEV_INTERMEDIATE_CA.certificate, DEV_ROOT_CA.certificate).map { it.publicKey.hash.sha256() } + SecureHash.parse(DEV_CORDAPP_CODE_SIGNING_STR).sha256() MaxLineLength:KeyStoreConfigHelpers.kt$val identityCert = X509Utilities.createCertificate(CertificateType.LEGAL_IDENTITY, nodeCaCertAndKeyPair.certificate, nodeCaCertAndKeyPair.keyPair, nodeCaCertAndKeyPair.certificate.subjectX500Principal, keyPair.public) MaxLineLength:KeyStoreConfigHelpers.kt$val nameConstraints = NameConstraints(arrayOf(GeneralSubtree(GeneralName(GeneralName.directoryName, legalName.toX500Name()))), arrayOf()) - MaxLineLength:KeyStoreConfigHelpers.kt$val nodeCaCertAndKeyPair = getCertificateAndKeyPair(X509Utilities.CORDA_CLIENT_CA, this@storeLegalIdentity.entryPassword) MaxLineLength:KeyStoreConfigHelpers.kt$val tlsCert = X509Utilities.createCertificate(CertificateType.TLS, devNodeCa.certificate, devNodeCa.keyPair, legalName.x500Principal, tlsKeyPair.public) - MaxLineLength:KeyStoreUtilities.kt$ fun KeyStore.addOrReplaceKey(alias: String, key: Key, password: CharArray, chain: Array<out Certificate>) - MaxLineLength:KeyStoreUtilities.kt$ fun KeyStore.getSupportedKey(alias: String, keyPassword: String): PrivateKey - MaxLineLength:KeyStoreUtilities.kt$ fun KeyStore.save(keyStoreFilePath: Path, storePassword: String) MaxLineLength:KeyStoreUtilities.kt$return certificate as? X509Certificate ?: throw IllegalStateException("Certificate under alias \"$alias\" is not an X.509 certificate: $certificate") - MaxLineLength:KotlinIntegrationTestingTutorial.kt$KotlinIntegrationTestingTutorial$bobProxy.startFlow(::CashPaymentFlow, 1000.DOLLARS, alice.nodeInfo.singleIdentity()).returnValue.getOrThrow() - MaxLineLength:KotlinUtilsTest.kt$KotlinUtilsTest$original.checkpointSerialize(context = KRYO_CHECKPOINT_CONTEXT).checkpointDeserialize(context = KRYO_CHECKPOINT_NOWHITELIST_CONTEXT) - MaxLineLength:KotlinUtilsTest.kt$KotlinUtilsTest$val copy = original.checkpointSerialize(context = KRYO_CHECKPOINT_CONTEXT).checkpointDeserialize(context = KRYO_CHECKPOINT_CONTEXT) - MaxLineLength:Kryo.kt$ContractUpgradeFilteredTransactionSerializer$override MaxLineLength:Kryo.kt$ContractUpgradeFilteredTransactionSerializer$val visibleComponents: Map<Int, ContractUpgradeFilteredTransaction.FilteredComponent> = uncheckedCast(kryo.readClassAndObject(input)) - MaxLineLength:Kryo.kt$ContractUpgradeWireTransactionSerializer$override MaxLineLength:Kryo.kt$ImmutableClassSerializer$throw KryoException("Hashcode mismatch for parameter types for ${klass.qualifiedName}: unsupported type evolution has happened.") - MaxLineLength:Kryo.kt$PublicKeySerializer${ // TODO: Instead of encoding to the default X509 format, we could have a custom per key type (space-efficient) serialiser. output.writeBytesWithLength(obj.encoded) } MaxLineLength:Kryo.kt$ThrowableSerializer$private val delegate: Serializer<Throwable> = uncheckedCast(ReflectionSerializerFactory.makeSerializer(kryo, FieldSerializer::class.java, type)) - MaxLineLength:Kryo.kt$X509CertificateSerializer$return CertificateFactory.getInstance("X.509").generateCertificate(input.readBytesWithLength().inputStream()) as X509Certificate - MaxLineLength:Kryo.kt$fun Kryo.serializationContext(): SerializeAsTokenContext? - MaxLineLength:Kryo.kt$if (elemCount < minLen) throw KryoException("Cannot deserialize list, too little elements. Minimum required: $minLen, got: $elemCount") - MaxLineLength:KryoCheckpointSerializer.kt$AutoCloseableSerialisationDetector$override fun read(kryo: Kryo, input: Input, type: Class<AutoCloseable>) - MaxLineLength:KryoCheckpointSerializer.kt$AutoCloseableSerialisationDetector$val message = "${closeable.javaClass.name}, which is a closeable resource, has been detected during flow checkpointing. " + "Restoring such resources across node restarts is not supported. Make sure code accessing it is " + "confined to a private method or the reference is nulled out." MaxLineLength:KryoCheckpointSerializer.kt$KryoCheckpointSerializer$context.encodingWhitelist.acceptEncoding(encoding) || throw KryoException(encodingNotPermittedFormat.format(encoding)) - MaxLineLength:KryoCheckpointSerializer.kt$KryoCheckpointSerializer$override - MaxLineLength:KryoCheckpointSerializer.kt$KryoCheckpointSerializer$val serializer = Fiber.getFiberSerializer(false) as KryoSerializer val classResolver = CordaClassResolver(context).apply { setKryo(serializer.kryo) } // TODO The ClassResolver can only be set in the Kryo constructor and Quasar doesn't provide us with a way of doing that val field = Kryo::class.java.getDeclaredField("classResolver").apply { isAccessible = true } serializer.kryo.apply { field.set(this, classResolver) // don't allow overriding the public key serializer for checkpointing DefaultKryoCustomizer.customize(this) addDefaultSerializer(AutoCloseable::class.java, AutoCloseableSerialisationDetector) register(ClosureSerializer.Closure::class.java, CordaClosureSerializer) classLoader = it.second } - MaxLineLength:KryoTests.kt$KryoTests$@Test fun `serialised form is stable when the same object instance occurs more than once, and using java serialisation`() MaxLineLength:KryoTests.kt$KryoTests$assertThat(deserialisedList.checkpointSerialize(noReferencesContext)).isEqualTo(originalList.checkpointSerialize(noReferencesContext)) MaxLineLength:KryoTests.kt$KryoTests$assertThat(listWithSameInstances.checkpointSerialize(noReferencesContext)).isEqualTo(listWithCopies.checkpointSerialize(noReferencesContext)) - MaxLineLength:KryoTests.kt$KryoTests$val deserialisedList = originalList.checkpointSerialize(noReferencesContext).checkpointDeserialize(noReferencesContext) - MaxLineLength:KryoTests.kt$KryoTests$val deserialisedMap: Map<Int, Int> = emptyMap<Int, Int>().checkpointSerialize(context).checkpointDeserialize(context) - MaxLineLength:KryoTests.kt$KryoTests$val meta = SignableData(testBytes.sha256(), SignatureMetadata(1, Crypto.findSignatureScheme(ALICE_PUBKEY).schemeNumberID)) - MaxLineLength:KryoTests.kt$KryoTests$val readRubbishStream: InputStream = rubbish.inputStream().checkpointSerialize(context).checkpointDeserialize(context) - MaxLineLength:KryoTests.kt$KryoTests$val streams = byteArrays.map { it.inputStream() }.checkpointSerialize(context).checkpointDeserialize(context).iterator() - MaxLineLength:LargeTransactionsTest.kt$LargeTransactionsTest$networkParameters = testNetworkParameters(maxMessageSize = 15.MB.toInt(), maxTransactionSize = 13.MB.toInt()) MaxLineLength:LargeTransactionsTest.kt$LargeTransactionsTest$val (alice, _) = listOf(ALICE_NAME, BOB_NAME).map { startNode(providedName = it, rpcUsers = listOf(rpcUser)) }.transpose().getOrThrow() - MaxLineLength:LazyPool.kt$LazyPool<A> MaxLineLength:LazyStickyPool.kt$LazyStickyPool<A : Any> - MaxLineLength:LedgerDSLInterpreter.kt$LedgerDSL$ @JvmOverloads fun unverifiedTransaction(label: String? = null, transactionBuilder: TransactionBuilder = TransactionBuilder(notary = notary), dsl: TransactionDSL<TransactionDSLInterpreter>.() -> Unit) - MaxLineLength:LedgerDSLInterpreter.kt$LedgerDSL<out T : TransactionDSLInterpreter, out L : LedgerDSLInterpreter<T>> : LedgerDSLInterpreter MaxLineLength:LedgerTransaction.kt$LedgerTransaction : FullTransaction - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ @Throws(TransactionVerificationException::class) fun verify() - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ fun <T : CommandData> commandsOfType(clazz: Class<T>): List<Command<T>> - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ fun <T : CommandData> filterCommands(clazz: Class<T>, predicate: Predicate<T>): List<Command<T>> - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ fun <T : CommandData> findCommand(clazz: Class<T>, predicate: Predicate<T>): Command<T> - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ fun <T : CommandData> getCommand(index: Int): Command<T> - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ fun <T : ContractState> filterInRefs(clazz: Class<T>, predicate: Predicate<T>): List<StateAndRef<T>> - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ fun <T : ContractState> filterInputs(clazz: Class<T>, predicate: Predicate<T>): List<T> - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ fun <T : ContractState> filterReferenceInputRefs(clazz: Class<T>, predicate: Predicate<T>): List<StateAndRef<T>> - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ fun <T : ContractState> filterReferenceInputs(clazz: Class<T>, predicate: Predicate<T>): List<T> - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ fun <T : ContractState> inputsOfType(clazz: Class<T>): List<T> - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$ fun <T : ContractState> referenceInputsOfType(clazz: Class<T>): List<T> - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$"Use WireTransaction.toLedgerTransaction instead. The result of the verify method would not be accurate." - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$( inputs: List<StateAndRef<ContractState>>, outputs: List<TransactionState<ContractState>>, commands: List<CommandWithParties<CommandData>>, attachments: List<Attachment>, id: SecureHash, notary: Party?, timeWindow: TimeWindow?, privacySalt: PrivacySalt, networkParameters: NetworkParameters ) - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$/** * Network parameters that were in force when the transaction was constructed. This is nullable only for backwards * compatibility for serialized transactions. In reality this field will always be set when on the normal codepaths. */ override val networkParameters: NetworkParameters? - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$/** A list of [Attachment] objects identified by the transaction that are needed for this transaction to verify. */ val attachments: List<Attachment> MaxLineLength:LedgerTransaction.kt$LedgerTransaction$/** Random data used to make the transaction hash unpredictable even if the contents can be predicted; needed to avoid some obscure attacks. */ val privacySalt: PrivacySalt - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$/** The notary that the tx uses, this must be the same as the notary of all the inputs, or null if there are no inputs. */ override val notary: Party? - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$// Create a copy of the outer LedgerTransaction which deserializes all fields inside the [transactionClassLoader]. // Only the copy will be used for verification, and the outer shell will be discarded. // This artifice is required to preserve backwards compatibility. Verifier(createLtxForVerification(), transactionClassLoader) - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$inline - MaxLineLength:LedgerTransaction.kt$LedgerTransaction$inline fun <reified T : ContractState> referenceInputRefsOfType(): List<StateAndRef<T>> MaxLineLength:LedgerTransaction.kt$LedgerTransaction$logger MaxLineLength:LedgerTransaction.kt$LedgerTransaction$return AttachmentsClassLoaderBuilder.withAttachmentsClassloaderContext(this.attachments + extraAttachments, getParamsWithGoo(), id) { transactionClassLoader -> // Create a copy of the outer LedgerTransaction which deserializes all fields inside the [transactionClassLoader]. // Only the copy will be used for verification, and the outer shell will be discarded. // This artifice is required to preserve backwards compatibility. Verifier(createLtxForVerification(), transactionClassLoader) } MaxLineLength:LedgerTransaction.kt$LedgerTransaction$return inputs.mapNotNull { if (clazz.isInstance(it.state.data)) uncheckedCast<StateAndRef<ContractState>, StateAndRef<T>>(it) else null } MaxLineLength:LedgerTransaction.kt$LedgerTransaction$return references.mapNotNull { if (clazz.isInstance(it.state.data)) uncheckedCast<StateAndRef<ContractState>, StateAndRef<T>>(it) else null } MaxLineLength:LedgerTransaction.kt$LedgerTransaction$throw UnsupportedOperationException("Cannot verify a LedgerTransaction created using deprecated constructors outside of flow context.") MaxLineLength:LedgerTransaction.kt$LedgerTransaction$val deserializedOutputs = deserialiseComponentGroup(componentGroups, TransactionState::class, ComponentGroupEnum.OUTPUTS_GROUP, forceDeserialize = true) - MaxLineLength:LedgerTransaction.kt$LedgerTransaction${ // Switch thread local deserialization context to using a cached attachments classloader. This classloader enforces various rules // like no-overlap, package namespace ownership and (in future) deterministic Java. return AttachmentsClassLoaderBuilder.withAttachmentsClassloaderContext(this.attachments + extraAttachments, getParamsWithGoo(), id) { transactionClassLoader -> // Create a copy of the outer LedgerTransaction which deserializes all fields inside the [transactionClassLoader]. // Only the copy will be used for verification, and the outer shell will be discarded. // This artifice is required to preserve backwards compatibility. Verifier(createLtxForVerification(), transactionClassLoader) } } - MaxLineLength:LedgerTransaction.kt$LedgerTransaction${ // This path is triggered if someone used old constructors that were accidentally exposed; darn Kotlin's lack of package-private // visibility! We did originally try to maintain verification codepaths that supported lack of network parameters, but, it // got too convoluted and people kept just !! asserting the nullity away because on normal codepaths this is always set. logger.warn("Network parameters on the LedgerTransaction with id: $id are null. Please don't use deprecated constructors of the LedgerTransaction. " + "Use WireTransaction.toLedgerTransaction instead. The result of the verify method would not be accurate.") // Roll the dice - we're probably in flow context if we got here at all, which means we can fish the current params out. try { params = getParamsFromFlowLogic() } catch (e: UnsupportedOperationException) { // Inside DJVM, ignore. } if (params == null) throw UnsupportedOperationException("Cannot verify a LedgerTransaction created using deprecated constructors outside of flow context.") } MaxLineLength:LedgerTransaction.kt$LedgerTransaction.Companion$return LedgerTransaction(inputs, outputs, commands, attachments, id, notary, timeWindow, privacySalt, networkParameters, references).apply { this.componentGroups = componentGroups this.serializedInputs = serializedInputs this.serializedReferences = serializedReferences } - MaxLineLength:LedgerTransaction.kt$LedgerTransaction.InOutGroup$@KeepForDJVM data MaxLineLength:LedgerTransactionQueryTests.kt$LedgerTransactionQueryTests$return StateAndRef(TransactionState(dummyState, DummyContract.PROGRAM_ID, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint), dummyStateRef) - MaxLineLength:LegalNameValidator.kt$LegalNameValidator$ fun validateNameAttribute(normalizedNameAttribute: String, validation: Validation) - MaxLineLength:LegalNameValidator.kt$LegalNameValidator$ fun validateOrganization(normalizedOrganization: String, validation: Validation) - MaxLineLength:LegalNameValidator.kt$LegalNameValidator$@Deprecated("Use validateOrganization instead", replaceWith = ReplaceWith("validateOrganization(normalizedLegalName)")) - MaxLineLength:LegalNameValidator.kt$LegalNameValidator.Rule.CapitalLetterRule$require(legalName == capitalizedLegalName) { "Legal name should be capitalized. i.e. '$capitalizedLegalName'" } MaxLineLength:LegalNameValidator.kt$LegalNameValidator.Rule.MustHaveAtLeastTwoLettersRule$require(legalName.count { it.isLetter() } >= 2) { "Illegal input legal name '$legalName'. Legal name must have at least two letters" } MaxLineLength:LegalNameValidator.kt$LegalNameValidator.Rule.UnicodeNormalizationRule$require(legalName == normalize(legalName)) { "Legal name must be normalized. Please use 'normalize' to normalize the legal name before validation." } - MaxLineLength:LegalNameValidator.kt$LegalNameValidator.Rule.UnicodeRangeRule$val illegalChars = legalName.toCharArray().filter { Character.UnicodeBlock.of(it) !in supportScriptsSet }.size MaxLineLength:LegalNameValidatorTest.kt$LegalNameValidatorTest$LegalNameValidator.validateNameAttribute("The quick brown fox jumped over the lazy dog.1234567890", LegalNameValidator.Validation.FULL) - MaxLineLength:LegalNameValidatorTest.kt$LegalNameValidatorTest$LegalNameValidator.validateOrganization("Legal Name With\n\rLine\nBreaks", LegalNameValidator.Validation.FULL) MaxLineLength:LegalNameValidatorTest.kt$LegalNameValidatorTest$LegalNameValidator.validateOrganization("Legal Name\u2004With\u0009Unicode\u0020Whitespaces", LegalNameValidator.Validation.FULL) MaxLineLength:LegalNameValidatorTest.kt$LegalNameValidatorTest$LegalNameValidator.validateOrganization("The quick brown fox jumped over the lazy dog.1234567890", LegalNameValidator.Validation.FULL) - MaxLineLength:LegalNameValidatorTest.kt$LegalNameValidatorTest$LegalNameValidator.validateOrganization(LegalNameValidator.normalize("Test Legal Name"), LegalNameValidator.Validation.FULL) - MaxLineLength:LegalNameValidatorTest.kt$LegalNameValidatorTest$LegalNameValidator.validateOrganization(longLegalName.append("A").toString(), LegalNameValidator.Validation.FULL) MaxLineLength:LegalNameValidatorTest.kt$LegalNameValidatorTest$assertEquals("Legal Name With Unicode Whitespaces", LegalNameValidator.normalize("Legal Name\u2004With\u0009Unicode\u0020Whitespaces")) - MaxLineLength:ListsSerializationTest.kt$ListsSerializationTest$Assertions.assertThatThrownBy { wrongPayloadType.serialize() } .isInstanceOf(NotSerializableException::class.java) MaxLineLength:ListsSerializationTest.kt$ListsSerializationTest.Companion$val envelope = DeserializationInput(SerializerFactoryBuilder.build(context.whitelist, context.deserializationClassLoader)).getEnvelope(serBytes, context) MaxLineLength:ListsSerializationTest.kt$internal inline - MaxLineLength:Literal.kt$ContractBuilder$@Suppress("UNUSED_PARAMETER") p3: kotlin.Pair<Parameter<T3>, Perceivable<T3>> - MaxLineLength:Literal.kt$ContractBuilder$fun <T> rollOut(startDate: LocalDate, endDate: LocalDate, frequency: Frequency, vars: T, init: RollOutBuilder<T>.() -> Unit): RollOut - MaxLineLength:Literal.kt$ContractBuilder$fun rollOut(startDate: LocalDate, endDate: LocalDate, frequency: Frequency, init: RollOutBuilder<Dummy>.() -> Unit): RollOut - MaxLineLength:Literal.kt$RollOutBuilder<T> : ContractBuilder - MaxLineLength:LoadTest.kt$LoadTest<T, S> - MaxLineLength:LoadTest.kt$RemoteNode(hostname, it.remoteSystemdServiceName, it.sshUser, it.rpcUser, it.rpcPort, it.remoteNodeDirectory) - MaxLineLength:LoadTest.kt$it.legalIdentitiesAndCerts.fold("") { acc, elem -> acc + "\n" + elem.name + ": " + elem.owningKey.toBase58String() } - MaxLineLength:LoadTest.kt$simpleNodes = hostNodeMap.values.filter { it.info.legalIdentitiesAndCerts.size == 1 } MaxLineLength:LoadTestConfiguration.kt$RemoteNode MaxLineLength:LocalDateSerializer.kt$LocalDateSerializer : Proxy - MaxLineLength:LocalDateSerializer.kt$LocalDateSerializer$override fun fromProxy(proxy: LocalDateProxy): LocalDate - MaxLineLength:LocalDateSerializer.kt$LocalDateSerializer$override fun toProxy(obj: LocalDate): LocalDateProxy MaxLineLength:LocalDateTimeSerializer.kt$LocalDateTimeSerializer : Proxy - MaxLineLength:LocalDateTimeSerializer.kt$LocalDateTimeSerializer$override fun toProxy(obj: LocalDateTime): LocalDateTimeProxy MaxLineLength:LocalDateTimeSerializer.kt$LocalDateTimeSerializer$override val additionalSerializers: Iterable<CustomSerializer<out Any>> = listOf(LocalDateSerializer(factory), LocalTimeSerializer(factory)) - MaxLineLength:LocalPropertyInformation.kt$LocalPropertyInformation$ConstructorPairedProperty : LocalPropertyInformation - MaxLineLength:LocalPropertyInformation.kt$LocalPropertyInformation$GetterSetterProperty : LocalPropertyInformation - MaxLineLength:LocalPropertyInformation.kt$LocalPropertyInformation$PrivateConstructorPairedProperty : LocalPropertyInformation - MaxLineLength:LocalPropertyInformation.kt$LocalPropertyInformation$ReadOnlyProperty : LocalPropertyInformation MaxLineLength:LocalPropertyInformation.kt$LocalPropertyInformation.CalculatedProperty$data MaxLineLength:LocalPropertyInformation.kt$LocalPropertyInformation.ConstructorPairedProperty$data MaxLineLength:LocalPropertyInformation.kt$LocalPropertyInformation.GetterSetterProperty$data MaxLineLength:LocalPropertyInformation.kt$LocalPropertyInformation.PrivateConstructorPairedProperty$data MaxLineLength:LocalPropertyInformation.kt$LocalPropertyInformation.ReadOnlyProperty$data - MaxLineLength:LocalSerializationRule.kt$LocalSerializationRule.AMQPSerializationScheme$( cordappCustomSerializers: Set<SerializationCustomSerializer<*, *>>, cordappSerializationWhitelists: Set<SerializationWhitelist>, serializerFactoriesForContexts: AccessOrderLinkedHashMap<SerializationFactoryCacheKey, SerializerFactory> ) - MaxLineLength:LocalSerializationRule.kt$LocalSerializationRule.AMQPSerializationScheme$override - MaxLineLength:LocalSerializerFactory.kt$DefaultLocalSerializerFactory : LocalSerializerFactory - MaxLineLength:LocalSerializerFactory.kt$DefaultLocalSerializerFactory$clazz.isSynthetic MaxLineLength:LocalSerializerFactory.kt$DefaultLocalSerializerFactory$is LocalTypeInformation.ACollection MaxLineLength:LocalSerializerFactory.kt$DefaultLocalSerializerFactory$is LocalTypeInformation.AMap MaxLineLength:LocalSerializerFactory.kt$DefaultLocalSerializerFactory$private MaxLineLength:LocalSerializerFactory.kt$DefaultLocalSerializerFactory$private val serializersByActualAndDeclaredType: MutableMap<ActualAndDeclaredType, AMQPSerializer<Any>> = DefaultCacheProvider.createCache() - MaxLineLength:LocalSerializerFactory.kt$DefaultLocalSerializerFactory$private val serializersByTypeId: MutableMap<TypeIdentifier, AMQPSerializer<Any>> = DefaultCacheProvider.createCache() - MaxLineLength:LocalSerializerFactory.kt$LocalSerializerFactory - MaxLineLength:LocalSerializerFactory.kt$LocalSerializerFactory$ fun getTypeInformation(typeName: String): LocalTypeInformation? - MaxLineLength:LocalSerializerFactory.kt$LocalSerializerFactory$/** * The [ClassWhitelist] used by this factory. Classes must be whitelisted for serialization, because they are expected * to be written in a secure manner. */ val whitelist: ClassWhitelist MaxLineLength:LocalTimeSerializer.kt$LocalTimeSerializer : Proxy MaxLineLength:LocalTimeSerializer.kt$LocalTimeSerializer$override fun fromProxy(proxy: LocalTimeProxy): LocalTime MaxLineLength:LocalTimeSerializer.kt$LocalTimeSerializer$override fun toProxy(obj: LocalTime): LocalTimeProxy - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation$ fun prettyPrint(simplifyClassNames: Boolean = true): String - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation$Abstract : LocalTypeInformation - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation$AnArray : LocalTypeInformation - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation$AnInterface : LocalTypeInformation MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation.ACollection$data - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation.AMap$fun withParameters(keyType: LocalTypeInformation, valueType: LocalTypeInformation): AMap - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation.AMap$val reparameterizedType = typeIdentifier.copy(parameters = listOf(keyType.typeIdentifier, valueType.typeIdentifier)) - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation.AMap$val unerasedType = typeIdentifier.toParameterized(listOf(keyType.typeIdentifier, valueType.typeIdentifier)) MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation.AnArray$data - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation.Atomic$data - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation.Companion$ fun forType(type: Type, typeIdentifier: TypeIdentifier, lookup: LocalTypeLookup): LocalTypeInformation - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation.Companion$throw IllegalStateException("Should not be attempting to build new type information when populating a cycle") MaxLineLength:LocalTypeInformation.kt$LocalTypeInformation.Singleton$data - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformationPrettyPrinter$private - MaxLineLength:LocalTypeInformation.kt$LocalTypeInformationPrettyPrinter$private data - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$ private fun buildNonAtomic(rawType: Class<*>, type: Type, typeIdentifier: TypeIdentifier, typeParameterInformation: List<LocalTypeInformation>): LocalTypeInformation - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$ private inline fun <T> suppressWarningsAnd(block: LocalTypeInformationBuilder.() -> T): T MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$!EnumSet::class.java.isAssignableFrom(type) MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$Map::class.java.isAssignableFrom(type) -> LocalTypeInformation.AMap(type, typeIdentifier, LocalTypeInformation.Unknown, LocalTypeInformation.Unknown) - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$constructorInformation: LocalConstructorInformation - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$is TypeIdentifier.Parameterised -> buildForParameterised(rawType, type as ParameterizedType, typeIdentifier, isOpaque) - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$it.name ?: throw IllegalStateException("Unnamed parameter in constructor $observedConstructor") - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$logger.info("No unique deserialisation constructor found for class $rawType, type is marked as non-composable") MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$logger.info("Properties of type ${type.typeName} do not satisfy its constructor, type has been marked as non-composable") - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$logger.info("Type ${type.typeName} has non-composable properties and has been marked as non-composable") - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$name to LocalPropertyInformation.ReadOnlyProperty(descriptor.getter, paramTypeInformation, isMandatory) MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$private - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$return LocalTypeInformation.Composable(type, typeIdentifier, constructorInformation, evolutionConstructors, properties, superclassInformation, interfaceInformation, typeParameterInformation) - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$return LocalTypeInformation.NonComposable(type, typeIdentifier, constructorInformation, properties, superclassInformation, interfaceInformation, typeParameterInformation) - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$suppressWarningsAnd { buildNonAtomic(rawType, type, typeIdentifier, buildTypeParameterInformation(type)) } - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$throw NotSerializableException("Type '${type.typeName} has synthetic fields and is likely a nested inner class.") - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$val constants = type.enumConstants.asSequence().mapIndexed { index, constant -> constant.toString() to index }.toMap() - MaxLineLength:LocalTypeInformationBuilder.kt$LocalTypeInformationBuilder$val constructorParameterIndices = constructorInformation.parameters.asSequence().mapIndexed { index, parameter -> parameter.name to index }.toMap() - MaxLineLength:LocalTypeModel.kt$ConfigurableLocalTypeModel : LocalTypeModel MaxLineLength:LocalTypeModel.kt$ConfigurableLocalTypeModel.BuilderLookup$override - MaxLineLength:LocalTypeModel.kt$LocalTypeLookup - MaxLineLength:LocalTypeModel.kt$LocalTypeLookup$ fun findOrBuild(type: Type, typeIdentifier: TypeIdentifier, builder: (Boolean) -> LocalTypeInformation): LocalTypeInformation - MaxLineLength:LocalTypeModel.kt$LocalTypeModel$ fun inspect(type: Type): LocalTypeInformation MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$ Concrete(a: Integer[], b: double, c: List<Integer[]>, d: int): Abstract<Integer>, Super<Integer[]>, SuperSuper<Integer[], Double> MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$ StringCollectionHolder(list: List<String>, map: Map<String, String>, array: List<String>[]): StringKeyedCollectionHolder<String>, CollectionHolder<String, String> MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$ StringKeyedCollectionHolder<Integer>(list: List<Integer>, map: Map<String, Integer>, array: List<Integer>[]): CollectionHolder<String, Integer> MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$ collectionHolder (optional): StringKeyedCollectionHolder<Integer>(list: List<Integer>, map: Map<String, Integer>, array: List<Integer>[]): CollectionHolder<String, Integer> - MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$AliasingOldStylePojoImpl : OldStylePojo MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$StringCollectionHolder : StringKeyedCollectionHolder MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$StringKeyedCollectionHolder<T> : CollectionHolder - MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$assertTrue(modelWithoutOpacity.inspect(typeOf<TransitivelyNonComposable>()) is LocalTypeInformation.NonComposable) - MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$private val customSerializerRegistry: CustomSerializerRegistry = CachingCustomSerializerRegistry(descriptorBasedSerializerRegistry) - MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$private val model = ConfigurableLocalTypeModel(WhitelistBasedTypeModelConfiguration(AllWhitelist, customSerializerRegistry)) - MaxLineLength:LocalTypeModelTests.kt$LocalTypeModelTests$val modelWithoutOpacity = ConfigurableLocalTypeModel(WhitelistBasedTypeModelConfiguration(AllWhitelist, serializerRegistry) ) MaxLineLength:LocalVolume.kt$LocalVolume$networkParamsFile.outputStream().use { networkParameters.signWithCert(Volume.keyPair.private, Volume.networkMapCert).serialize().writeTo(it) } - MaxLineLength:LoginView.kt$LoginView$nodeModel = login(hostTextField.text, portProperty.value, usernameTextField.text, passwordTextField.text) - MaxLineLength:LoginView.kt$LoginView$val button = Alert(Alert.AlertType.CONFIRMATION, "Are you sure you want to exit Corda Explorer?").apply { initOwner(root.scene.window) }.showAndWait().get() - MaxLineLength:MQSecurityAsNodeTest.kt$MQSecurityAsNodeTest$attacker.start(ActiveMQDefaultConfiguration.getDefaultClusterUser(), ActiveMQDefaultConfiguration.getDefaultClusterPassword()) MaxLineLength:MQSecurityAsNodeTest.kt$MQSecurityAsNodeTest$setPrivateKey(X509Utilities.CORDA_CLIENT_CA, clientKeyPair.private, listOf(clientCACert, DEV_INTERMEDIATE_CA.certificate, DEV_ROOT_CA.certificate), signingCertStore.entryPassword) MaxLineLength:MQSecurityAsNodeTest.kt$MQSecurityAsNodeTest$setPrivateKey(X509Utilities.CORDA_CLIENT_TLS, tlsKeyPair.private, listOf(clientTLSCert, clientCACert, DEV_INTERMEDIATE_CA.certificate, DEV_ROOT_CA.certificate), p2pSslConfig.keyStore.entryPassword) MaxLineLength:MQSecurityAsNodeTest.kt$MQSecurityAsNodeTest$val clientCACert = X509Utilities.createCertificate(CertificateType.INTERMEDIATE_CA, DEV_INTERMEDIATE_CA.certificate, DEV_INTERMEDIATE_CA.keyPair, legalName.x500Principal, clientKeyPair.public, nameConstraints = nameConstraints) MaxLineLength:MQSecurityAsNodeTest.kt$MQSecurityAsNodeTest$val clientTLSCert = X509Utilities.createCertificate(CertificateType.TLS, clientCACert, clientKeyPair, CordaX500Name("MiniCorp", "London", "GB").x500Principal, tlsKeyPair.public) MaxLineLength:MQSecurityAsNodeTest.kt$MQSecurityAsNodeTest$val nameConstraints = NameConstraints(arrayOf(GeneralSubtree(GeneralName(GeneralName.directoryName, legalName.toX500Name()))), arrayOf()) MaxLineLength:MQSecurityTest.kt$MQSecurityTest$fun clientTo(target: NetworkHostAndPort, sslConfiguration: MutualSslConfiguration? = configureTestSSL(CordaX500Name("MegaCorp", "London", "GB"))): SimpleMQClient - MaxLineLength:Main.kt$ fun main(args: Array<String>) MaxLineLength:Main.kt$Main$// TODO : This could block the UI thread when number of views increase, maybe we can make this async and display a loading screen. // Stock Views. registerView<Dashboard>() registerView<TransactionViewer>() // CordApps Views. registerView<CashViewer>() // Tools. registerView<Network>() registerView<Settings>() // Default view to Dashboard. selectedView.set(find<Dashboard>()) MaxLineLength:Main.kt$NetworkBootstrapperRunner : CordaCliWrapper MaxLineLength:Main.kt$NetworkBootstrapperRunner$@Option(names = ["--copy-cordapps"], description = ["Whether or not to copy the CorDapp JARs into the nodes' 'cordapps' directory. \${COMPLETION-CANDIDATES}"]) - MaxLineLength:Main.kt$NetworkBootstrapperRunner$@Option(names = ["--event-horizon"], description = ["The event horizon to use in the network-parameters. Default is 30 days."]) MaxLineLength:Main.kt$NetworkBootstrapperRunner$@Option(names = ["--max-message-size"], description = ["The maximum message size to use in the network-parameters, in bytes. Current default is $DEFAULT_MAX_MESSAGE_SIZE."]) MaxLineLength:Main.kt$NetworkBootstrapperRunner$@Option(names = ["--max-transaction-size"], description = ["The maximum transaction size to use in the network-parameters, in bytes. Current default is $DEFAULT_MAX_TRANSACTION_SIZE."]) MaxLineLength:Main.kt$NetworkBootstrapperRunner$@Option(names = ["--minimum-platform-version"], description = ["The minimum platform version to use in the network-parameters. Current default is $PLATFORM_VERSION."]) MaxLineLength:Main.kt$NetworkBootstrapperRunner$@Option(names = ["--network-parameter-overrides", "-n"], description = ["Overrides the default network parameters with those in the given file."]) MaxLineLength:Main.kt$NetworkBootstrapperRunner$@Option(names = ["--no-copy"], hidden = true, description = ["""DEPRECATED. Don't copy the CorDapp JARs into the nodes' "cordapps" directories."""]) - MaxLineLength:Main.kt$NetworkBootstrapperRunner$description MaxLineLength:Main.kt$NetworkBootstrapperRunner$if (networkParametersFile?.exists() != true) throw FileNotFoundException("Unable to find specified network parameters config file at $networkParametersFile") - MaxLineLength:Main.kt$NetworkBootstrapperRunner$overrides += minimumPlatformVersion?.let { mapOf("minimumPlatformVersion" to minimumPlatformVersion!!) } ?: mutableMapOf() - MaxLineLength:Main.kt$NetworkBootstrapperRunner$printError("Error${errors.pluralise()} found parsing the network parameter overrides file at $networkParametersFile:") - MaxLineLength:Main.kt$NetworkBootstrapperRunner$printWarning("The --no-copy parameter has been deprecated and been replaced with the --copy-cordapps parameter.") - MaxLineLength:Main.kt$NetworkBootstrapperRunner$require(eventHorizon == null || eventHorizon?.isNegative == false) { "The --event-horizon parameter must be a positive value" } - MaxLineLength:Main.kt$NetworkBootstrapperRunner$require(maxMessageSize == null || maxMessageSize ?: 0 > 0) { "The --max-message-size parameter must be at least 1" } - MaxLineLength:Main.kt$NetworkBootstrapperRunner$require(maxTransactionSize == null || maxTransactionSize ?: 0 > 0) { "The --max-transaction-size parameter must be at least 1" } MaxLineLength:Main.kt$NetworkBootstrapperRunner$require(minimumPlatformVersion == null || minimumPlatformVersion ?: 0 > 0) { "The --minimum-platform-version parameter must be at least 1" } - MaxLineLength:Main.kt$NetworkBootstrapperRunner$val networkParameterOverrides = getNetworkParametersOverrides().doOnErrors(::reportErrors).optional ?: return ExitCodes.FAILURE MaxLineLength:Main.kt$Node$if (transactions.size == 1) listOf(genesisTx) else transactions.values.reversed().take(10).filter { !isAccepted(it) && conflicts[it.data]!!.size == 1 }.shuffled(network.rng).take(3) MaxLineLength:Main.kt$Transaction$return "T(id=${id.toString().take(5)}, data=$data, parents=[${parents.map {it.toString().take(5) }}, chit=$chit, confidence=$confidence)" - MaxLineLength:Main.kt$nodeFilter = isNotary - MaxLineLength:Main.kt$require(acceptance.filter { it }.size < 2) { "More than one transaction of the conflict set of $v got accepted." } - MaxLineLength:Main.kt$val defaultConfig = ConfigFactory.parseResources("loadtest-reference.conf", ConfigParseOptions.defaults().setAllowMissing(false)) - MaxLineLength:MainView.kt$MainView$contentDisplayProperty().bind(smallIconProperty.map { if (it) ContentDisplay.TOP else ContentDisplay.LEFT }) - MaxLineLength:MainView.kt$MainView$if (selected == it) listOf(menuItemCSS, menuItemSelectedCSS).observable() else listOf(menuItemCSS).observable() - MaxLineLength:MainView.kt$MainView$textAlignmentProperty().bind(smallIconProperty.map { if (it) TextAlignment.CENTER else TextAlignment.LEFT }) - MaxLineLength:MapSerializer.kt$MapSerializer : AMQPSerializer MaxLineLength:MapSerializer.kt$MapSerializer$private val typeNotation: TypeNotation = RestrictedType(AMQPTypeIdentifiers.nameForType(declaredType), null, emptyList(), "map", Descriptor(typeDescriptor), emptyList()) - MaxLineLength:MapSerializer.kt$MapSerializer.Companion$fun resolveActual(actualClass: Class<*>, declaredTypeInformation: LocalTypeInformation.AMap): LocalTypeInformation.AMap - MaxLineLength:MapSerializer.kt$MapSerializer.Companion$private - MaxLineLength:MapValuesList.kt$MapValuesList.Companion$val backingList = FXCollections.observableArrayList<Map.Entry<K, A>>(sourceMap.entries.sortedBy { it.key!!.hashCode() }) - MaxLineLength:MappedList.kt$MappedList<A, B> : TransformationList - MaxLineLength:MappedSchemasCrossReferenceDetectionTests.kt$MappedSchemasCrossReferenceDetectionTests$BadSchema : MappedSchema - MaxLineLength:MappedSchemasCrossReferenceDetectionTests.kt$MappedSchemasCrossReferenceDetectionTests$GoodSchema : MappedSchema - MaxLineLength:MappedSchemasCrossReferenceDetectionTests.kt$MappedSchemasCrossReferenceDetectionTests$PoliteSchema : MappedSchema - MaxLineLength:MappedSchemasCrossReferenceDetectionTests.kt$MappedSchemasCrossReferenceDetectionTests$TrickySchema : MappedSchema - MaxLineLength:MappedSchemasCrossReferenceDetectionTests.kt$MappedSchemasCrossReferenceDetectionTests.TrickySchema.State$( @Column var id: String, //the field is a cross-reference to other MappedSchema however the field is not persistent (no JPA annotation) var other: GoodSchema.State ) - MaxLineLength:MapsSerializationTest.kt$MapsSerializationTest$"Map type class java.util.HashMap is unstable under iteration. Suggested fix: use java.util.LinkedHashMap instead." - MaxLineLength:MapsSerializationTest.kt$MapsSerializationTest$@Test fun `check EmptyMap serialization`() - MaxLineLength:MaxTransactionSizeTests.kt$MaxTransactionSizeTests$assertThatThrownBy { future.getOrThrow() }.hasMessageContaining("Transaction exceeded network's maximum transaction size limit") - MaxLineLength:MaxTransactionSizeTests.kt$MaxTransactionSizeTests${ // These 4 attachments yield a transaction that's got ~ 4mb, which will exceed the 3mb max transaction size limit val bigFile1 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 0, "a") val bigFile2 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 1, "b") val bigFile3 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 2, "c") val bigFile4 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 3, "c") val flow = aliceNode.transaction { 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) } val future = aliceNode.startFlow(flow) mockNet.runNetwork() assertThatThrownBy { future.getOrThrow() }.hasMessageContaining("Transaction exceeded network's maximum transaction size limit") } - MaxLineLength:MaxTransactionSizeTests.kt$MaxTransactionSizeTests${ // These 4 attachments yield a transaction that's got ~ 4mb, which will exceed the 3mb max transaction size limit val bigFile1 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 0, "a") val bigFile2 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 1, "b") val bigFile3 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 2, "c") val bigFile4 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 3, "d") val flow = aliceNode.transaction { 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) } val exception = assertFailsWith<IllegalArgumentException> { val future = aliceNode.startFlow(flow) mockNet.runNetwork() future.getOrThrow() } assertThat(exception).hasMessageContaining("Transaction exceeded network's maximum transaction size limit") } - MaxLineLength:Measure.kt$fun <A : Any, B : Any, C : Any, D : Any, R> measure(a: Iterable<A>, b: Iterable<B>, c: Iterable<C>, d: Iterable<D>, f: (A, B, C, D) -> R) MaxLineLength:Measure.kt$measure(listOf(a, b, c, d), f.reflect()!!) { f(uncheckedCast(it[0]), uncheckedCast(it[1]), uncheckedCast(it[2]), uncheckedCast(it[3])) } MaxLineLength:Measure.kt$private - MaxLineLength:MemberRule.kt$MemberRule$final override MaxLineLength:MerkleTransaction.kt$ComponentVisibilityException : CordaException - MaxLineLength:MerkleTransaction.kt$FilteredComponentGroup : ComponentGroup - MaxLineLength:MerkleTransaction.kt$FilteredTransaction : TraversableTransaction MaxLineLength:MerkleTransaction.kt$FilteredTransaction$ @Throws(ComponentVisibilityException::class) fun checkAllComponentsVisible(componentGroupEnum: ComponentGroupEnum) - MaxLineLength:MerkleTransaction.kt$FilteredTransaction$ @Throws(ComponentVisibilityException::class) fun checkCommandVisibility(publicKey: PublicKey) - MaxLineLength:MerkleTransaction.kt$FilteredTransaction$ fun checkWithFun(checkingFun: (Any) -> Boolean): Boolean MaxLineLength:MerkleTransaction.kt$FilteredTransaction$"Did not receive components for group ${componentGroupEnum.ordinal} and cannot verify they didn't exist in the original wire transaction" - MaxLineLength:MerkleTransaction.kt$FilteredTransaction$"Partial Merkle tree root and advertised full Merkle tree root for component group $groupIndex do not match" MaxLineLength:MerkleTransaction.kt$FilteredTransaction$val groupFullRoot = MerkleTree.getMerkleTree(group.components.mapIndexed { index, component -> componentHash(group.nonces[index], component) }).hash MaxLineLength:MerkleTransaction.kt$FilteredTransaction$verificationCheck - MaxLineLength:MerkleTransaction.kt$FilteredTransaction$verificationCheck(groupIndex < groupHashes.size) { "There is no matching component group hash for group $groupIndex" } MaxLineLength:MerkleTransaction.kt$FilteredTransaction$visibilityCheck MaxLineLength:MerkleTransaction.kt$FilteredTransaction$visibilityCheck(group.groupIndex < groupHashes.size) { "There is no matching component group hash for group ${group.groupIndex}" } - MaxLineLength:MerkleTransaction.kt$FilteredTransaction$visibilityCheck(groupPartialRoot == groupFullRoot) { "Some components for group ${group.groupIndex} are not visible" } MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$filteredComponentGroups.add(FilteredComponentGroup(groupIndex, value, filteredComponentNonces[groupIndex]!!, createPartialMerkleTree(groupIndex))) MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$filteredComponentHashes[componentGroupIndex] = mutableListOf(wtx.availableComponentHashes[componentGroupIndex]!![internalIndex]) - MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$filteredComponentHashes[componentGroupIndex]!!.add(wtx.availableComponentHashes[componentGroupIndex]!![internalIndex]) - MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$filteredComponentHashes[signersGroupIndex] = wtx.availableComponentHashes[signersGroupIndex]!!.toMutableList() MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$filteredComponentNonces[componentGroupIndex] = mutableListOf(wtx.availableComponentNonces[componentGroupIndex]!![internalIndex]) - MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$filteredComponentNonces[componentGroupIndex]!!.add(wtx.availableComponentNonces[componentGroupIndex]!![internalIndex]) - MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$filteredComponentNonces[signersGroupIndex] = wtx.availableComponentNonces[signersGroupIndex]!!.toMutableList() MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$val filteredComponentHashes: MutableMap<Int, MutableList<SecureHash>> = hashMapOf() // Required for partial Merkle tree generation. - MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$val serialisedComponent = wtx.componentGroups.first { it.groupIndex == componentGroupIndex }.components[internalIndex] - MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$wtx.attachments.forEachIndexed { internalIndex, it -> filter(it, ATTACHMENTS_GROUP.ordinal, internalIndex) } MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$wtx.componentGroups .filter { it.groupIndex >= values().size } .forEach { componentGroup -> componentGroup.components.forEachIndexed { internalIndex, component -> filter(component, componentGroup.groupIndex, internalIndex) } } MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion$wtx.references.forEachIndexed { internalIndex, it -> filter(ReferenceStateRef(it), REFERENCES_GROUP.ordinal, internalIndex) } - MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion${ group.add(serialisedComponent) // If the group[componentGroupIndex] existed, then we guarantee that // filteredComponentNonces[componentGroupIndex] and filteredComponentHashes[componentGroupIndex] are not null. filteredComponentNonces[componentGroupIndex]!!.add(wtx.availableComponentNonces[componentGroupIndex]!![internalIndex]) filteredComponentHashes[componentGroupIndex]!!.add(wtx.availableComponentHashes[componentGroupIndex]!![internalIndex]) } - MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion${ if (!filtering.test(t)) return val group = filteredSerialisedComponents[componentGroupIndex] // Because the filter passed, we know there is a match. We also use first Vs single as the init function // of WireTransaction ensures there are no duplicated groups. val serialisedComponent = wtx.componentGroups.first { it.groupIndex == componentGroupIndex }.components[internalIndex] if (group == null) { // As all of the helper Map structures, like availableComponentNonces, availableComponentHashes // and groupsMerkleRoots, are computed lazily via componentGroups.forEach, there should always be // a match on Map.get ensuring it will never return null. filteredSerialisedComponents[componentGroupIndex] = mutableListOf(serialisedComponent) filteredComponentNonces[componentGroupIndex] = mutableListOf(wtx.availableComponentNonces[componentGroupIndex]!![internalIndex]) filteredComponentHashes[componentGroupIndex] = mutableListOf(wtx.availableComponentHashes[componentGroupIndex]!![internalIndex]) } else { group.add(serialisedComponent) // If the group[componentGroupIndex] existed, then we guarantee that // filteredComponentNonces[componentGroupIndex] and filteredComponentHashes[componentGroupIndex] are not null. filteredComponentNonces[componentGroupIndex]!!.add(wtx.availableComponentNonces[componentGroupIndex]!![internalIndex]) filteredComponentHashes[componentGroupIndex]!!.add(wtx.availableComponentHashes[componentGroupIndex]!![internalIndex]) } // If at least one command is visible, then all command-signers should be visible as well. // This is required for visibility purposes, see FilteredTransaction.checkAllCommandsVisible() for more details. if (componentGroupIndex == COMMANDS_GROUP.ordinal && !signersIncluded) { signersIncluded = true val signersGroupIndex = SIGNERS_GROUP.ordinal // There exist commands, thus the signers group is not empty. val signersGroupComponents = wtx.componentGroups.first { it.groupIndex == signersGroupIndex } filteredSerialisedComponents[signersGroupIndex] = signersGroupComponents.components.toMutableList() filteredComponentNonces[signersGroupIndex] = wtx.availableComponentNonces[signersGroupIndex]!!.toMutableList() filteredComponentHashes[signersGroupIndex] = wtx.availableComponentHashes[signersGroupIndex]!!.toMutableList() } } MaxLineLength:MerkleTransaction.kt$FilteredTransaction.Companion${ wtx.inputs.forEachIndexed { internalIndex, it -> filter(it, INPUTS_GROUP.ordinal, internalIndex) } wtx.outputs.forEachIndexed { internalIndex, it -> filter(it, OUTPUTS_GROUP.ordinal, internalIndex) } wtx.commands.forEachIndexed { internalIndex, it -> filter(it, COMMANDS_GROUP.ordinal, internalIndex) } wtx.attachments.forEachIndexed { internalIndex, it -> filter(it, ATTACHMENTS_GROUP.ordinal, internalIndex) } if (wtx.notary != null) filter(wtx.notary, NOTARY_GROUP.ordinal, 0) if (wtx.timeWindow != null) filter(wtx.timeWindow, TIMEWINDOW_GROUP.ordinal, 0) // Note that because [inputs] and [references] share the same type [StateRef], we use a wrapper for references [ReferenceStateRef], // when filtering. Thus, to filter-in all [references] based on type, one should use the wrapper type [ReferenceStateRef] and not [StateRef]. // Similar situation is for network parameters hash and attachments, one should use wrapper [NetworkParametersHash] and not [SecureHash]. wtx.references.forEachIndexed { internalIndex, it -> filter(ReferenceStateRef(it), REFERENCES_GROUP.ordinal, internalIndex) } wtx.networkParametersHash?.let { filter(NetworkParametersHash(it), PARAMETERS_GROUP.ordinal, 0) } // It is highlighted that because there is no a signers property in TraversableTransaction, // one cannot specifically filter them in or out. // The above is very important to ensure someone won't filter out the signers component group if at least one // command is included in a FilteredTransaction. // It's sometimes possible that when we receive a WireTransaction for which there is a new or more unknown component groups, // we decide to filter and attach this field to a FilteredTransaction. // An example would be to redact certain contract state types, but otherwise leave a transaction alone, // including the unknown new components. wtx.componentGroups .filter { it.groupIndex >= values().size } .forEach { componentGroup -> componentGroup.components.forEachIndexed { internalIndex, component -> filter(component, componentGroup.groupIndex, internalIndex) } } } MaxLineLength:MerkleTransaction.kt$FilteredTransactionVerificationException : CordaException - MaxLineLength:MerkleTransaction.kt$TraversableTransaction$override MaxLineLength:MerkleTransaction.kt$TraversableTransaction$override val outputs: List<TransactionState<ContractState>> = deserialiseComponentGroup(componentGroups, TransactionState::class, OUTPUTS_GROUP) - MaxLineLength:MerkleTransaction.kt$TraversableTransaction$val timeWindows: List<TimeWindow> = deserialiseComponentGroup(componentGroups, TimeWindow::class, TIMEWINDOW_GROUP) - MaxLineLength:MerkleTree.kt$MerkleTree$Node : MerkleTree MaxLineLength:MessageChainState.kt$MessageChainState$@BelongsToContract(MessageChainContract::class) data - MaxLineLength:MessageSizeChecksInterceptor.kt$AmqpMessageSizeChecksInterceptor : MessageSizeChecksInterceptorAmqpInterceptor - MaxLineLength:MessageSizeChecksInterceptor.kt$ArtemisMessageSizeChecksInterceptor : MessageSizeChecksInterceptorInterceptor - MaxLineLength:MessageSizeChecksInterceptor.kt$ArtemisMessageSizeChecksInterceptor$is MessagePacket -> (packet.message.persistentSize - packet.message.headersAndPropertiesEncodeSize - 4).toInt() MaxLineLength:MessageSizeChecksInterceptor.kt$MessageSizeChecksInterceptor$logger MaxLineLength:MessageState.kt$MessageState$@BelongsToContract(MessageContract::class) data - MaxLineLength:Messaging.kt$DeduplicationHandler - MaxLineLength:Messaging.kt$MessagingService$ fun addMessageHandler(topic: String, callback: MessageHandler): MessageHandlerRegistration MaxLineLength:Messaging.kt$MessagingService$ fun createMessage(topic: String, data: ByteArray, deduplicationId: SenderDeduplicationId = SenderDeduplicationId(DeduplicationId.createRandom(newSecureRandom()), ourSenderUUID), additionalHeaders: Map<String, String> = emptyMap()): Message - MaxLineLength:Messaging.kt$MessagingService$/** * A unique identifier for this sender that changes whenever a node restarts. This is used in conjunction with a sequence * number for message de-duplication at the recipient. */ val ourSenderUUID: String - MaxLineLength:Messaging.kt$ReceivedMessage : Message MaxLineLength:Messaging.kt$fun MessagingService.send(topicSession: String, payload: Any, to: MessageRecipients, deduplicationId: SenderDeduplicationId = SenderDeduplicationId(DeduplicationId.createRandom(newSecureRandom()), ourSenderUUID), additionalHeaders: Map<String, String> = emptyMap()) MaxLineLength:MessagingExecutor.kt$MessagingExecutor$putLongProperty(org.apache.activemq.artemis.api.core.Message.HDR_SCHEDULED_DELIVERY_TIME, System.currentTimeMillis() + amqDelayMillis) - MaxLineLength:MessagingExecutor.kt$MessagingExecutor$putStringProperty(P2PMessagingHeaders.cordaVendorProperty, cordaVendor) putStringProperty(P2PMessagingHeaders.releaseVersionProperty, releaseVersion) putIntProperty(P2PMessagingHeaders.platformVersionProperty, versionInfo.platformVersion) putStringProperty(P2PMessagingHeaders.topicProperty, SimpleString(message.topic)) writeBodyBufferBytes(message.data.bytes) // Use the magic deduplication property built into Artemis as our message identity too putStringProperty(org.apache.activemq.artemis.api.core.Message.HDR_DUPLICATE_DETECTION_ID, SimpleString(message.uniqueMessageId.toString)) // If we are the sender (ie. we are not going through recovery of some sort), use sequence number short cut. if (ourSenderUUID == message.senderUUID) { putStringProperty(P2PMessagingHeaders.senderUUID, SimpleString(ourSenderUUID)) putLongProperty(P2PMessagingHeaders.senderSeqNo, ourSenderSeqNo.getAndIncrement()) } // For demo purposes - if set then add a delay to messages in order to demonstrate that the flows are doing as intended if (amqDelayMillis > 0 && message.topic == FlowMessagingImpl.sessionTopic) { putLongProperty(org.apache.activemq.artemis.api.core.Message.HDR_SCHEDULED_DELIVERY_TIME, System.currentTimeMillis() + amqDelayMillis) } message.additionalHeaders.forEach { key, value -> putStringProperty(key, value) } MaxLineLength:MessagingExecutor.kt$MessagingExecutor$putStringProperty(org.apache.activemq.artemis.api.core.Message.HDR_DUPLICATE_DETECTION_ID, SimpleString(message.uniqueMessageId.toString)) MaxLineLength:MetricInterceptor.kt$MetricInterceptor$@Suspendable override - MaxLineLength:MigrationNamedCacheFactory.kt$MigrationNamedCacheFactory : BindableNamedCacheFactorySingletonSerializeAsToken - MaxLineLength:MigrationNamedCacheFactory.kt$MigrationNamedCacheFactory$override - MaxLineLength:MigrationNamedCacheFactory.kt$MigrationNamedCacheFactory$override fun bindWithConfig(nodeConfiguration: NodeConfiguration) - MaxLineLength:MigrationNamedCacheFactory.kt$MigrationNamedCacheFactory$override fun bindWithMetrics(metricRegistry: MetricRegistry) MaxLineLength:MigrationNamedCacheFactory.kt$MigrationNamedCacheFactory$private val nodeConfiguration: NodeConfiguration? MaxLineLength:MigrationServicesForResolution.kt$MigrationServicesForResolution$deserialiseComponentGroup(tx.componentGroups, TransactionState::class, ComponentGroupEnum.OUTPUTS_GROUP, forceDeserialize = true) - MaxLineLength:MigrationServicesForResolution.kt$MigrationServicesForResolution$else -> throw MigrationException("Unknown transaction type ${baseTx::class.qualifiedName} found when loading a state") - MaxLineLength:MigrationServicesForResolution.kt$MigrationServicesForResolution$is ContractUpgradeLedgerTransaction -> it.value.map { stateRef -> StateAndRef(baseTx.outputs[stateRef.index], stateRef) } - MaxLineLength:MigrationServicesForResolution.kt$MigrationServicesForResolution$is NotaryChangeLedgerTransaction -> it.value.map { stateRef -> StateAndRef(baseTx.outputs[stateRef.index], stateRef) } - MaxLineLength:MigrationServicesForResolution.kt$MigrationServicesForResolution$logger.info("Couldn't find network parameters file: ${e.message}. This is expected if the node is starting for the first time.") - MaxLineLength:MigrationServicesForResolution.kt$MigrationServicesForResolution$override - MaxLineLength:MigrationServicesForResolution.kt$MigrationServicesForResolution$private MaxLineLength:MigrationServicesForResolution.kt$MigrationServicesForResolution$val states = AttachmentsClassLoaderBuilder.withAttachmentsClassloaderContext(attachments, networkParameters, tx.id, cordappLoader.appClassLoader) { deserialiseComponentGroup(tx.componentGroups, TransactionState::class, ComponentGroupEnum.OUTPUTS_GROUP, forceDeserialize = true) } - MaxLineLength:MigrationServicesForResolution.kt$MigrationServicesForResolution${ // If there is no attachment that allows the state class to be deserialised correctly, then carpent a state class anyway. It // might still be possible to access the participants depending on how the state class was serialised. logger.debug("Could not use attachments to deserialise transaction output states for transaction ${tx.id}") tx.outputs.filterIndexed { index, _ -> stateIndices.contains(index)} } - MaxLineLength:MigrationServicesForResolution.kt$MigrationServicesForResolution.<no name provided>${ // Note that the parameters in any file shouldn't be put into the database - this will be done by the node on startup. return if (hash == filedParams?.raw?.hash) { filedParams.raw.deserialize() } else { cordaDB.transaction { storage[hash]?.verified() } } } - MaxLineLength:MissingAttachmentsException.kt$MissingAttachmentsException : CordaException MaxLineLength:MissingContractAttachments.kt$MissingContractAttachments$"${contractsClassName ?: states.map { it.contract }.distinct()}${minimumRequiredContractClassVersion?.let { ", minimum required contract class version $minimumRequiredContractClassVersion"}}. " MaxLineLength:MissingContractAttachments.kt$MissingContractAttachments$@JvmOverloads constructor(val states: List<TransactionState<ContractState>>, contractsClassName: String? = null, minimumRequiredContractClassVersion: Version? = null) - MaxLineLength:MockAttachmentStorage.kt$MockAttachmentStorage$(criteria.contractClassNamesCondition as ColumnPredicate.EqualityComparison<List<ContractClassName>>).rightLiteral MaxLineLength:MockAttachmentStorage.kt$MockAttachmentStorage$@JvmOverloads fun importContractAttachment(contractClassNames: List<ContractClassName>, uploader: String, jar: InputStream, attachmentId: AttachmentId? = null, signers: List<PublicKey> = emptyList()): AttachmentId MaxLineLength:MockAttachmentStorage.kt$MockAttachmentStorage$ContractAttachment.create(baseAttachment, contractClassNames.first(), contractClassNames.toSet(), uploader, signers, version) MaxLineLength:MockAttachmentStorage.kt$MockAttachmentStorage$MockAttachment : AbstractAttachment @@ -6721,550 +3922,225 @@ MaxLineLength:MockAttachmentStorage.kt$MockAttachmentStorage$private MaxLineLength:MockAttachmentStorage.kt$MockAttachmentStorage$val attachmentQueryCriteria = AttachmentQueryCriteria.AttachmentsQueryCriteria(contractClassNamesCondition = Builder.equal(listOf(contractClassName)), versionCondition = Builder.greaterThanOrEqual(minContractVersion), uploaderCondition = Builder.`in`(TRUSTED_UPLOADERS)) MaxLineLength:MockAttachmentStorage.kt$MockAttachmentStorage$val attachmentSort = AttachmentSort(listOf(AttachmentSort.AttachmentSortColumn(AttachmentSort.AttachmentSortAttribute.VERSION, Sort.Direction.DESC))) - MaxLineLength:MockAttachmentStorage.kt$MockAttachmentStorage$val contractClassMetadata = ContractAttachmentMetadata(contractClassName, version, signers.isNotEmpty()) MaxLineLength:MockAttachmentStorage.kt$MockAttachmentStorage$val version = try { Integer.parseInt(baseAttachment.openAsJAR().manifest?.mainAttributes?.getValue(Attributes.Name.IMPLEMENTATION_VERSION)) } catch (e: Exception) { DEFAULT_CORDAPP_VERSION } - MaxLineLength:MockAttachmentStorage.kt$MockAttachmentStorage$versionCondition = Builder.greaterThanOrEqual(minContractVersion) MaxLineLength:MockContractAttachment.kt$// A valid zip file with 1 entry. val simpleZip = byteArrayOf(80, 75, 3, 4, 20, 0, 8, 8, 8, 0, 15, 113, 79, 78, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 4, 0, 47, 97, -2, -54, 0, 0, 75, 4, 0, 80, 75, 7, 8, 67, -66, -73, -24, 3, 0, 0, 0, 1, 0, 0, 0, 80, 75, 1, 2, 20, 0, 20, 0, 8, 8, 8, 0, 15, 113, 79, 78, 67, -66, -73, -24, 3, 0, 0, 0, 1, 0, 0, 0, 2, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 47, 97, -2, -54, 0, 0, 80, 75, 5, 6, 0, 0, 0, 0, 1, 0, 1, 0, 52, 0, 0, 0, 55, 0, 0, 0, 0, 0) - MaxLineLength:MockCordappProvider.kt$MockCordappProvider$attachments.importContractAttachment(contractClassNames, DEPLOYED_CORDAPP_UPLOADER, data.inputStream(), contractHash, signers) - MaxLineLength:MockCordappProvider.kt$MockCordappProvider$fakeAttachment(contractClass.replace('.', '/') + ".class", "fake class file for $contractClass", manifestAttributes) - MaxLineLength:MockCordappProvider.kt$MockCordappProvider$if (cordappRegistry.none { it.first.contractClassNames.contains(contractClassName) && it.second == contractHash }) { cordappRegistry.add(Pair( cordapp, findOrImportAttachment( listOf(contractClassName), fakeAttachmentCached(contractClassName, jarManifestAttributesWithObligatoryElement), attachments, contractHash, signers ) )) } - MaxLineLength:MockCordappProvider.kt$MockCordappProvider$private - MaxLineLength:MockKeyManagementService.kt$MockKeyManagementService$override - MaxLineLength:MockKeyManagementService.kt$MockKeyManagementService$override fun filterMyKeys(candidateKeys: Iterable<PublicKey>): Iterable<PublicKey> - MaxLineLength:MockKeyManagementService.kt$MockKeyManagementService$private fun getSigner(publicKey: PublicKey): ContentSigner - MaxLineLength:MockKeyManagementService.kt$MockKeyManagementService$private val keyStore: MutableMap<PublicKey, PrivateKey> = initialKeys.associateByTo(HashMap(), { it.public }, { it.private }) - MaxLineLength:MockNetwork.kt$MockNetwork MaxLineLength:MockNetwork.kt$MockNetwork$ fun createPartyNode(legalName: CordaX500Name? = null): StartedMockNode - MaxLineLength:MockNetwork.kt$MockNetwork$/** In a mock network, nodes have an incrementing integer ID. Real networks do not have this. Returns the next ID that will be used. */ val nextNodeId get(): Int = internalMockNetwork.nextNodeId - MaxLineLength:MockNetwork.kt$MockNetwork$@Deprecated("cordappPackages does not preserve the original CorDapp's versioning and metadata, which may lead to " + "misleading results in tests. Use MockNetworkParameters.cordappsForAllNodes instead.") MaxLineLength:MockNetwork.kt$MockNetwork$val servicePeerAllocationStrategy: InMemoryMessagingNetwork.ServicePeerAllocationStrategy = defaultParameters.servicePeerAllocationStrategy - MaxLineLength:MockNetwork.kt$MockNetworkParameters - MaxLineLength:MockNetwork.kt$MockNetworkParameters$(networkSendManuallyPumped: Boolean, threadPerNode: Boolean, servicePeerAllocationStrategy: InMemoryMessagingNetwork.ServicePeerAllocationStrategy, notarySpecs: List<MockNetworkNotarySpec>, networkParameters: NetworkParameters ) - MaxLineLength:MockNetwork.kt$MockNetworkParameters$constructor(cordappsForAllNodes: Collection<TestCordapp>) : this(threadPerNode = false, cordappsForAllNodes = cordappsForAllNodes) MaxLineLength:MockNetwork.kt$MockNetworkParameters$fun withCordappsForAllNodes(cordappsForAllNodes: Collection<TestCordapp>): MockNetworkParameters - MaxLineLength:MockNetwork.kt$MockNetworkParameters$fun withNetworkParameters(networkParameters: NetworkParameters): MockNetworkParameters MaxLineLength:MockNetwork.kt$MockNetworkParameters$fun withNetworkSendManuallyPumped(networkSendManuallyPumped: Boolean): MockNetworkParameters - MaxLineLength:MockNetwork.kt$MockNetworkParameters$fun withNotarySpecs(notarySpecs: List<MockNetworkNotarySpec>): MockNetworkParameters MaxLineLength:MockNetwork.kt$MockNetworkParameters$fun withServicePeerAllocationStrategy(servicePeerAllocationStrategy: InMemoryMessagingNetwork.ServicePeerAllocationStrategy): MockNetworkParameters MaxLineLength:MockNetwork.kt$MockNetworkParameters$return MockNetworkParameters(networkSendManuallyPumped, threadPerNode, servicePeerAllocationStrategy, notarySpecs, networkParameters, emptyList()) MaxLineLength:MockNetwork.kt$MockNetworkParameters$val servicePeerAllocationStrategy: InMemoryMessagingNetwork.ServicePeerAllocationStrategy = InMemoryMessagingNetwork.ServicePeerAllocationStrategy.Random() MaxLineLength:MockNetwork.kt$MockNodeParameters MaxLineLength:MockNetwork.kt$MockNodeParameters$fun copy(forcedID: Int?, legalName: CordaX500Name?, entropyRoot: BigInteger, configOverrides: MockNodeConfigOverrides): MockNodeParameters MaxLineLength:MockNetwork.kt$MockNodeParameters$fun withAdditionalCordapps(additionalCordapps: Collection<TestCordapp>): MockNodeParameters - MaxLineLength:MockNetwork.kt$MockNodeParameters$fun withConfigOverrides(configOverrides: MockNodeConfigOverrides): MockNodeParameters - MaxLineLength:MockNetwork.kt$StartedMockNode$ fun <F : FlowLogic<*>> findStateMachines(flowClass: Class<F>): List<Pair<F, CordaFuture<*>>> MaxLineLength:MockNetwork.kt$StartedMockNode$ fun <F : FlowLogic<*>> registerInitiatedFlow(initiatedFlowClass: Class<F>): Observable<F> MaxLineLength:MockNetwork.kt$StartedMockNode$ fun <F : FlowLogic<*>> registerInitiatedFlow(initiatingFlowClass: Class<out FlowLogic<*>>, initiatedFlowClass: Class<F>): Observable<F> MaxLineLength:MockNetwork.kt$StartedMockNode$ fun <T> startFlow(logic: FlowLogic<T>): CordaFuture<T> - MaxLineLength:MockNetwork.kt$UnstartedMockNode$ fun <T : SerializeAsToken> installCordaService(serviceClass: Class<T>): T MaxLineLength:MockNetworkIntegrationTests.kt$MockNetworkIntegrationTests$assertEquals(0, startJavaProcess<MockNetworkIntegrationTests>(emptyList(), extraJvmArguments = listOf("-javaagent:$quasar")).waitFor()) MaxLineLength:MockNetworkParametersService.kt$MockNetworkParametersStorage : NetworkParametersStorage - MaxLineLength:MockNetworkParametersService.kt$MockNetworkParametersStorage$override - MaxLineLength:MockNodeMessagingService.kt$MockNodeMessagingService$ fun start(network: InMemoryMessagingNetwork, manuallyPumped: Boolean, id: Int, notaryService: PartyAndCertificate?) - MaxLineLength:MockNodeMessagingService.kt$MockNodeMessagingService$ private fun unPopMessages(transfers: Collection<InMemoryMessagingNetwork.MessageTransfer>) - MaxLineLength:MockNodeMessagingService.kt$MockNodeMessagingService$OpaqueBytes(message.data.bytes.copyOf()) - MaxLineLength:MockNodeMessagingService.kt$MockNodeMessagingService$handler.callback(receivedMessage, handler, InMemoryDeduplicationHandler(receivedMessage, transfer)) MaxLineLength:MockNodeMessagingService.kt$MockNodeMessagingService$override MaxLineLength:MockNodeMessagingService.kt$MockNodeMessagingService$private - MaxLineLength:MockNodeMessagingService.kt$MockNodeMessagingService$return InMemoryMessage(topic, OpaqueBytes(data), deduplicationId.deduplicationId, senderUUID = deduplicationId.senderUUID) - MaxLineLength:MockNodeMessagingService.kt$MockNodeMessagingService$val matchingHandlers = handlers.filter { it.topicSession.isBlank() || transfer.message.topic == it.topicSession } - MaxLineLength:MockNodeMessagingService.kt$MockNodeMessagingService${ // Got no handlers for this message yet. Keep the message around and attempt redelivery after a new // handler has been registered. The purpose of this path is to make unit tests that have multi-threading // reliable, as a sender may attempt to send a message to a receiver that hasn't finished setting // up a handler for yet. Most unit tests don't run threaded, but we want to test true parallelism at // least sometimes. log.warn("Message to ${transfer.message.topic} could not be delivered") pendingRedelivery.add(transfer) null } MaxLineLength:MockNodeMessagingService.kt$MockNodeMessagingService.InMemoryDeduplicationHandler$private inner - MaxLineLength:MockServices.kt$ fun <T : SerializeAsToken> createMockCordaService(serviceHub: MockServices, serviceConstructor: (AppServiceHub) -> T): T MaxLineLength:MockServices.kt$MockAppServiceHubImpl<out T : SerializeAsToken> : AppServiceHubServiceHub - MaxLineLength:MockServices.kt$MockServices$ fun addMockCordapp(contractClassName: ContractClassName) - MaxLineLength:MockServices.kt$MockServices$ override fun loadContractAttachment(stateRef: StateRef) MaxLineLength:MockServices.kt$MockServices$/** * Create a mock [ServiceHub] that can't load CorDapp code, and which uses a default service identity. */ constructor(cordappPackages: Iterable<String>) : this(cordappPackages, CordaX500Name("TestIdentity", "", "GB"), makeTestIdentityService()) MaxLineLength:MockServices.kt$MockServices$/** * Create a mock [ServiceHub] that can't load CorDapp code, which uses the provided identity service * (you can get one from [makeTestIdentityService]) and which represents the given identity. */ @JvmOverloads constructor(cordappPackages: Iterable<String>, initialIdentityName: CordaX500Name, identityService: IdentityService = makeTestIdentityService()) : this(cordappPackages, TestIdentity(initialIdentityName), identityService) MaxLineLength:MockServices.kt$MockServices$/** * Create a mock [ServiceHub] that looks for app code in the given package names, uses the provided identity service * (you can get one from [makeTestIdentityService]) and represents the given identity. */ @JvmOverloads constructor(cordappPackages: Iterable<String>, initialIdentityName: CordaX500Name, identityService: IdentityService = makeTestIdentityService(), key: KeyPair, vararg moreKeys: KeyPair) : this(cordappPackages, TestIdentity(initialIdentityName, key), identityService, *moreKeys) MaxLineLength:MockServices.kt$MockServices$/** * Create a mock [ServiceHub] which uses the package of the caller to find CorDapp code. It uses a default service * identity. */ constructor() : this(listOf(getCallerPackage(MockServices::class)!!), CordaX500Name("TestIdentity", "", "GB"), makeTestIdentityService()) MaxLineLength:MockServices.kt$MockServices$/** * Create a mock [ServiceHub] which uses the package of the caller to find CorDapp code. It uses the provided identity service * (you can get one from [makeTestIdentityService]) and which represents the given identity. */ @JvmOverloads constructor(initialIdentityName: CordaX500Name, identityService: IdentityService = makeTestIdentityService(), key: KeyPair, vararg moreKeys: KeyPair) : this(listOf(getCallerPackage(MockServices::class)!!), TestIdentity(initialIdentityName, key), identityService, *moreKeys) - MaxLineLength:MockServices.kt$MockServices$/** * Create a mock [ServiceHub] which uses the package of the caller to find CorDapp code. It uses the provided identity service * (you can get one from [makeTestIdentityService]) and which represents the given identity. It has no keys. */ @JvmOverloads constructor(initialIdentityName: CordaX500Name, identityService: IdentityService = makeTestIdentityService()) : this(listOf(getCallerPackage(MockServices::class)!!), TestIdentity(initialIdentityName), identityService) MaxLineLength:MockServices.kt$MockServices$constructor(cordappPackages: List<String>, firstIdentity: TestIdentity, networkParameters: NetworkParameters, vararg moreIdentities: TestIdentity) : this( cordappPackages, firstIdentity, makeTestIdentityService(*listOf(firstIdentity, *moreIdentities).map { it.identity }.toTypedArray()), networkParameters, firstIdentity.keyPair ) MaxLineLength:MockServices.kt$MockServices$constructor(cordappPackages: List<String>, initialIdentityName: CordaX500Name, identityService: IdentityService, networkParameters: NetworkParameters) : this(cordappPackages, TestIdentity(initialIdentityName), identityService, networkParameters) MaxLineLength:MockServices.kt$MockServices$constructor(cordappPackages: List<String>, initialIdentityName: CordaX500Name, identityService: IdentityService, networkParameters: NetworkParameters, key: KeyPair) : this(cordappPackages, TestIdentity(initialIdentityName, key), identityService, networkParameters) - MaxLineLength:MockServices.kt$MockServices$constructor(firstIdentity: TestIdentity, networkParameters: NetworkParameters, vararg moreIdentities: TestIdentity) : this( listOf(getCallerPackage(MockServices::class)!!), firstIdentity, networkParameters, *moreIdentities ) - MaxLineLength:MockServices.kt$MockServices$get() = ServicesForResolutionImpl(identityService, attachments, cordappProvider, networkParametersService, validatedTransactions) - MaxLineLength:MockServices.kt$MockServices$initialIdentity: TestIdentity MaxLineLength:MockServices.kt$MockServices$internal MaxLineLength:MockServices.kt$MockServices$override val keyManagementService: KeyManagementService = MockKeyManagementService(identityService, *arrayOf(initialIdentity.keyPair) + moreKeys) - MaxLineLength:MockServices.kt$MockServices$override var networkParametersService: NetworkParametersService = MockNetworkParametersStorage(initialNetworkParameters) - MaxLineLength:MockServices.kt$MockServices$private MaxLineLength:MockServices.kt$MockServices$private constructor(cordappLoader: CordappLoader, identityService: IdentityService, networkParameters: NetworkParameters, initialIdentity: TestIdentity, moreKeys: Array<out KeyPair>, keyManagementService: KeyManagementService) : this(cordappLoader, MockTransactionStorage(), identityService, networkParameters, initialIdentity, moreKeys, keyManagementService) - MaxLineLength:MockServices.kt$MockServices$return NodeInfo(listOf(NetworkHostAndPort("mock.node.services", 10000)), listOf(initialIdentity.identity), 1, serial = 1L) MaxLineLength:MockServices.kt$MockServices$return NodeVaultService(clock, keyManagementService, servicesForResolution, database, schemaService, cordappLoader.appClassLoader).apply { start() } - MaxLineLength:MockServices.kt$MockServices$this(cordappLoaderForPackages(cordappPackages), identityService, networkParameters, initialIdentity, moreKeys) MaxLineLength:MockServices.kt$MockServices$this(cordappLoaderForPackages(cordappPackages), identityService, networkParameters, initialIdentity, moreKeys, keyManagementService) MaxLineLength:MockServices.kt$MockServices$this(cordappLoaderForPackages(cordappPackages), identityService, testNetworkParameters(modifiedTime = Instant.MIN), initialIdentity, moreKeys) MaxLineLength:MockServices.kt$MockServices.Companion$ @JvmStatic @JvmOverloads fun makeTestDatabaseAndMockServices(cordappPackages: List<String>, identityService: IdentityService, initialIdentity: TestIdentity, networkParameters: NetworkParameters = testNetworkParameters(modifiedTime = Instant.MIN), vararg moreKeys: KeyPair): Pair<CordaPersistence, MockServices> MaxLineLength:MockServices.kt$MockServices.Companion$ @JvmStatic @JvmOverloads fun makeTestDatabaseAndPersistentServices( cordappPackages: List<String>, initialIdentity: TestIdentity, networkParameters: NetworkParameters = testNetworkParameters(modifiedTime = Instant.MIN), moreKeys: Set<KeyPair>, moreIdentities: Set<PartyAndCertificate> ): Pair<CordaPersistence, MockServices> MaxLineLength:MockServices.kt$MockServices.Companion$makeMockMockServices(cordappLoader, identityService, networkParameters, initialIdentity, moreKeys, keyManagementService, schemaService, persistence) MaxLineLength:MockServices.kt$MockServices.Companion$makeMockMockServices(cordappLoader, identityService, networkParameters, initialIdentity, moreKeys.toSet(), keyManagementService, schemaService, database) - MaxLineLength:MockServices.kt$MockServices.Companion$networkParameters: NetworkParameters = testNetworkParameters(modifiedTime = Instant.MIN) - MaxLineLength:MockServices.kt$MockServices.Companion$private - MaxLineLength:MockServices.kt$MockServices.Companion$props.setProperty("dataSource.url", "jdbc:h2:mem:${nodeName}_persistence;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE") - MaxLineLength:MockServices.kt$MockServices.Companion$return JarScanningCordappLoader.fromJarUrls(cordappsForPackages(packages).map { it.jarFile.toUri().toURL() }, versionInfo) MaxLineLength:MockServices.kt$MockServices.Companion$return object : MockServices(cordappLoader, identityService, networkParameters, initialIdentity, moreKeys.toTypedArray(), keyManagementService) { override var networkParametersService: NetworkParametersService = MockNetworkParametersStorage(networkParameters) override val vaultService: VaultService = makeVaultService(schemaService, persistence, cordappLoader) override fun recordTransactions(statesToRecord: StatesToRecord, txs: Iterable<SignedTransaction>) { ServiceHubInternal.recordTransactions(statesToRecord, txs, validatedTransactions as WritableTransactionStorage, mockStateMachineRecordedTransactionMappingStorage, vaultService as VaultServiceInternal, persistence) } override fun jdbcSession(): Connection = persistence.createSession() override fun <T : Any> withEntityManager(block: EntityManager.() -> T): T { return block(contextTransaction.restrictedEntityManager) } override fun withEntityManager(block: Consumer<EntityManager>) { return block.accept(contextTransaction.restrictedEntityManager) } } MaxLineLength:MockServices.kt$MockServices.Companion$val database = configureDatabase(dataSourceProps, DatabaseConfig(), identityService::wellKnownPartyFromX500Name, identityService::wellKnownPartyFromAnonymous, schemaService, schemaService.internalSchemas()) - MaxLineLength:MockServices.kt$MockServices.Companion$val keyManagementService = MockKeyManagementService(identityService, *arrayOf(initialIdentity.keyPair) + moreKeys) - MaxLineLength:MockServices.kt$MockServices.Companion$val keyManagementService = PersistentKeyManagementService(TestingNamedCacheFactory(), identityService, persistence) MaxLineLength:MockServices.kt$MockServices.Companion$val persistence = configureDatabase(dataSourceProps, DatabaseConfig(), identityService::wellKnownPartyFromX500Name, identityService::wellKnownPartyFromAnonymous, schemaService, schemaService.internalSchemas()) - MaxLineLength:MockServices.kt$MockServices.Companion${ val cordappLoader = cordappLoaderForPackages(cordappPackages) val dataSourceProps = makeTestDataSourceProperties() val schemaService = NodeSchemaService(cordappLoader.cordappSchemas) val identityService = PersistentIdentityService(TestingNamedCacheFactory()) val persistence = configureDatabase(dataSourceProps, DatabaseConfig(), identityService::wellKnownPartyFromX500Name, identityService::wellKnownPartyFromAnonymous, schemaService, schemaService.internalSchemas()) // Create a persistent identity service and add all the supplied identities. identityService.apply { ourNames = setOf(initialIdentity.name) database = persistence start(DEV_ROOT_CA.certificate) persistence.transaction { identityService.loadIdentities(moreIdentities + initialIdentity.identity) } } // Create a persistent key management service and add the key pair which was created for the TestIdentity. // We only add the keypair for the initial identity and any other keys which this node may control. Note: We don't add the keys // for the other identities. val keyManagementService = PersistentKeyManagementService(TestingNamedCacheFactory(), identityService, persistence) persistence.transaction { keyManagementService.start(moreKeys + initialIdentity.keyPair) } val mockService = persistence.transaction { makeMockMockServices(cordappLoader, identityService, networkParameters, initialIdentity, moreKeys, keyManagementService, schemaService, persistence) } return Pair(persistence, mockService) } - MaxLineLength:MockServices.kt$MockServices.Companion.<no name provided>$override var networkParametersService: NetworkParametersService = MockNetworkParametersStorage(networkParameters) - MaxLineLength:Models.kt$Models MaxLineLength:MyCustomNotaryService.kt$MyCustomValidatingNotaryService : SinglePartyNotaryService - MaxLineLength:MyCustomNotaryService.kt$MyCustomValidatingNotaryService$override fun createServiceFlow(otherPartySession: FlowSession): FlowLogic<Void?> - MaxLineLength:MyCustomNotaryService.kt$MyCustomValidatingNotaryService$override val uniquenessProvider = PersistentUniquenessProvider(services.clock, services.database, services.cacheFactory) - MaxLineLength:MyCustomNotaryService.kt$MyValidatingNotaryFlow : ValidatingNotaryFlow - MaxLineLength:NOT_YET_REGISTERED_MARKER_KEYS_AND_CERTS.kt$NOT_YET_REGISTERED_MARKER_KEYS_AND_CERTS$val ECDSAR1_KEYPAIR by lazy { Crypto.deriveKeyPairFromEntropy(Crypto.ECDSA_SECP256R1_SHA256, BigInteger.valueOf(0)) } - MaxLineLength:NamedCacheTest.kt$NamedCacheTest$override - MaxLineLength:Network.kt$Network$centralLabel = mapLabels.firstOrDefault(SimpleObjectProperty(myLabel), { centralPeer?.contains(it.text, true) == true }) - MaxLineLength:Network.kt$Network$if (it is WireTransaction) it.outputStates.observable().getParties() // For ContractUpgradeWireTransaction and NotaryChangeWireTransaction the output parties are the same as input parties else inputParties - MaxLineLength:Network.kt$Network$label(PartyNameFormatter.short.format(identities[0].name)) { font = Font.font(font.family, FontWeight.BOLD, 15.0) } - MaxLineLength:Network.kt$Network$mapScrollPane.hvalue = (valX + adjustment.x) / (mapImageView.layoutBounds.width - mapScrollPane.viewportBounds.width) - MaxLineLength:Network.kt$Network$mapScrollPane.vvalue = (valY + adjustment.y) / (mapImageView.layoutBounds.height - mapScrollPane.viewportBounds.height) MaxLineLength:Network.kt$Network$node.getWorldMapLocation()?.coordinate?.project(mapPane.width, mapPane.height, 85.0511, -85.0511, -180.0, 180.0) ?: ScreenCoordinate(0.0, 0.0) - MaxLineLength:Network.kt$Network$private MaxLineLength:Network.kt$Network$private val peerButtons = peerComponents.filtered { myIdentity.value !in it.nodeInfo.legalIdentitiesAndCerts.map { it.party } }.map { it.button } MaxLineLength:Network.kt$Network$val inputParties = it.inputs.sequence() .map { it as? PartiallyResolvedTransaction.InputResolution.Resolved } .filterNotNull() .map { it.stateAndRef.state.data }.getParties() val outputParties = it.transaction.coreTransaction.let { if (it is WireTransaction) it.outputStates.observable().getParties() // For ContractUpgradeWireTransaction and NotaryChangeWireTransaction the output parties are the same as input parties else inputParties } val signingParties = it.transaction.sigs.map { it.by.toKnownParty() } // Input parties fire a bullets to all output parties, and to the signing parties. !! This is a rough guess of how the message moves in the network. // TODO : Expose artemis queue to get real message information. inputParties.cross(outputParties) + inputParties.cross(signingParties) MaxLineLength:Network.kt$Network$val mapLabel = label(PartyNameFormatter.short.format(identities.first().name)) // We choose the first one for the name of the node on the map. - MaxLineLength:Network.kt$Network$val newHeight = Math.min(Math.max(mapImageView.prefHeight(-1.0) * zoomFactor, mapOriginalHeight), mapOriginalHeight * 10) - MaxLineLength:Network.kt$Network$val receiver = destNode.label.boundsInParentProperty().map { Point2D(it.width / 2 + it.minX, it.height / 4 - 2.5 + it.minY) } - MaxLineLength:Network.kt$Network$val sender = senderNode.label.boundsInParentProperty().map { Point2D(it.width / 2 + it.minX, it.height / 4 - 2.5 + it.minY) } MaxLineLength:Network.kt$Network${ // It has to be a copy if we want to have notary both in notaries list and in identity (if we are looking at that particular notary node). myIdentityPane.apply { center = node.renderButton(mapLabel) } myLabel = mapLabel } - MaxLineLength:Network.kt$Network${ val node = this val identities = node.legalIdentitiesAndCerts.sortedBy { it.owningKey.toBase58String() } val mapLabel = label(PartyNameFormatter.short.format(identities.first().name)) // We choose the first one for the name of the node on the map. mapPane.add(mapLabel) // applyCss: This method does not normally need to be invoked directly but may be used in conjunction with Parent.layout() // to size a Node before the next pulse, or if the Scene is not in a Stage. // It's needed to properly add node label to the map (before that width and height are 0 which results in wrong placement of // nodes rendered after initial map rendering). mapPane.applyCss() mapPane.layout() mapLabel.apply { graphic = FontAwesomeIconView(FontAwesomeIcon.DOT_CIRCLE_ALT) contentDisplay = ContentDisplay.TOP val coordinate = Bindings.createObjectBinding({ // These coordinates are obtained when we generate the map using TileMill. node.getWorldMapLocation()?.coordinate?.project(mapPane.width, mapPane.height, 85.0511, -85.0511, -180.0, 180.0) ?: ScreenCoordinate(0.0, 0.0) }, arrayOf(mapPane.widthProperty(), mapPane.heightProperty())) // Center point of the label. layoutXProperty().bind(coordinate.map { it.screenX - width / 2 }) layoutYProperty().bind(coordinate.map { it.screenY - height / 4 }) } val button = node.renderButton(mapLabel) if (myIdentity.value in node.legalIdentitiesAndCerts.map { it.party }) { // It has to be a copy if we want to have notary both in notaries list and in identity (if we are looking at that particular notary node). myIdentityPane.apply { center = node.renderButton(mapLabel) } myLabel = mapLabel } return MapViewComponents(this, button, mapLabel) } - MaxLineLength:NetworkBootstrapper.kt$CopyCordapps$println("WARNING: ${it.fileName} already exists in $cordappsDir, ignoring and leaving existing CorDapp untouched") - MaxLineLength:NetworkBootstrapper.kt$CopyCordapps$protected abstract fun copyTo(cordappJars: List<Path>, nodeDirs: List<Path>, networkAlreadyExists: Boolean, fromCordform: Boolean) - MaxLineLength:NetworkBootstrapper.kt$CopyCordapps.FirstRunOnly$override MaxLineLength:NetworkBootstrapper.kt$CopyCordapps.FirstRunOnly$println("Not copying CorDapp JARs as --copy-cordapps is set to FirstRunOnly, and it looks like this network has already been bootstrapped.") - MaxLineLength:NetworkBootstrapper.kt$CopyCordapps.No$override MaxLineLength:NetworkBootstrapper.kt$CopyCordapps.Yes$override fun copyTo(cordappJars: List<Path>, nodeDirs: List<Path>, networkAlreadyExists: Boolean, fromCordform: Boolean) - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$1 -> return netParamsFilesGrouped.keys.first().deserialize().verifiedNetworkParametersCert(DEV_ROOT_CA.certificate) - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$bootstrap(directory, cordappJars, copyCordapps, fromCordform = false, networkParametersOverrides = networkParameterOverrides) - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$is NotaryCluster.CFT -> DevIdentityGenerator.generateDistributedNotarySingularIdentity(directories, cluster.name) - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$listOf(CordaX500Name.parse(config.getString("notary.serviceLegalName")) to DirectoryAndConfig(path, config)) - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$override MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$paths.filter { it.toString().endsWith(".jar") && !it.isSameAs(bootstrapperJar) && !jarsThatArentCordapps.contains(it.fileName.toString().toLowerCase()) } - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$private val contractsJarConverter: (Path) -> ContractsJar MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$require(networkParameterOverrides.minimumPlatformVersion == null || networkParameterOverrides.minimumPlatformVersion <= PLATFORM_VERSION) { "Minimum platform version cannot be greater than $PLATFORM_VERSION" } - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$val msg = StringBuilder("Differing sets of network parameters were found. Make sure all the nodes have the same " + "network parameters by copying the correct $NETWORK_PARAMS_FILE_NAME file across.\n\n") - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$val newNetParams = installNetworkParameters(notaryInfos, newWhitelist, existingNetParams, nodeDirs, networkParametersOverrides) MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$val newWhitelist = generateWhitelist(existingNetParams, readExcludeWhitelist(directory), unsignedJars.map(contractsJarConverter), readIncludeWhitelist(directory), signedJars.map(contractsJarConverter)) - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$val nodeDirs = directory.list { subDir -> subDir.filter { (it / "node.conf").exists() && !(it / "corda.jar").exists() }.toList() } MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$val signedJars = cordappJars.filter { isSigned(it) } // signed JARs are excluded by default, optionally include them in order to transition states from CZ whitelist to signature constraint - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$webServerConfFiles.firstOrNull { directory.relativize(it).toString().removeSuffix("_web-server.conf") == nodeName } - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper$when (legalIdentities.size) { // Single node notaries have just one identity like all other nodes. This identity is the notary identity 1 -> legalIdentities[0] // Nodes which are part of a distributed notary have a second identity which is the composite identity of the // cluster and is shared by all the other members. This is the notary identity. 2 -> legalIdentities[1] else -> throw IllegalArgumentException("Not sure how to get the notary identity in this scenario: $this") } - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper.AMQPParametersSerializationScheme$override - MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapper.Companion$val timePerNode = 40.seconds // On the test machine, generating the node info takes 7 seconds for a single node. MaxLineLength:NetworkBootstrapper.kt$NetworkBootstrapperWithOverridableParameters$fun bootstrap(directory: Path, copyCordapps: CopyCordapps, networkParameterOverrides: NetworkParametersOverrides = NetworkParametersOverrides()) - MaxLineLength:NetworkBootstrapperRunnerTests.kt$NetworkBootstrapperRunnerTests$@Test fun `test when a package is specified in the network parameters file it is passed through to the bootstrapper DSA`() - MaxLineLength:NetworkBootstrapperRunnerTests.kt$NetworkBootstrapperRunnerTests$@Test fun `test when a package is specified in the network parameters file it is passed through to the bootstrapper EC`() MaxLineLength:NetworkBootstrapperRunnerTests.kt$NetworkBootstrapperRunnerTests$verify(mockBootstrapper) MaxLineLength:NetworkBootstrapperRunnerTests.kt$NetworkBootstrapperRunnerTests$verify(mockBootstrapper).bootstrap(Paths.get(".").toAbsolutePath().normalize(), CopyCordapps.FirstRunOnly, NetworkParametersOverrides()) MaxLineLength:NetworkBootstrapperRunnerTests.kt$NetworkBootstrapperRunnerTests$verify(mockBootstrapper).bootstrap(Paths.get(".").toAbsolutePath().normalize(), CopyCordapps.FirstRunOnly, NetworkParametersOverrides(eventHorizon = 7.days)) MaxLineLength:NetworkBootstrapperRunnerTests.kt$NetworkBootstrapperRunnerTests$verify(mockBootstrapper).bootstrap(Paths.get(".").toAbsolutePath().normalize(), CopyCordapps.FirstRunOnly, NetworkParametersOverrides(maxMessageSize = 1)) MaxLineLength:NetworkBootstrapperRunnerTests.kt$NetworkBootstrapperRunnerTests$verify(mockBootstrapper).bootstrap(Paths.get(".").toAbsolutePath().normalize(), CopyCordapps.FirstRunOnly, NetworkParametersOverrides(maxTransactionSize = 1)) MaxLineLength:NetworkBootstrapperRunnerTests.kt$NetworkBootstrapperRunnerTests$verify(mockBootstrapper).bootstrap(Paths.get(".").toAbsolutePath().normalize(), CopyCordapps.FirstRunOnly, NetworkParametersOverrides(minimumPlatformVersion = 1)) - MaxLineLength:NetworkBootstrapperRunnerTests.kt$NetworkBootstrapperRunnerTests$verify(mockBootstrapper).bootstrap(Paths.get(".").toAbsolutePath().normalize(), CopyCordapps.No, NetworkParametersOverrides()) MaxLineLength:NetworkBootstrapperRunnerTests.kt$NetworkBootstrapperRunnerTests$verify(mockBootstrapper).bootstrap(tempDir.toPath().toAbsolutePath().normalize(), CopyCordapps.FirstRunOnly, NetworkParametersOverrides()) - MaxLineLength:NetworkBootstrapperTest.kt$NetworkBootstrapperTest$assertContainsPackageOwner("bob", mapOf(Pair(alicePackageName, ALICE.publicKey), Pair(bobPackageName, BOB.publicKey))) - MaxLineLength:NetworkBootstrapperTest.kt$NetworkBootstrapperTest$bootstrap(packageOwnership = mapOf(Pair(alicePackageName, ALICE.publicKey), Pair(bobPackageName, BOB.publicKey))) - MaxLineLength:NetworkBootstrapperTest.kt$NetworkBootstrapperTest$private - MaxLineLength:NetworkBootstrapperTest.kt$NetworkBootstrapperTest$return list { it.filter { it.fileName.toString().startsWith(NODE_INFO_FILE_NAME_PREFIX) }.toList() }.single() - MaxLineLength:NetworkBootstrapperTest.kt$NetworkBootstrapperTest$val networkParameters = assertBootstrappedNetwork(fakeEmbeddedCorda, "alice" to aliceConfig, "notary" to notaryConfig) - MaxLineLength:NetworkBootstrapperTest.kt$NetworkBootstrapperTest$val networkParameters2 = assertBootstrappedNetwork(fakeEmbeddedCorda, "alice" to aliceConfig, "bob" to bobConfig) - MaxLineLength:NetworkBuilder.kt$NetworkBuilderImpl$nodeInstantiator.createInstanceRequest(it).also { onNodeInstanceRequestedCallback(listOf(it)) } - MaxLineLength:NetworkBuilder.kt$NetworkBuilderImpl$nodeInstantiator.instantiateNotaryInstance(request).thenApply { it.also(onNodeInstanceCallback) } MaxLineLength:NetworkHostAndPort.kt$NetworkHostAndPort.Companion$ @JvmStatic fun parse(str: String): NetworkHostAndPort - MaxLineLength:NetworkHostAndPortTest.kt$NetworkHostAndPortTest${ NetworkHostAndPort("example.com", it) } - MaxLineLength:NetworkHostAndPortTest.kt$NetworkHostAndPortTest${ NetworkHostAndPort.parse(it) } - MaxLineLength:NetworkIdentityModel.kt$NetworkIdentityModel$val notaries = ChosenList(rpcProxy.map { FXCollections.observableList(it?.cordaRPCOps?.notaryIdentities() ?: emptyList()) }, "notaries") - MaxLineLength:NetworkIdentityModel.kt$NetworkIdentityModel$val notaryNodes: ObservableList<NodeInfo> = notaries.map { rpcProxy.value?.cordaRPCOps?.nodeInfoFromParty(it) }.filterNotNull() - MaxLineLength:NetworkMap.kt$ParametersUpdate - MaxLineLength:NetworkMapCache.kt$NetworkMapCache$ fun getNodeByLegalIdentity(party: AbstractParty): NodeInfo? - MaxLineLength:NetworkMapCache.kt$NetworkMapCacheBase$ fun getNodeByLegalName(name: CordaX500Name): NodeInfo? - MaxLineLength:NetworkMapCache.kt$NetworkMapCacheBase$ fun getNodesByLegalName(name: CordaX500Name): List<NodeInfo> - MaxLineLength:NetworkMapCache.kt$NetworkMapCacheBase$ fun track(): DataFeed<List<NodeInfo>, NetworkMapCache.MapChange> - MaxLineLength:NetworkMapCache.kt$NetworkMapCacheBase$/** * A list of notary services available on the network. * * Note that the identities are sorted based on legal name, and the ordering might change once new notaries are introduced. */ val notaryIdentities: List<Party> - MaxLineLength:NetworkMapCacheTest.kt$NetworkMapCacheTest$assertEquals(aliceNode.info, bobCache.getNodesByLegalIdentityKey(aliceNode.info.singleIdentity().owningKey).single()) - MaxLineLength:NetworkMapCacheTest.kt$NetworkMapCacheTest$assertEquals(aliceNode.services.networkMapCache.getNodesByLegalIdentityKey(alice.owningKey).singleOrNull(), aliceNode.info) - MaxLineLength:NetworkMapCacheTest.kt$NetworkMapCacheTest$assertEquals(aliceNode.services.networkMapCache.getNodesByLegalIdentityKey(alice.owningKey).singleOrNull(), bobNode.info) - MaxLineLength:NetworkMapClient.kt$NetworkMapClient$logger.trace { "Fetched network parameters: '$networkParameterHash' successfully. Network Parameters: $networkParameter" } - MaxLineLength:NetworkMapClient.kt$NetworkMapClient$logger.trace { "Sending network parameters with hash ${signedParametersHash.raw.deserialize()} approval to $ackURL." } - MaxLineLength:NetworkMapClientTest.kt$NetworkMapClientTest$assertEquals(networkMapClient.getNetworkParameters(originalNetworkParameterHash).verified(), server.networkParameters) MaxLineLength:NetworkMapServer.kt$NetworkMapServer$val jerseyServlet = ServletHolder(ServletContainer(resourceConfig)).apply { initOrder = 0 } // Initialise at server start MaxLineLength:NetworkMapServer.kt$NetworkMapServer.InMemoryNetworkMapService$nodeInfoMap.filter { it.value.verified().legalIdentities.first().name == signedNodeInfo.verified().legalIdentities.first().name } - MaxLineLength:NetworkMapServer.kt$NetworkMapServer.InMemoryNetworkMapService$return Response.ok(signedNetworkMap.serialize().bytes).header("Cache-Control", "max-age=${pollInterval.seconds}").build() - MaxLineLength:NetworkMapTest.kt$NetworkMapTest$@Test fun `nodes process additions and removals from the network map correctly (and also download the network parameters)`() - MaxLineLength:NetworkMapTest.kt$NetworkMapTest$assertEquals(laterHash, networkMapServer.latestParametersAccepted(alice.nodeInfo.legalIdentities.first().owningKey)) MaxLineLength:NetworkMapTest.kt$NetworkMapTest$assertThat(nodeInfosDir.list().single().readObject<SignedNodeInfo>().verified().legalIdentities.first(), `is`( this.nodeInfo.legalIdentities.first())) MaxLineLength:NetworkMapTest.kt$NetworkMapTest$assertThatThrownBy { alice.rpc.acceptNewNetworkParameters(nextHash) }.hasMessageContaining("Refused to accept parameters with hash") - MaxLineLength:NetworkMapTest.kt$NetworkMapTest$networkMapServer.scheduleParametersUpdate(laterParams, "Another update", Instant.ofEpochMilli(random63BitValue())) - MaxLineLength:NetworkMapTest.kt$NetworkMapTest$networkMapServer.scheduleParametersUpdate(nextParams, "Next parameters", Instant.ofEpochMilli(random63BitValue())) - MaxLineLength:NetworkMapTest.kt$NetworkMapTest$val aliceNode = startNode(providedName = ALICE_NAME, devMode = false).getOrThrow() val aliceNodeInfo = aliceNode.nodeInfo.serialize().hash assertThat(networkMapServer.networkMapHashes()).contains(aliceNodeInfo) networkMapServer.removeNodeInfo(aliceNode.nodeInfo) var maxRemoveRetries = 5 // Try to remove multiple times in case the network map republishes just in between the removal and the check. while (aliceNodeInfo in networkMapServer.networkMapHashes()) { networkMapServer.removeNodeInfo(aliceNode.nodeInfo) if (maxRemoveRetries-- == 0) { throw AssertionError("Could not remove Node info.") } } // Wait until the node info is republished. Thread.sleep(2000) assertThat(networkMapServer.networkMapHashes()).contains(aliceNodeInfo) MaxLineLength:NetworkMapTest.kt$NetworkMapTest.Companion$nms.networkParameters = testNetworkParameters(it, modifiedTime = Instant.ofEpochMilli(random63BitValue()), epoch = 2) - MaxLineLength:NetworkMapUpdater.kt$@VisibleForTesting internal MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$"""Node is using network parameters with hash $currentParametersHash but the network map is advertising ${networkMap.networkParameterHash}. To resolve this mismatch, and move to the current parameters, delete the $NETWORK_PARAMS_FILE_NAME file from the node's directory and restart. The node will shutdown now.""" - MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$// Add new node info to the network map cache, these could be new node info or modification of node info for existing nodes. networkMapCache.addNode(it) - MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$ParametersUpdateInfo(it.first.newParametersHash, it.second.verified(), it.first.description, it.first.updateDeadline) MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$To resolve this mismatch, and move to the current parameters, delete the - MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$hash.serialize().sign { keyManagementService.sign(it.bytes, ourNodeInfo.verified().legalIdentities[0].owningKey) } - MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$if (autoAcceptNetworkParameters && networkParameters.canAutoAccept(newNetParams, excludedAutoAcceptNetworkParameters)) { logger.info("Auto-accepting network parameter update ${update.newParametersHash}") acceptNewNetworkParameters(update.newParametersHash) { hash -> hash.serialize().sign { keyManagementService.sign(it.bytes, ourNodeInfo.verified().legalIdentities[0].owningKey) } } } else { parametersUpdatesTrack.onNext(updateInfo) } - MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$logger.info("Auto-accept enabled for network parameter changes which modify only: $autoAcceptNetworkParametersNames") MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$networkMapClient ?: throw IllegalStateException("Network parameters updates are not supported without compatibility zone configured") - MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$private - MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$this.excludedAutoAcceptNetworkParameters = networkParameterAcceptanceSettings.excludedAutoAcceptableParameters - MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$throw CordaRuntimeException("Network map cache can be updated only if network map/compatibility zone URL is specified") MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$val (update, signedNewNetParams) = requireNotNull(newNetworkParameters) { "Couldn't find parameters update for the hash: $parametersHash" } - MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater$val acceptedHash = if (updatesFile.exists()) updatesFile.readObject<SignedNetworkParameters>().raw.hash else null - MaxLineLength:NetworkMapUpdater.kt$NetworkMapUpdater${ networkMapClient ?: throw IllegalStateException("Network parameters updates are not supported without compatibility zone configured") // TODO This scenario will happen if node was restarted and didn't download parameters yet, but we accepted them. // Add persisting of newest parameters from update. val (update, signedNewNetParams) = requireNotNull(newNetworkParameters) { "Couldn't find parameters update for the hash: $parametersHash" } // We should check that we sign the right data structure hash. val newNetParams = signedNewNetParams.verifiedNetworkParametersCert(trustRoot) val newParametersHash = signedNewNetParams.raw.hash if (parametersHash == newParametersHash) { // The latest parameters have priority. signedNewNetParams.serialize() .open() .copyTo(baseDirectory / NETWORK_PARAMS_UPDATE_FILE_NAME, StandardCopyOption.REPLACE_EXISTING) networkMapClient.ackNetworkParametersUpdate(sign(parametersHash)) logger.info("Accepted network parameter update $update: $newNetParams") } else { throw OutdatedNetworkParameterHashException(parametersHash, newParametersHash) } } - MaxLineLength:NetworkMapUpdater.kt$autoAcceptableNamesAndGetters.none { it.key in excludedParameterNames && valueChanged(newNetworkParameters, it.value) } - MaxLineLength:NetworkMapUpdater.kt$private fun KProperty1<out NetworkParameters, Any?>.isAutoAcceptable(): Boolean - MaxLineLength:NetworkMapUpdater.kt$private val memberPropertyPartition = NetworkParameters::class.declaredMemberProperties.partition { it.isAutoAcceptable() } - MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$// Test fix for ENT-1882 // This scenario can happen when signing of network map server is performed much longer after the node joined the network. // Network map will advertise hashes without that node. @Test fun `not remove own node info when it is not in network map yet`() - MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$@Test fun `network parameters not auto-accepted when update only changes whitelist but auto accept configured to be false`() - MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$@Test fun `network parameters not auto-accepted when update only changes whitelist but parameter included in exclusion`() - MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$NetworkParameterAcceptanceSettings(autoAcceptNetworkParameters, excludedAutoAcceptNetworkParameters) MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$assertFalse(netParams.canAutoAccept(netParamsAutoAcceptable, setOf("whitelistedContractImplementations")), "not auto-acceptable if only AutoAcceptable params have changed but one has been added to the exclusion set") MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$assertFalse(netParams.canAutoAccept(netParamsNotAutoAcceptable, emptySet()), "not auto-acceptable if non-AutoAcceptable param has changed") MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$assertThat(networkMapCache.allNodeHashes).containsExactlyInAnyOrder(fileNodeInfoAndSigned1.signed.raw.hash, fileNodeInfoAndSigned2.signed.raw.hash) - MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$assertThat(networkMapCache.allNodeHashes).containsExactlyInAnyOrder(signedMyInfo.raw.hash, signedOtherInfo.raw.hash) - MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$assertTrue(netParams.canAutoAccept(netParams, autoAcceptablePropertyNames), "auto acceptable if identical regardless of exclusions") MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$assertTrue(netParams.canAutoAccept(netParamsAutoAcceptable, emptySet()), "auto-acceptable if only AutoAcceptable params have changed") MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$assertTrue(netParams.canAutoAccept(netParamsAutoAcceptable, setOf("modifiedTime")), "auto-acceptable if only AutoAcceptable params have changed and excluded param has not changed") - MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$on { getNodeByHash(any()) }.then { mock -> data.values.singleOrNull { it.serialize().hash == mock.arguments[0] } } MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$private - MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$updater = NetworkMapUpdater(networkMapCache, fileWatcher, netMapClient, baseDir, extraNetworkMapKeys, networkParametersStorage) - MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$val fileName = "${NodeInfoFilesCopier.NODE_INFO_FILE_NAME_PREFIX}${localNodeInfo.legalIdentities[0].name.serialize().hash}" MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest$val fileName1 = "${NodeInfoFilesCopier.NODE_INFO_FILE_NAME_PREFIX}${fileNodeInfoAndSigned1.nodeInfo.legalIdentities[0].name.serialize().hash}" - MaxLineLength:NetworkMapUpdaterTest.kt$NetworkMapUpdaterTest${ setUpdater() val nodeInfoBuilder = TestNodeInfoBuilder() val (_, key) = nodeInfoBuilder.addLegalIdentity(CordaX500Name("Info", "London", "GB")) val (serverNodeInfo, serverSignedNodeInfo) = nodeInfoBuilder.buildWithSigned(1, 1) // Construct node for exactly same identity, but different serial. This one will go to additional-node-infos only. val localNodeInfo = serverNodeInfo.copy(serial = 17) val localSignedNodeInfo = NodeInfoAndSigned(localNodeInfo) { _, serialised -> key.sign(serialised.bytes) } // The one with higher serial goes to additional-node-infos. NodeInfoWatcher.saveToFile(nodeInfoDir, localSignedNodeInfo) // Publish to network map the one with lower serial. networkMapClient.publish(serverSignedNodeInfo) startUpdater() advanceTime() verify(networkMapCache, times(1)).addNode(localNodeInfo) // Node from file has higher serial than the one from NetworkMapServer eventually { assertThat(networkMapCache.allNodeHashes).containsOnly(localSignedNodeInfo.signed.raw.hash) } val fileName = "${NodeInfoFilesCopier.NODE_INFO_FILE_NAME_PREFIX}${localNodeInfo.legalIdentities[0].name.serialize().hash}" (nodeInfoDir / fileName).delete() advanceTime() verify(networkMapCache, times(1)).removeNode(any()) verify(networkMapCache).removeNode(localNodeInfo) eventually { // Instead of node from file we should have now the one from NetworkMapServer assertThat(networkMapCache.allNodeHashes).containsOnly(serverSignedNodeInfo.raw.hash) } } - MaxLineLength:NetworkParameterOverridesSpec.kt$NetworkParameterOverridesSpec$internal MaxLineLength:NetworkParameterOverridesSpec.kt$NetworkParameterOverridesSpec.PackageOwnershipSpec$badValue("Error reading the key store from the file for keyStoreFilePath: $suppliedKeystorePath and keyStorePassword: $keystorePassword ${e.message}") MaxLineLength:NetworkParameterOverridesSpec.kt$NetworkParameterOverridesSpec.PackageOwnershipSpec$badValue("Password is incorrect or the key store is damaged for keyStoreFilePath: $suppliedKeystorePath and keyStorePassword: $keystorePassword") MaxLineLength:NetworkParameterOverridesSpec.kt$fun Config.parseAsNetworkParametersConfiguration(options: Configuration.Validation.Options = Configuration.Validation.Options(strict = false)): Valid<NetworkParametersOverrides> - MaxLineLength:NetworkParameterOverridesSpec.kt$internal fun <T> badValue(msg: String): Valid<T> MaxLineLength:NetworkParameters.kt$NetworkParameters - MaxLineLength:NetworkParameters.kt$NetworkParameters$whitelistedContractImplementations: Map<String, List<AttachmentId>> = this.whitelistedContractImplementations MaxLineLength:NetworkParametersCopier.kt$NetworkParametersCopier$private val serialisedSignedNetParams: SerializedBytes<SignedDataWithCert<NetworkParameters>> = signingCertAndKeyPair.sign(networkParameters).serialize() - MaxLineLength:NetworkParametersReader.kt$NetworkParametersReader$logger.info("No network-parameters file found. Expecting network parameters to be available from the network map.") - MaxLineLength:NetworkParametersReader.kt$NetworkParametersReader$private - MaxLineLength:NetworkParametersReader.kt$NetworkParametersReader${ // Node joins for the first time. downloadParameters(advertisedParametersHash) } MaxLineLength:NetworkParametersReader.kt$NetworkParametersReader${ // TODO On one hand we have node starting without parameters and just accepting them by default, // on the other we have parameters update process - it needs to be unified. Say you start the node, you don't have matching parameters, // you get them from network map, but you have to run the approval step. if (signedParametersFromFile == null) { // Node joins for the first time. downloadParameters(advertisedParametersHash) } else if (signedParametersFromFile.raw.hash == advertisedParametersHash) { // Restarted with the same parameters. signedParametersFromFile } else { // Update case. readParametersUpdate(advertisedParametersHash, signedParametersFromFile.raw.hash) } } - MaxLineLength:NetworkParametersReader.kt$NetworkParametersReader${ logger.info("Unable to download network map", e) // If NetworkMap is down while restarting the node, we should be still able to continue with parameters from file null } MaxLineLength:NetworkParametersReader.kt$NetworkParametersReader.Error$NetworkMapNotConfigured : Error - MaxLineLength:NetworkParametersReader.kt$NetworkParametersReader.Error$ParamsNotConfigured : Error - MaxLineLength:NetworkParametersReader.kt$NetworkParametersReader.Error.OldParamsAndUpdate$"parameters advertised by network map. Please update node to use correct network parameters file." - MaxLineLength:NetworkParametersReaderTest.kt$NetworkParametersReaderTest$NetworkParametersCopier(server.networkParameters, update = true).install(baseDirectory) - MaxLineLength:NetworkParametersReaderTest.kt$NetworkParametersReaderTest$val parameters = NetworkParametersReader(DEV_ROOT_CA.certificate, networkMapClient, baseDirectory).read().networkParameters - MaxLineLength:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$(megaCorpNode.services.networkParametersService as NetworkParametersStorage).saveParameters(certKeyPair.sign(defaultParams)) - MaxLineLength:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$(megaCorpNode.services.networkParametersService as NetworkParametersStorage).saveParameters(certKeyPair.sign(params3)) - MaxLineLength:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$assertThatExceptionOfType(TransactionVerificationException.TransactionNetworkParameterOrderingException::class.java) MaxLineLength:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$cordappsForAllNodes = listOf(DUMMY_CONTRACTS_CORDAPP, cordappForClasses(ResolveTransactionsFlowTest.TestFlow::class.java, ResolveTransactionsFlowTest.TestResponseFlow::class.java)) - MaxLineLength:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$params2 = testNetworkParameters(epoch = 2, minimumPlatformVersion = 3, notaries = listOf((NotaryInfo(notaryParty, true)))) - MaxLineLength:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$params3 = testNetworkParameters(epoch = 3, minimumPlatformVersion = 4, notaries = listOf((NotaryInfo(notaryParty, true)))) MaxLineLength:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$private - MaxLineLength:NetworkParametersResolutionTest.kt$NetworkParametersResolutionTest$val signatureMetadata = SignatureMetadata(services.myInfo.platformVersion, Crypto.findSignatureScheme(publicKey).schemeNumberID) - MaxLineLength:NetworkParametersService.kt$NetworkParametersService$/** * For backwards compatibility, this parameters hash will be used for resolving historical transactions in the chain. */ val defaultHash: SecureHash MaxLineLength:NetworkParametersServiceInternal.kt$NetworkParametersStorage$ fun getEpochFromHash(hash: SecureHash): Int? - MaxLineLength:NetworkParametersServiceInternal.kt$NetworkParametersStorage$ fun getHistoricNotary(party: Party): NotaryInfo? - MaxLineLength:NetworkParametersServiceInternal.kt$NetworkParametersStorage$ fun lookupSigned(hash: SecureHash): SignedDataWithCert<NetworkParameters>? - MaxLineLength:NetworkParametersTest.kt$NetworkParametersTest$alice.services.startFlow(CashIssueFlow(500.DOLLARS, OpaqueBytes.of(0x01), fakeNotaryId)).resultFuture.getOrThrow() MaxLineLength:NetworkParametersTest.kt$NetworkParametersTest$val alice = mockNet.createUnstartedNode(InternalMockNodeParameters(legalName = ALICE_NAME, forcedID = 100, version = MOCK_VERSION_INFO.copy(platformVersion = 1))) MaxLineLength:NetworkParametersTest.kt$NetworkParametersTest$val alice = mockNet.createUnstartedNode(InternalMockNodeParameters(legalName = ALICE_NAME, forcedID = 100, version = MOCK_VERSION_INFO.copy(platformVersion = 2))) - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$ fun generateKeysAndRegister() MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$ | Please make sure the config is correct or that the correct certificate for the CRL issuer is added to the node's trust store. - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$"$networkRootTrustStorePath does not exist. This file must contain the root CA cert of your compatibility zone. " MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$certStore.query { setPrivateKey(SELF_SIGNED_PRIVATE_KEY, AliasPrivateKey(SELF_SIGNED_PRIVATE_KEY), listOf(NOT_YET_REGISTERED_MARKER_KEYS_AND_CERTS.ECDSAR1_CERT), certificateStore.entryPassword) } - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$if (Crypto.toSupportedPublicKey(certificates.first().publicKey) != Crypto.toSupportedPublicKey(registeringPublicKey)) { throw CertificateRequestException("Received certificate contains incorrect public key, expected '$registeringPublicKey', got '${certificates.first().publicKey}'.") } MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$logError MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$logProgress("Certificate signing request with the following information will be submitted to the Corda certificate signing server.") - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$logProgress("Successfully submitted request to Corda certificate signing server, request ID: $requestId.") MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$onSuccess(nodeCaPublicKey, cryptoService.getSigner(nodeCaKeyAlias), nodeCaCertificates, tlsCrlIssuerCert?.subjectX500Principal?.toX500Name()) - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$private val nextIdleDuration: (Duration?) -> Duration? = FixedPeriodLimitedRetrialStrategy(10, Duration.ofMinutes(1)) MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$protected open fun onSuccess(publicKey: PublicKey, contentSigner: ContentSigner, certificates: List<X509Certificate>, tlsCrlCertificateIssuer: X500Name?) MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$throw CertificateRequestException("Received certificate contains incorrect public key, expected '$registeringPublicKey', got '${certificates.first().publicKey}'.") MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$throw CertificateRequestException("Received certificate contains invalid cert role, expected '$certRole', got '$nodeCaCertRole'.") - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$throw CertificateRequestException("Subject of received node CA cert doesn't match with node legal name: $nodeCaSubject") - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$throw NodeRegistrationException("Compatibility Zone registration service is currently unavailable, " + "try again later!.", e) - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$val certStore: CertificateStore = if (cryptoService is BCCryptoService) cryptoService.certificateStore else certificateStore MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$val request = X509Utilities.createCertificateSigningRequest(myLegalName.x500Principal, emailAddress, publicKey, contentSigner, certRole) - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper$val requestId = submitOrResumeCertificateSigningRequest(nodeCaPublicKey, cryptoService.getSigner(nodeCaKeyAlias)) - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper${ // Create or load self signed keypair from the key store. // We use the self sign certificate to store the key temporarily in the keystore while waiting for the request approval. if (alias !in this) { // NODE_CA should be TLS compatible due to the cert hierarchy structure. val keyPair = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME) val selfSignCert = X509Utilities.createSelfSignedCACertificate(myLegalName.x500Principal, keyPair) // Save to the key store. with(value) { setPrivateKey(alias, keyPair.private, listOf(selfSignCert), keyPassword = entryPassword) save() } } return query { getCertificateAndKeyPair(alias, entryPassword) }.keyPair } - MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper${ certificatesDirectory.createDirectories() // We need this in case cryptoService and certificateStore share the same KeyStore (for backwards compatibility purposes). // If we didn't, then an update to cryptoService wouldn't be reflected to certificateStore that is already loaded in memory. val certStore: CertificateStore = if (cryptoService is BCCryptoService) cryptoService.certificateStore else certificateStore // SELF_SIGNED_PRIVATE_KEY is used as progress indicator. if (certStore.contains(nodeCaKeyAlias) && !certStore.contains(SELF_SIGNED_PRIVATE_KEY)) { logProgress("Certificate already exists, Corda node will now terminate...") return } val tlsCrlIssuerCert = getTlsCrlIssuerCert() // We use SELF_SIGNED_PRIVATE_KEY as progress indicator so we just store a dummy key and cert. // When registration succeeds, this entry should be deleted. certStore.query { setPrivateKey(SELF_SIGNED_PRIVATE_KEY, AliasPrivateKey(SELF_SIGNED_PRIVATE_KEY), listOf(NOT_YET_REGISTERED_MARKER_KEYS_AND_CERTS.ECDSAR1_CERT), certificateStore.entryPassword) } val nodeCaPublicKey = loadOrGenerateKeyPair() val requestId = submitOrResumeCertificateSigningRequest(nodeCaPublicKey, cryptoService.getSigner(nodeCaKeyAlias)) val nodeCaCertificates = pollServerForCertificates(requestId) validateCertificates(nodeCaPublicKey, nodeCaCertificates) certStore.setCertPathOnly(nodeCaKeyAlias, nodeCaCertificates) certStore.value.internal.deleteEntry(SELF_SIGNED_PRIVATE_KEY) certStore.value.save() logProgress("Private key '$nodeCaKeyAlias' and its certificate-chain stored successfully.") onSuccess(nodeCaPublicKey, cryptoService.getSigner(nodeCaKeyAlias), nodeCaCertificates, tlsCrlIssuerCert?.subjectX500Principal?.toX500Name()) // All done, clean up temp files. requestIdStore.deleteIfExists() } MaxLineLength:NetworkRegistrationHelper.kt$NetworkRegistrationHelper${ val nodeCACertificate = certificates.first() val nodeCaSubject = try { CordaX500Name.build(nodeCACertificate.subjectX500Principal) } catch (e: IllegalArgumentException) { throw CertificateRequestException("Received node CA cert has invalid subject name: ${e.message}") } if (nodeCaSubject != myLegalName) { throw CertificateRequestException("Subject of received node CA cert doesn't match with node legal name: $nodeCaSubject") } val nodeCaCertRole = try { CertRole.extract(nodeCACertificate) } catch (e: IllegalArgumentException) { throw CertificateRequestException("Unable to extract cert role from received node CA cert: ${e.message}") } if (certRole != nodeCaCertRole) { throw CertificateRequestException("Received certificate contains invalid cert role, expected '$certRole', got '$nodeCaCertRole'.") } // Validate returned certificate is for the correct public key. if (Crypto.toSupportedPublicKey(certificates.first().publicKey) != Crypto.toSupportedPublicKey(registeringPublicKey)) { throw CertificateRequestException("Received certificate contains incorrect public key, expected '$registeringPublicKey', got '${certificates.first().publicKey}'.") } // Validate certificate chain returned from the doorman with the root cert obtained via out-of-band process, to prevent MITM attack on doorman server. X509Utilities.validateCertificateChain(rootCert, certificates) logProgress("Certificate signing request approved, storing private key with the certificate chain.") } MaxLineLength:NetworkRegistrationHelper.kt$NodeRegistrationHelper$computeNextIdleDoormanConnectionPollInterval: (Duration?) -> Duration? = FixedPeriodLimitedRetrialStrategy(10, Duration.ofMinutes(1)) - MaxLineLength:NetworkRegistrationHelper.kt$NodeRegistrationHelper$logger.info("Copying trusted certificate to the node's trust store: Alias: $it, Certificate: $certificate") MaxLineLength:NetworkRegistrationHelper.kt$NodeRegistrationHelper$logger.warn("The node's trust store already exists. The following certificates will be overridden: ${this.aliases().asSequence()}") MaxLineLength:NetworkRegistrationHelper.kt$NodeRegistrationHelper$override MaxLineLength:NetworkRegistrationHelper.kt$NodeRegistrationHelper$private MaxLineLength:NetworkRegistrationHelper.kt$NodeRegistrationHelper$val validityWindow = X509Utilities.getCertificateValidityWindow(DEFAULT_VALIDITY_WINDOW.first, DEFAULT_VALIDITY_WINDOW.second, issuerCertificate) MaxLineLength:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest$CertRole.NODE_CA -> NodeRegistrationHelper(config, certService, NodeRegistrationOption(config.certificatesDirectory / networkRootTrustStoreFileName, networkRootTrustStorePassword)) - MaxLineLength:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest$NameConstraints(arrayOf(GeneralSubtree(GeneralName(GeneralName.directoryName, legalName.toX500Name()))), arrayOf()) - MaxLineLength:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest$doReturn(CertificateStoreStubs.P2P.withCertificatesDirectory(certificatesDirectory)).whenever(it).p2pSslOptions - MaxLineLength:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest$doReturn(CertificateStoreStubs.Signing.withCertificatesDirectory(certificatesDirectory)).whenever(it).signingCertificateStore MaxLineLength:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest$private - MaxLineLength:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest$publicKey: PublicKey = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME).public MaxLineLength:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest$rootAndIntermediateCA: Pair<CertificateAndKeyPair, CertificateAndKeyPair> = createDevIntermediateCaCertPath() - MaxLineLength:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest$val rootAndIntermediateCA = createDevIntermediateCaCertPath().also { saveNetworkTrustStore(CORDA_ROOT_CA to it.first.certificate) } - MaxLineLength:NetworkRegistrationHelperTest.kt$NetworkRegistrationHelperTest${ createFixedResponseRegistrationHelper(nodeCaCertPath) } - MaxLineLength:NetworkRegistrationService.kt$NetworkRegistrationService$ @Throws(CertificateRequestException::class) fun retrieveCertificates(requestId: String): CertificateResponse - MaxLineLength:NewTransaction.kt$NewTransaction$CashTransaction.Exit -> ExitRequest(Amount.fromDecimal(amount.value, currencyChoiceBox.value), issueRef) MaxLineLength:NewTransaction.kt$NewTransaction$CashTransaction.Issue -> IssueAndPaymentRequest(Amount.fromDecimal(amount.value, currencyChoiceBox.value), issueRef, partyBChoiceBox.value.party, selectNotary(), anonymous) MaxLineLength:NewTransaction.kt$NewTransaction$CashTransaction.Pay -> PaymentRequest(Amount.fromDecimal(amount.value, currencyChoiceBox.value), partyBChoiceBox.value.party, anonymous = anonymous, notary = selectNotary()) MaxLineLength:NewTransaction.kt$NewTransaction$issueRefLabel.visibleProperty().bind(transactionTypeCB.valueProperty().map { it == CashTransaction.Issue || it == CashTransaction.Exit }) MaxLineLength:NewTransaction.kt$NewTransaction$issuer.isNotNull.and(currencyChoiceBox.valueProperty().isNotNull).and(transactionTypeCB.valueProperty().booleanBinding(transactionTypeCB.valueProperty()) { it != CashTransaction.Issue }) - MaxLineLength:NewTransaction.kt$NewTransaction$partyATextField.textProperty().bind(myIdentity.map { it?.let { PartyNameFormatter.short.format(it.name) } ?: "" }) MaxLineLength:NewTransaction.kt$NewTransaction$val filteredCash = cash.filtered { it.token.issuer.party == issuer.value && it.token.product == currencyChoiceBox.value } .map { it.withoutIssuer() }.sumOrNull() MaxLineLength:NewTransaction.kt$NewTransaction$val issuer = Bindings.createObjectBinding({ if (issuerChoiceBox.isVisible) issuerChoiceBox.value else myIdentity.value }, arrayOf(myIdentity, issuerChoiceBox.visibleProperty(), issuerChoiceBox.valueProperty())) - MaxLineLength:NewTransaction.kt$NewTransaction$visibleProperty().bind(transactionTypeCB.valueProperty().map { it == CashTransaction.Issue || it == CashTransaction.Exit }) - MaxLineLength:Node.kt$Node$ override fun startDatabase() - MaxLineLength:Node.kt$Node$ private fun registerDefaultExceptionHandler() MaxLineLength:Node.kt$Node$"To disable autodetect set detectPublicIp = false in the node.conf, or consider using messagingServerAddress and messagingServerExternal" MaxLineLength:Node.kt$Node$ArtemisRpcBroker.withSsl(configuration.p2pSslOptions, this.address, adminAddress, sslConfig!!, securityManager, MAX_RPC_MESSAGE_SIZE, jmxMonitoringHttpPort != null, rpcBrokerDirectory, shouldStartLocalShell()) MaxLineLength:Node.kt$Node$ArtemisRpcBroker.withoutSsl(configuration.p2pSslOptions, this.address, adminAddress, securityManager, MAX_RPC_MESSAGE_SIZE, jmxMonitoringHttpPort != null, rpcBrokerDirectory, shouldStartLocalShell()) - MaxLineLength:Node.kt$Node$ObjectName("$domain:type=$category,${if (component.isNotEmpty()) "component=$component," else ""}name=$subName") MaxLineLength:Node.kt$Node$System.setProperty("h2.allowedClasses", "org.h2.mvstore.db.MVTableEngine,org.locationtech.jts.geom.Geometry,org.h2.server.TcpServer") MaxLineLength:Node.kt$Node$if (configuration.shouldStartLocalShell()) RPCSecurityManagerWithAdditionalUser(this, User(INTERNAL_SHELL_USER, INTERNAL_SHELL_USER, setOf(Permissions.all()))) else this MaxLineLength:Node.kt$Node$internalRpcMessagingClient = InternalRPCMessagingClient(configuration.p2pSslOptions, it.admin, MAX_RPC_MESSAGE_SIZE, CordaX500Name.build(configuration.p2pSslOptions.keyStore.get()[X509Utilities.CORDA_CLIENT_TLS].subjectX500Principal), rpcServerConfiguration) - MaxLineLength:Node.kt$Node$log MaxLineLength:Node.kt$Node$log.info("Detected public IP: ${foundPublicIP.hostAddress}. This will be used instead of the provided \"$host\" as the advertised address.") MaxLineLength:Node.kt$Node$log.info("Retrieved public IP from Network Map Service: $this. This will be used instead of the provided \"$host\" as the advertised address.") MaxLineLength:Node.kt$Node$override - MaxLineLength:Node.kt$Node$override fun myAddresses(): List<NetworkHostAndPort> MaxLineLength:Node.kt$Node$registerScheme(AMQPClientSerializationScheme(cordappLoader.cordapps, Caffeine.newBuilder().maximumSize(128).build<SerializationFactoryCacheKey, SerializerFactory>().asMap())) MaxLineLength:Node.kt$Node$registerScheme(AMQPServerSerializationScheme(cordappLoader.cordapps, Caffeine.newBuilder().maximumSize(128).build<SerializationFactoryCacheKey, SerializerFactory>().asMap())) - MaxLineLength:Node.kt$Node$require(nodeInfo.legalIdentities.size in 1..2) { "Currently nodes must have a primary address and optionally one serviced address" } MaxLineLength:Node.kt$Node$rpcClientContext = if (configuration.shouldInitCrashShell()) AMQP_RPC_CLIENT_CONTEXT.withClassLoader(classloader) else null - MaxLineLength:Node.kt$Node$serviceIdentity = if (nodeInfo.legalIdentities.size == 1) null else nodeInfo.legalIdentities[1].owningKey MaxLineLength:Node.kt$Node$throw CouldNotCreateDataSourceException("Database password is required for H2 server listening on ${InetAddress.getByName(effectiveH2Settings.address.host)}.") - MaxLineLength:Node.kt$Node${ check(!serverThread.isOnThread) synchronized(this) { if (shutdown) return shutdown = true // Unregister shutdown hook to prevent any unnecessary second calls to stop shutdownHook?.cancel() shutdownHook = null } printBasicNodeInfo("Shutting down ...") // All the Node started subsystems were registered with the runOnStop list at creation. // So now simply call the parent to stop everything in reverse order. // In particular this prevents premature shutdown of the Database by AbstractNode whilst the serverThread is active super.stop() shutdown = false log.info("Shutdown complete") } - MaxLineLength:Node.kt$Node${ override fun createStartedNode(nodeInfo: NodeInfo, rpcOps: CordaRPCOps, notaryService: NotaryService?): NodeInfo = nodeInfo companion object { private val staticLog = contextLogger() var renderBasicInfoToConsole = true /** Used for useful info that we always want to show, even when not logging to the console */ fun printBasicNodeInfo(description: String, info: String? = null) { val msg = if (info == null) description else "${description.padEnd(40)}: $info" val loggerName = if (renderBasicInfoToConsole) "BasicInfo" else "Main" LoggerFactory.getLogger(loggerName).info(msg) } fun printInRed(message: String) { println("${ShellConstants.RED}$message${ShellConstants.RESET}") } fun printWarning(message: String) { Emoji.renderIfSupported { printInRed("${Emoji.warningSign} ATTENTION: $message") } staticLog.warn(message) } internal fun failStartUp(message: String): Nothing { println(message) println("Corda will now exit...") exitProcess(1) } private fun createClock(configuration: NodeConfiguration): CordaClock { return (if (configuration.useTestClock) ::DemoClock else ::SimpleClock)(Clock.systemUTC()) } private val sameVmNodeCounter = AtomicInteger() // TODO: make this configurable. const val MAX_RPC_MESSAGE_SIZE = 10485760 fun isInvalidJavaVersion(): Boolean { if (!hasMinimumJavaVersion()) { println("You are using a version of Java that is not supported (${SystemUtils.JAVA_VERSION}). Please upgrade to the latest version of Java 8.") println("Corda will now exit...") return true } return false } private fun hasMinimumJavaVersion(): Boolean { // when the ext.java8_minUpdateVersion gradle constant changes, so must this check val major = SystemUtils.JAVA_VERSION_FLOAT return try { val update = getJavaUpdateVersion(SystemUtils.JAVA_VERSION) // To filter out cases like 1.8.0_202-ea major == 1.8F && update >= 171 } catch (e: NumberFormatException) { // custom JDKs may not have the update version (e.g. 1.8.0-adoptopenjdk) false } } } override val log: Logger get() = staticLog override val transactionVerifierWorkerCount: Int get() = 4 private var internalRpcMessagingClient: InternalRPCMessagingClient? = null private var rpcBroker: ArtemisBroker? = null private var shutdownHook: ShutdownHook? = null // DISCUSSION // // We use a single server thread for now, which means all message handling is serialized. // // Writing thread safe code is hard. In this project we are writing most node services and code to be thread safe, but // the possibility of mistakes is always present. Thus we make a deliberate decision here to trade off some multi-core // scalability in order to gain developer productivity by setting the size of the serverThread pool to one, which will // reduce the number of threading bugs we will need to tackle. // // This leaves us with four possibilities in future: // // (1) We discover that processing messages is fast and that our eventual use cases do not need very high // processing rates. We have benefited from the higher productivity and not lost anything. // // (2) We discover that we need greater multi-core scalability, but that the bulk of our time goes into particular CPU // hotspots that are easily multi-threaded e.g. signature checking. We successfully multi-thread those hotspots // and find that our software now scales sufficiently well to satisfy our user's needs. // // (3) We discover that it wasn't enough, but that we only need to run some messages in parallel and that the bulk of // the work can stay single threaded. For example perhaps we find that latency sensitive UI requests must be handled // on a separate thread pool where long blocking operations are not allowed, but that the bulk of the heavy lifting // can stay single threaded. In this case we would need a separate thread pool, but we still minimise the amount of // thread safe code we need to write and test. // // (4) None of the above are sufficient and we need to run all messages in parallel to get maximum (single machine) // scalability and fully saturate all cores. In that case we can go fully free-threaded, e.g. change the number '1' // below to some multiple of the core count. Alternatively by using the ForkJoinPool and let it figure out the right // number of threads by itself. This will require some investment in stress testing to build confidence that we // haven't made any mistakes, but it will only be necessary if eventual deployment scenarios demand it. // // Note that the messaging subsystem schedules work onto this thread in a blocking manner. That means if the server // thread becomes too slow and a backlog of work starts to builds up it propagates back through into the messaging // layer, which can then react to the backpressure. Artemis MQ in particular knows how to do flow control by paging // messages to disk rather than letting us run out of RAM. // // The primary work done by the server thread is execution of flow logics, and related // serialisation/deserialisation work. override fun makeMessagingService(): MessagingService { return P2PMessagingClient( config = configuration, versionInfo = versionInfo, serverAddress = configuration.messagingServerAddress ?: NetworkHostAndPort("localhost", configuration.p2pAddress.port), nodeExecutor = serverThread, database = database, networkMap = networkMapCache, isDrainingModeOn = nodeProperties.flowsDrainingMode::isEnabled, drainingModeWasChangedEvents = nodeProperties.flowsDrainingMode.values, metricRegistry = metricRegistry, cacheFactory = cacheFactory ) } override fun startMessagingService(rpcOps: RPCOps, nodeInfo: NodeInfo, myNotaryIdentity: PartyAndCertificate?, networkParameters: NetworkParameters) { require(nodeInfo.legalIdentities.size in 1..2) { "Currently nodes must have a primary address and optionally one serviced address" } network as P2PMessagingClient // Construct security manager reading users data either from the 'security' config section // if present or from rpcUsers list if the former is missing from config. val securityManagerConfig = configuration.security?.authService ?: SecurityConfiguration.AuthService.fromUsers(configuration.rpcUsers) val securityManager = with(RPCSecurityManagerImpl(securityManagerConfig, cacheFactory)) { if (configuration.shouldStartLocalShell()) RPCSecurityManagerWithAdditionalUser(this, User(INTERNAL_SHELL_USER, INTERNAL_SHELL_USER, setOf(Permissions.all()))) else this } val messageBroker = if (!configuration.messagingServerExternal) { val brokerBindAddress = configuration.messagingServerAddress ?: NetworkHostAndPort("0.0.0.0", configuration.p2pAddress.port) ArtemisMessagingServer(configuration, brokerBindAddress, networkParameters.maxMessageSize) } else { null } val rpcServerAddresses = if (configuration.rpcOptions.standAloneBroker) { BrokerAddresses(configuration.rpcOptions.address, configuration.rpcOptions.adminAddress) } else { startLocalRpcBroker(securityManager) } val bridgeControlListener = BridgeControlListener( configuration.p2pSslOptions, network.serverAddress, networkParameters.maxMessageSize, configuration.crlCheckSoftFail) printBasicNodeInfo("Advertised P2P messaging addresses", nodeInfo.addresses.joinToString()) val rpcServerConfiguration = RPCServerConfiguration.DEFAULT rpcServerAddresses?.let { internalRpcMessagingClient = InternalRPCMessagingClient(configuration.p2pSslOptions, it.admin, MAX_RPC_MESSAGE_SIZE, CordaX500Name.build(configuration.p2pSslOptions.keyStore.get()[X509Utilities.CORDA_CLIENT_TLS].subjectX500Principal), rpcServerConfiguration) printBasicNodeInfo("RPC connection address", it.primary.toString()) printBasicNodeInfo("RPC admin connection address", it.admin.toString()) } // Start up the embedded MQ server messageBroker?.apply { closeOnStop() start() } rpcBroker?.apply { closeOnStop() start() } // Start P2P bridge service bridgeControlListener.apply { closeOnStop() start() } // Start up the MQ clients. internalRpcMessagingClient?.run { closeOnStop() init(rpcOps, securityManager, cacheFactory) } network.closeOnStop() network.start( myIdentity = nodeInfo.legalIdentities[0].owningKey, serviceIdentity = if (nodeInfo.legalIdentities.size == 1) null else nodeInfo.legalIdentities[1].owningKey, advertisedAddress = nodeInfo.addresses[0], maxMessageSize = networkParameters.maxMessageSize ) } private fun startLocalRpcBroker(securityManager: RPCSecurityManager): BrokerAddresses? { return with(configuration) { rpcOptions.address.let { val rpcBrokerDirectory: Path = baseDirectory / "brokers" / "rpc" with(rpcOptions) { rpcBroker = if (useSsl) { ArtemisRpcBroker.withSsl(configuration.p2pSslOptions, this.address, adminAddress, sslConfig!!, securityManager, MAX_RPC_MESSAGE_SIZE, jmxMonitoringHttpPort != null, rpcBrokerDirectory, shouldStartLocalShell()) } else { ArtemisRpcBroker.withoutSsl(configuration.p2pSslOptions, this.address, adminAddress, securityManager, MAX_RPC_MESSAGE_SIZE, jmxMonitoringHttpPort != null, rpcBrokerDirectory, shouldStartLocalShell()) } } rpcBroker!!.addresses } } } override fun myAddresses(): List<NetworkHostAndPort> = listOf(getAdvertisedAddress()) + configuration.additionalP2PAddresses private fun getAdvertisedAddress(): NetworkHostAndPort { return with(configuration) { require(p2pAddress.host != "0.0.0.0") { "Invalid p2pAddress: $p2pAddress contains 0.0.0.0 which is not suitable as an advertised node address" } val host = if (detectPublicIp) { tryDetectIfNotPublicHost(p2pAddress.host) ?: p2pAddress.host } else { p2pAddress.host } NetworkHostAndPort(host, p2pAddress.port) } } /** * Checks whether the specified [host] is a public IP address or hostname. If not, tries to discover the current * machine's public IP address to be used instead by looking through the network interfaces. */ private fun tryDetectIfNotPublicHost(host: String): String? { return if (host.toLowerCase() == "localhost") { log.warn("p2pAddress specified as localhost. Trying to autodetect a suitable public address to advertise in network map." + "To disable autodetect set detectPublicIp = false in the node.conf, or consider using messagingServerAddress and messagingServerExternal") val foundPublicIP = AddressUtils.tryDetectPublicIP() if (foundPublicIP == null) { try { val retrievedHostName = networkMapClient?.myPublicHostname() if (retrievedHostName != null) { log.info("Retrieved public IP from Network Map Service: $this. This will be used instead of the provided \"$host\" as the advertised address.") } retrievedHostName } catch (ignore: Exception) { // Cannot reach the network map service, ignore the exception and use provided P2P address instead. log.warn("Cannot connect to the network map service for public IP detection.") null } } else { log.info("Detected public IP: ${foundPublicIP.hostAddress}. This will be used instead of the provided \"$host\" as the advertised address.") foundPublicIP.hostAddress } } else { null } } /** * If the node is persisting to an embedded H2 database, then expose this via TCP with a DB URL of the form: * jdbc:h2:tcp://<host>:<port>/node * with username and password as per the DataSource connection details. The key element to enabling this support is to * ensure that you specify a DB connection URL of the form jdbc:h2:file: in the node config and that you include * the H2 option AUTO_SERVER_PORT set to the port you desire to use (0 will give a dynamically allocated port number) * but exclude the H2 option AUTO_SERVER=TRUE. * This is not using the H2 "automatic mixed mode" directly but leans on many of the underpinnings. For more details * on H2 URLs and configuration see: http://www.h2database.com/html/features.html#database_url */ override fun startDatabase() { val databaseUrl = configuration.dataSourceProperties.getProperty("dataSource.url") val h2Prefix = "jdbc:h2:file:" if (databaseUrl != null && databaseUrl.startsWith(h2Prefix)) { val effectiveH2Settings = configuration.effectiveH2Settings //forbid execution of arbitrary code via SQL except those classes required by H2 itself System.setProperty("h2.allowedClasses", "org.h2.mvstore.db.MVTableEngine,org.locationtech.jts.geom.Geometry,org.h2.server.TcpServer") if (effectiveH2Settings?.address != null) { if (!InetAddress.getByName(effectiveH2Settings.address.host).isLoopbackAddress && configuration.dataSourceProperties.getProperty("dataSource.password").isBlank()) { throw CouldNotCreateDataSourceException("Database password is required for H2 server listening on ${InetAddress.getByName(effectiveH2Settings.address.host)}.") } val databaseName = databaseUrl.removePrefix(h2Prefix).substringBefore(';') val baseDir = Paths.get(databaseName).parent.toString() val server = org.h2.tools.Server.createTcpServer( "-tcpPort", effectiveH2Settings.address.port.toString(), "-tcpAllowOthers", "-tcpDaemon", "-baseDir", baseDir, "-key", "node", databaseName) // override interface that createTcpServer listens on (which is always 0.0.0.0) System.setProperty("h2.bindAddress", effectiveH2Settings.address.host) runOnStop += server::stop val url = try { server.start().url } catch (e: JdbcSQLException) { if (e.cause is BindException) { throw AddressBindingException(effectiveH2Settings.address) } else { throw e } } printBasicNodeInfo("Database connection url is", "jdbc:h2:$url/node") } } super.startDatabase() database.closeOnStop() } private val _startupComplete = openFuture<Unit>() val startupComplete: CordaFuture<Unit> get() = _startupComplete override fun generateAndSaveNodeInfo(): NodeInfo { initialiseSerialization() return super.generateAndSaveNodeInfo() } override fun start(): NodeInfo { registerDefaultExceptionHandler() initialiseSerialization() val nodeInfo: NodeInfo = super.start() nodeReadyFuture.thenMatch({ serverThread.execute { registerJmxReporter(services.monitoringService.metrics) _startupComplete.set(Unit) } }, { th -> staticLog.error("Unexpected exception", th) } // XXX: Why not use log? ) shutdownHook = addShutdownHook { stop() } return nodeInfo } /** * Register a default exception handler for all threads that terminates the process if the database connection goes away and * cannot be recovered. */ private fun registerDefaultExceptionHandler() { Thread.setDefaultUncaughtExceptionHandler(DbExceptionHandler(Thread.getDefaultUncaughtExceptionHandler())) } /** * A hook to allow configuration override of the JmxReporter being used. */ fun registerJmxReporter(metrics: MetricRegistry) { log.info("Registering JMX reporter:") when (configuration.jmxReporterType) { JmxReporterType.JOLOKIA -> registerJolokiaReporter(metrics) JmxReporterType.NEW_RELIC -> registerNewRelicReporter(metrics) } } private fun registerJolokiaReporter(registry: MetricRegistry) { log.info("Registering Jolokia JMX reporter:") // Begin exporting our own metrics via JMX. These can be monitored using any agent, e.g. Jolokia: // // https://jolokia.org/agent/jvm.html JmxReporter.forRegistry(registry).inDomain("net.corda").createsObjectNamesWith { _, domain, name -> // Make the JMX hierarchy a bit better organised. val category = name.substringBefore('.').substringBeforeLast('/') val component = name.substringBefore('.').substringAfterLast('/', "") val subName = name.substringAfter('.', "") (if (subName == "") ObjectName("$domain:name=$category${if (component.isNotEmpty()) ",component=$component," else ""}") else ObjectName("$domain:type=$category,${if (component.isNotEmpty()) "component=$component," else ""}name=$subName")) }.build().start() } private fun registerNewRelicReporter(registry: MetricRegistry) { log.info("Registering New Relic JMX Reporter:") val reporter = NewRelicReporter.forRegistry(registry) .name("New Relic Reporter") .filter(MetricFilter.ALL) .attributeFilter(AllEnabledMetricAttributeFilter()) .rateUnit(TimeUnit.SECONDS) .durationUnit(TimeUnit.MILLISECONDS) .metricNamePrefix("corda/") .build() reporter.start(1, TimeUnit.MINUTES) } override val rxIoScheduler: Scheduler get() = Schedulers.io() private fun initialiseSerialization() { if (!initialiseSerialization) return val classloader = cordappLoader.appClassLoader nodeSerializationEnv = SerializationEnvironment.with( SerializationFactoryImpl().apply { registerScheme(AMQPServerSerializationScheme(cordappLoader.cordapps, Caffeine.newBuilder().maximumSize(128).build<SerializationFactoryCacheKey, SerializerFactory>().asMap())) registerScheme(AMQPClientSerializationScheme(cordappLoader.cordapps, Caffeine.newBuilder().maximumSize(128).build<SerializationFactoryCacheKey, SerializerFactory>().asMap())) }, p2pContext = AMQP_P2P_CONTEXT.withClassLoader(classloader), rpcServerContext = AMQP_RPC_SERVER_CONTEXT.withClassLoader(classloader), rpcClientContext = if (configuration.shouldInitCrashShell()) AMQP_RPC_CLIENT_CONTEXT.withClassLoader(classloader) else null, //even Shell embeded in the node connects via RPC to the node storageContext = AMQP_STORAGE_CONTEXT.withClassLoader(classloader), checkpointSerializer = KryoCheckpointSerializer, checkpointContext = KRYO_CHECKPOINT_CONTEXT.withClassLoader(classloader) ) } /** Starts a blocking event loop for message dispatch. */ fun run() { internalRpcMessagingClient?.start(rpcBroker!!.serverControl) (network as P2PMessagingClient).run() } private var shutdown = false override fun stop() { check(!serverThread.isOnThread) synchronized(this) { if (shutdown) return shutdown = true // Unregister shutdown hook to prevent any unnecessary second calls to stop shutdownHook?.cancel() shutdownHook = null } printBasicNodeInfo("Shutting down ...") // All the Node started subsystems were registered with the runOnStop list at creation. // So now simply call the parent to stop everything in reverse order. // In particular this prevents premature shutdown of the Database by AbstractNode whilst the serverThread is active super.stop() shutdown = false log.info("Shutdown complete") } fun <T : FlowLogic<*>> registerInitiatedFlow(smm: StateMachineManager, initiatedFlowClass: Class<T>) { this.flowManager.registerInitiatedFlow(initiatedFlowClass) } } MaxLineLength:Node.kt$Node.Companion$println("You are using a version of Java that is not supported (${SystemUtils.JAVA_VERSION}). Please upgrade to the latest version of Java 8.") - MaxLineLength:Node.kt$Node.Companion${ val update = getJavaUpdateVersion(SystemUtils.JAVA_VERSION) // To filter out cases like 1.8.0_202-ea major == 1.8F && update >= 171 } - MaxLineLength:Node.kt$NodeWithInfo$fun <T : FlowLogic<*>> registerInitiatedFlow(initiatedFlowClass: Class<T>) MaxLineLength:Node.kt$NodeWithInfo$val services: StartedNodeServices = object : StartedNodeServices, ServiceHubInternal by node.services, FlowStarter by node.flowStarter {} MaxLineLength:NodeAdder.kt$NodeAdder$val newInstanceX500 = x500ToAdd?.toString() ?: nodeInfo.groupX500!!.copy(commonName = nodeInfo.groupX500.commonName + (currentNodeSize)).toString() MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$/** * This caches contract attachment versions by contract class name. For each version, we support one signed and one unsigned attachment, since that is allowed. * * It is correctly invalidated as new attachments are uploaded. */ private val contractsCache = InfrequentlyMutatedCache<ContractClassName, NavigableMap<Version, AttachmentIds>>("NodeAttachmentService_contractAttachmentVersions", cacheFactory) - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$AttachmentSort.AttachmentSortColumn(AttachmentSort.AttachmentSortAttribute.INSERTION_DATE, Sort.Direction.DESC) MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$ContractAttachment - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$HashCheckingStream : FilterInputStream MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$HashMismatchException : CordaRuntimeException MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$log.warn("(Dev Mode) Multiple signed attachments ${signed.map { it.toString() }} for contract $contractClassName version '${it.key}'.") MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$log.warn("Selecting attachment ${unsigned.first()} from duplicated, unsigned attachments ${unsigned.map { it.toString() }} for contract $contractClassName version '${it.key}'.") MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$log.warn("Several versions based on whitelistedContractImplementations position are available: ${versions.toSet()}. $msg") MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$private - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$require(inputStream !is JarInputStream) { "Input stream must not be a JarInputStream" } // Read the file into RAM and then calculate its hash. The attachment must fit into memory. // TODO: Switch to a two-phase insert so we can handle attachments larger than RAM. // To do this we must pipe stream into the database without knowing its hash, which we will learn only once // the insert/upload is complete. We can then query to see if it's a duplicate and if so, erase, and if not // set the hash field of the new attachment record. val bytes = inputStream.readFully() val id = bytes.sha256() if (!hasAttachment(id)) { checkIsAValidJAR(bytes.inputStream()) val jarSigners = getSigners(bytes) val contractVersion = increaseDefaultVersionIfWhitelistedAttachment(contractClassNames, getVersion(bytes), id) val session = currentDBSession() if (!devMode) verifyVersionUniquenessForSignedAttachments(contractClassNames, contractVersion, jarSigners) val attachment = NodeAttachmentService.DBAttachment( attId = id.toString(), content = bytes, uploader = uploader, filename = filename, contractClassNames = contractClassNames, signers = jarSigners, version = contractVersion ) session.save(attachment) attachmentCount.inc() log.info("Stored new attachment: id=$id uploader=$uploader filename=$filename") contractClassNames.forEach { contractsCache.invalidate(it) } return@withContractsInJar id } if (isUploaderTrusted(uploader)) { val session = currentDBSession() val attachment = session.get(NodeAttachmentService.DBAttachment::class.java, id.toString()) // update the `uploader` field (as the existing attachment may have been resolved from a peer) if (attachment.uploader != uploader) { if (!devMode) verifyVersionUniquenessForSignedAttachments(contractClassNames, attachment.version, attachment.signers) attachment.uploader = uploader log.info("Updated attachment $id with uploader $uploader") contractClassNames.forEach { contractsCache.invalidate(it) } loadAttachmentContent(id)?.let { attachmentAndContent -> // TODO: this is racey. ENT-2870 attachmentContentCache.put(id, Optional.of(attachmentAndContent)) attachmentCache.put(id, Optional.of(attachmentAndContent.first)) } return@withContractsInJar id } // If the uploader is the same, throw the exception because the attachment cannot be overridden by the same uploader. } throw DuplicateAttachmentException(id.toString()) - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$throw DuplicateContractClassException(it, contractVersion, existingContractsImplementations.map { it.toString() }) - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$val attachmentImpl = AttachmentImpl(id, { attachment.content }, checkAttachmentsOnLoad, attachment.uploader).let { val contracts = attachment.contractClassNames if (contracts != null && contracts.isNotEmpty()) { ContractAttachment.create(it, contracts.first(), contracts.drop(1).toSet(), attachment.uploader, attachment.signers?.toList() ?: emptyList(), attachment.version) } else { it } } MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$val attachmentQueryCriteria = AttachmentQueryCriteria.AttachmentsQueryCriteria(contractClassNamesCondition = Builder.equal(listOf(name)), versionCondition = Builder.greaterThanOrEqual(0), uploaderCondition = Builder.`in`(TRUSTED_UPLOADERS)) MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$val attachmentSort = AttachmentSort(listOf(AttachmentSort.AttachmentSortColumn(AttachmentSort.AttachmentSortAttribute.VERSION, Sort.Direction.DESC), AttachmentSort.AttachmentSortColumn(AttachmentSort.AttachmentSortAttribute.INSERTION_DATE, Sort.Direction.DESC))) - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$val contractVersion = increaseDefaultVersionIfWhitelistedAttachment(contractClassNames, getVersion(bytes), id) - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$val existingContractsImplementations = queryAttachments(AttachmentQueryCriteria.AttachmentsQueryCriteria( contractClassNamesCondition = Builder.equal(listOf(it)), versionCondition = Builder.equal(contractVersion), uploaderCondition = Builder.`in`(TRUSTED_UPLOADERS), isSignedCondition = Builder.equal(true)) ) MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$val versions = contractClassNames.mapNotNull { servicesForResolution.networkParameters.whitelistedContractImplementations[it]?.indexOf(attachmentId) } .filter { it >= 0 }.map { it + 1 } // +1 as versions starts from 1 not 0 - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$verifyVersionUniquenessForSignedAttachments(contractClassNames, attachment.version, attachment.signers) MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService$weigher = Weigher<SecureHash, Optional<Pair<Attachment, ByteArray>>> { key, value -> key.size + if (value.isPresent) value.get().second.size else 0 } - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService${ val session = currentDBSession() val attachment = session.get(NodeAttachmentService.DBAttachment::class.java, id.toString()) // update the `uploader` field (as the existing attachment may have been resolved from a peer) if (attachment.uploader != uploader) { if (!devMode) verifyVersionUniquenessForSignedAttachments(contractClassNames, attachment.version, attachment.signers) attachment.uploader = uploader log.info("Updated attachment $id with uploader $uploader") contractClassNames.forEach { contractsCache.invalidate(it) } loadAttachmentContent(id)?.let { attachmentAndContent -> // TODO: this is racey. ENT-2870 attachmentContentCache.put(id, Optional.of(attachmentAndContent)) attachmentCache.put(id, Optional.of(attachmentAndContent.first)) } return@withContractsInJar id } // If the uploader is the same, throw the exception because the attachment cannot be overridden by the same uploader. } MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.AttachmentImpl$private - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.AttachmentImpl$return if (checkOnLoad && id is SecureHash.SHA256) HashCheckingStream(id, attachmentData.size, stream) else stream MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.AttachmentImpl.Token$override fun fromToken(context: SerializeAsTokenContext) MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.AttachmentImpl.Token$private - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.Companion$// Just iterate over the entries with verification enabled: should be good enough to catch mistakes. // Note that JarInputStream won't throw any kind of error at all if the file stream is in fact not // a ZIP! It'll just pretend it's an empty archive, which is kind of stupid but that's how it works. // So we have to check to ensure we found at least one item. // // For signed Jars add additional checks to close security holes left by the default jarSigner verifier: // - All entries listed in the Manifest are in the JAR file. // - No extra files in the JAR that were not listed in the Manifest. // Together with the check that all entries need to be signed by the same signers that is performed when the signers are read, // it should close any possibility of foul play. internal fun checkIsAValidJAR(stream: InputStream) - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.Companion$if (manifestHasEntries && !allManifestEntries!!.remove(cursor.name)) extraFilesNotFoundInEntries.add(cursor) - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.Companion$private val PRIVILEGED_UPLOADERS = listOf(DEPLOYED_CORDAPP_UPLOADER, RPC_UPLOADER, P2P_UPLOADER, UNKNOWN_UPLOADER) - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.Companion$require(!('\\' in cursor.name || cursor.name == "." || cursor.name == "..")) { "Bad character in $entryPath" } - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.Companion$throw SecurityException("Signed jar has been tampered with. Files ${allManifestEntries} have been removed.") - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.Companion$throw SecurityException("Signed jar has been tampered with. Files ${extraSignableFiles} have been added to the JAR.") - MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.Companion$val extraSignableFiles = extraFilesNotFoundInEntries.filterNot { JarSignatureCollector.isNotSignable(it) } MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.DBAttachment$( @Id @Column(name = "att_id", nullable = false) var attId: String, @Column(name = "content", nullable = false) @Lob var content: ByteArray, @Column(name = "insertion_date", nullable = false, updatable = false) var insertionDate: Instant = Instant.now(), @Column(name = "uploader", nullable = true) var uploader: String? = null, @Column(name = "filename", updatable = false, nullable = true) var filename: String? = null, @ElementCollection @Column(name = "contract_class_name", nullable = false) @CollectionTable(name = "${NODE_DATABASE_PREFIX}attachments_contracts", joinColumns = [(JoinColumn(name = "att_id", referencedColumnName = "att_id"))], foreignKey = ForeignKey(name = "FK__ctr_class__attachments")) var contractClassNames: List<ContractClassName>? = null, @ElementCollection(targetClass = PublicKey::class, fetch = FetchType.EAGER) @Column(name = "signer", nullable = false) @CollectionTable(name = "${NODE_DATABASE_PREFIX}attachments_signers", joinColumns = [(JoinColumn(name = "att_id", referencedColumnName = "att_id"))], foreignKey = ForeignKey(name = "FK__signers__attachments")) var signers: List<PublicKey>? = null, // Assumption: only Contract Attachments are versioned, version unknown or value for other attachments other than Contract Attachment defaults to 1 @Column(name = "version", nullable = false) var version: Int = DEFAULT_CORDAPP_VERSION ) MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.DBAttachment$@CollectionTable(name = "${NODE_DATABASE_PREFIX}attachments_contracts", joinColumns = [(JoinColumn(name = "att_id", referencedColumnName = "att_id"))], foreignKey = ForeignKey(name = "FK__ctr_class__attachments")) MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.DBAttachment$@CollectionTable(name = "${NODE_DATABASE_PREFIX}attachments_signers", joinColumns = [(JoinColumn(name = "att_id", referencedColumnName = "att_id"))], foreignKey = ForeignKey(name = "FK__signers__attachments")) MaxLineLength:NodeAttachmentService.kt$NodeAttachmentService.HashCheckingStream$private val stream: HashingInputStream = HashingInputStream(Hashing.sha256(), counter) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$(uploaderCondition("complexB").and(filenamerCondition("archiveB.zip"))).or(filenamerCondition("archiveC.zip")) MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `The strict JAR verification function fails signed JARs with removed or extra files that are valid according to the usual jarsigner`() - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `can import duplicated contract class and version from siged attachment if an unsigned attachment already exists`() - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `can import duplicated contract class and version from unsiged attachment if a signed attachment already exists`() - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `can import jar with duplicated contract class, version and signers - when one uploader is trusted and other isnt`() - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `cannot promote to trusted uploader if other trusted attachment already has duplicated contract class, version and signers`() - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$@Test fun `development mode - retrieve latest versions of signed contracts - multiple versions of same version id exist in store`() - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$AttachmentSort(listOf(AttachmentSort.AttachmentSortColumn(AttachmentSort.AttachmentSortAttribute.VERSION))) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$assertEquals(listOf(jarAndSigner.second.hash), storage.openAttachment(attachmentId)!!.signerKeys.map { it.hash }) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$assertThat((storage.openAttachment(expectedAttachmentId) as ContractAttachment).uploader).isEqualTo(initialUploader) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$assertThat((storage.openAttachment(expectedAttachmentId) as ContractAttachment).uploader).isEqualTo(trustedUploader) MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$assertThatThrownBy { attachment.read { storage.privilegedImportAttachment(it, untrustedUploader, null) } }.isInstanceOf(DuplicateAttachmentException::class.java) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$contractClassNamesCondition = Builder.equal(listOf("com.example.MyContract", "com.example.AnotherContract")) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$contractJarV2.read { attachmentIdV2Unsigned = storage.privilegedImportAttachment(it, "app", "contract-V2.jar") } MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$fun filenameSort(direction: Sort.Direction) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$signedContractJar.read { attachmentIdV1Signed = storage.privilegedImportAttachment(it, "app", "contract-signed.jar") } MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$signedContractJarSameVersion.read { attachmentIdSameVersionLatest = devModeStorage.privilegedImportAttachment(it, "app", "contract-signed-same-version.jar") } - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$signedContractJarV2.read { attachmentIdV2Signed = storage.privilegedImportAttachment(it, "app", "contract-signed-V2.jar") } MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$storage.queryAttachments(AttachmentsQueryCriteria(contractClassNamesCondition = Builder.equal(listOf("com.example.MyContract")))).size - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$storage.queryAttachments(AttachmentsQueryCriteria(signersCondition = Builder.equal(listOf(publicKey)))).size MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$val (signedContractJarSameVersion, _) = makeTestSignedContractJar(file.path,"com.example.MyContract", versionSeed = Random().nextInt()) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$val anotherAttachmentId = anotherContractJar.read { storage.privilegedImportAttachment(it, "app", "another-sample.jar") } MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$val anotherContractJar = makeTestContractJar(file.path, listOf( "com.example.MyContract", "com.example.AnotherContract"), generateManifest = false, jarFileName = "another-sample.jar") MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$val anotherContractJar = makeTestContractJar(file.path, listOf( "com.example.MyContract", "com.example.AnotherContract"), true, generateManifest = false, jarFileName = "another-sample.jar") MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$val attachments = storage.queryAttachments(AttachmentsQueryCriteria(contractClassNamesCondition = Builder.equal(listOf("com.example.MyContract")))) MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$val corruptAttachment = NodeAttachmentService.DBAttachment(attId = id.toString(), content = bytes, version = DEFAULT_CORDAPP_VERSION) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$val overriddenAttachmentId = attachment.read { storage.privilegedImportAttachment(it, trustedUploader, null) } - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$val reimportedAttachmentId = contractJar.read { storage.privilegedImportAttachment(it, "app", "sample.jar") } - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$val signedAttachments = storage.queryAttachments(AttachmentsQueryCriteria(isSignedCondition = Builder.equal(true))) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest$val unsignedAttachments = storage.queryAttachments(AttachmentsQueryCriteria(isSignedCondition = Builder.equal(false))) - MaxLineLength:NodeAttachmentServiceTest.kt$NodeAttachmentServiceTest.FetchAttachmentsFlow$serviceHub.attachments.importAttachment(baos.toByteArray().inputStream(), "$P2P_UPLOADER:${ourIdentity.name}", null) MaxLineLength:NodeBasedTest.kt$InProcessNode : Node MaxLineLength:NodeBasedTest.kt$InProcessNode$assertFalse(isInvalidJavaVersion(), "You are using a version of Java that is not supported (${SystemUtils.JAVA_VERSION}). Please upgrade to the latest version of Java 8.") - MaxLineLength:NodeBasedTest.kt$NodeBasedTest - MaxLineLength:NodeBasedTest.kt$NodeBasedTest$@JvmOverloads constructor(private val cordappPackages: List<String> = emptyList(), private val notaries: List<CordaX500Name> = emptyList()) - MaxLineLength:NodeBasedTest.kt$NodeBasedTest$val customCordapps = cordappsForPackages(getCallerPackage(NodeBasedTest::class)?.let { cordappPackages + it } ?: cordappPackages) - MaxLineLength:NodeBasedTest.kt$NodeBasedTest$val node = InProcessNode(parsedConfig, MOCK_VERSION_INFO.copy(platformVersion = platformVersion), flowManager = flowManager) - MaxLineLength:NodeBuilder.kt$NodeBuilder$localDockerClient.buildImageCmd() .withDockerfile(File(nodeDir, "Dockerfile")) .withBaseDirectory(nodeDir) MaxLineLength:NodeBuilder.kt$NodeBuilder.<no name provided>$future.completeExceptionally(IllegalStateException("Could not build image for: $nodeDir, reason: ${result?.errorDetail}")) - MaxLineLength:NodeBuilder.kt$NodeBuilder.<no name provided>$val config = nodeConfig.parseAsNodeConfigWithFallback(ConfigFactory.parseFile(copiedNode.configFile)).value() - MaxLineLength:NodeBuilder.kt$fun Config.parseAsNodeConfigWithFallback(preCopyConfig: Config): Validated<NodeConfiguration, Configuration.Validation.Error> - MaxLineLength:NodeCmdLineOptions.kt$InitialRegistrationCmdLineOptions$"Cannot perform initial registration when 'devMode' is true, unless 'devModeOptions.allowCompatibilityZone' is also true." - MaxLineLength:NodeCmdLineOptions.kt$InitialRegistrationCmdLineOptions$"compatibilityZoneURL or networkServices must be present in the node configuration file in registration mode." - MaxLineLength:NodeCmdLineOptions.kt$NodeCmdLineOptions$"compatibilityZoneURL or networkServices must be present in the node configuration file in registration mode." - MaxLineLength:NodeCmdLineOptions.kt$NodeCmdLineOptions$description = ["DEPRECATED. Clears local copy of network map, on node startup it will be restored from server or file system."] MaxLineLength:NodeCmdLineOptions.kt$NodeCmdLineOptions$description = ["DEPRECATED. Performs the node start-up tasks necessary to generate the nodeInfo file, saves it to disk, then exits."] MaxLineLength:NodeCmdLineOptions.kt$NodeCmdLineOptions$description = ["DEPRECATED. Starts initial node registration with Corda network to obtain certificate from the permissioning server."] - MaxLineLength:NodeCmdLineOptions.kt$NodeCmdLineOptions$valid(ConfigHelper.loadConfig(baseDirectory, configFile, configOverrides = ConfigFactory.parseMap(configOverrides))) - MaxLineLength:NodeConfig.kt$NodeConfig$@VisibleForTesting internal MaxLineLength:NodeConfig.kt$NodeConfig$return NodeConfigurationData(myLegalName, p2pAddress, this.rpcSettings.address, notary, h2port, rpcUsers, useTestClock, detectPublicIp, devMode) .toConfig() .withoutPath("rpcAddress") .withoutPath("rpcAdminAddress") .withValue("rpcSettings", rpcSettings) - MaxLineLength:NodeConfiguration.kt$CertChainPolicyConfig$@Deprecated("Do not use") data MaxLineLength:NodeConfiguration.kt$DevModeOptions$data - MaxLineLength:NodeConfiguration.kt$NetworkParameterAcceptanceSettings - MaxLineLength:NodeConfiguration.kt$NodeConfiguration$@Deprecated(message = "Use of single compatibility zone URL is deprecated", replaceWith = ReplaceWith("networkServices.networkMapURL")) - MaxLineLength:NodeConfiguration.kt$NodeConfiguration$val flowMonitorSuspensionLoggingThresholdMillis: Duration get() = DEFAULT_FLOW_MONITOR_SUSPENSION_LOGGING_THRESHOLD_MILLIS MaxLineLength:NodeConfiguration.kt$SecurityConfiguration.AuthService.DataSource$AuthDataSourceType.DB -> require(users == null && connection != null) { "Database-backed authentication must not specify a user list, and must configure a database" } MaxLineLength:NodeConfiguration.kt$SecurityConfiguration.AuthService.DataSource$AuthDataSourceType.INMEMORY -> require(users != null && connection == null) { "In-memory authentication must specify a user list, and must not configure a database" } MaxLineLength:NodeConfiguration.kt$fun Config.parseAsNodeConfiguration(options: Configuration.Validation.Options = Configuration.Validation.Options(strict = true)): Valid<NodeConfiguration> MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$// TODO: There are two implications here: // 1. "signingCertificateStore" and "p2pKeyStore" have the same passwords. In the future we should re-visit this "rule" and see of they can be made different; // 2. The passwords for store and for keys in this store are the same, this is due to limitations of Artemis. override val signingCertificateStore = FileBasedCertificateStoreSupplier(signingCertificateStorePath, keyStorePassword, keyStorePassword) - MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$@Suppress("DEPRECATION") @Deprecated("Do not configure") override MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$logger - MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$logger.warn("Top-level declaration of property 'rpcAddress' is deprecated. Please use 'rpcSettings.address' instead.") MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$override - MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$override val flowMonitorSuspensionLoggingThresholdMillis: Duration = Defaults.flowMonitorSuspensionLoggingThresholdMillis - MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$override val networkParameterAcceptanceSettings: NetworkParameterAcceptanceSettings = Defaults.networkParameterAcceptanceSettings - MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$private val p2pTrustStore = FileBasedCertificateStoreSupplier(p2pTrustStoreFilePath, trustStorePassword, trustStorePassword) - MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$require(h2port == null || h2Settings == null) { "Cannot specify both 'h2port' and 'h2Settings' in configuration" } MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$require(rpcSettings.address == null) { "Can't provide top-level rpcAddress and rpcSettings.address (they control the same property)." } MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$return listOf("cannot specify 'compatibilityZoneURL' when 'devMode' is true, unless 'devModeOptions.allowCompatibilityZone' is also true") MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl$return listOf("cannot specify 'networkServices' when 'devMode' is true, unless 'devModeOptions.allowCompatibilityZone' is also true") - MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl.Defaults$initialiseAppSchema = if(devMode) SchemaInitializationType.UPDATE else SchemaInitializationType.VALIDATE MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl.Defaults$val flowMonitorSuspensionLoggingThresholdMillis: Duration = NodeConfiguration.DEFAULT_FLOW_MONITOR_SUSPENSION_LOGGING_THRESHOLD_MILLIS - MaxLineLength:NodeConfigurationImpl.kt$NodeConfigurationImpl.Defaults$val networkParameterAcceptanceSettings: NetworkParameterAcceptanceSettings = NetworkParameterAcceptanceSettings() MaxLineLength:NodeConfigurationImpl.kt$NodeRpcSettings.<no name provided>$return "address: $address, adminAddress: $adminAddress, standAloneBroker: $standAloneBroker, useSsl: $useSsl, sslConfig: $sslConfig" - MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$@Test fun `validation succeeds when compatibilityZoneURL is present and devMode is true and allowCompatibilityZoneURL is set`() MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertFalse(getConfig("test-config-DevMode.conf", ConfigFactory.parseMap(mapOf("devMode" to false))).getBooleanCaseInsensitive("devMode")) MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertFalse(getConfig("test-config-empty.conf", ConfigFactory.parseMap(mapOf("devMode" to false))).getBooleanCaseInsensitive("devMode")) MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertFalse(getConfig("test-config-noDevMode.conf", ConfigFactory.parseMap(mapOf("devMode" to false))).getBooleanCaseInsensitive("devMode")) MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertThat(config.errors.asSequence().map(Configuration.Validation.Error::message).filter { it.contains("rpcSettings.adminAddress") }.toList()).isNotEmpty - MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertThat(errors).hasOnlyOneElementSatisfying { error -> error.contains("compatibilityZoneURL") && error.contains("devMode") } - MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertThat(errors).hasOnlyOneElementSatisfying { error -> error.contains("networkServices") && error.contains("devMode") } MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertThat(rawConfig.parseAsNodeConfiguration().errors.single()) - MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertThatThrownBy { configDebugOptions(false, debugOptions) }.hasMessageMatching("Cannot use devModeOptions outside of dev mode") MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertTrue(getConfig("test-config-DevMode.conf", ConfigFactory.parseMap(mapOf("devMode" to true))).getBooleanCaseInsensitive("devMode")) MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertTrue(getConfig("test-config-empty.conf", ConfigFactory.parseMap(mapOf("devMode" to true))).getBooleanCaseInsensitive("devMode")) MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$assertTrue(getConfig("test-config-noDevMode.conf", ConfigFactory.parseMap(mapOf("devMode" to true))).getBooleanCaseInsensitive("devMode")) MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$private MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$return testConfiguration.copy(tlsCertCrlDistPoint = tlsCertCrlDistPoint, tlsCertCrlIssuer = tlsCertCrlIssuer?.let { X500Principal(it) }, crlCheckSoftFail = crlCheckSoftFail) MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$val configValidationResult = configTlsCertCrlOptions(null, "C=US, L=New York, OU=Corda, O=R3 HoldCo LLC, CN=Corda Root CA").validate() - MaxLineLength:NodeConfigurationImplTest.kt$NodeConfigurationImplTest$var rawConfig = ConfigFactory.parseResources("working-config.conf", ConfigParseOptions.defaults().setAllowMissing(false)) MaxLineLength:NodeConnection.kt$NodeConnection : Closeable - MaxLineLength:NodeConnection.kt$NodeConnection$fun clearDb() MaxLineLength:NodeConnection.kt$NodeConnection$return runShellCommandGetOutput("sudo netstat -tlpn | grep ${remoteNode.rpcPort} | awk '{print $7}' | grep -oE '[0-9]+'").getResultOrThrow().replace("\n", "") - MaxLineLength:NodeConnection.kt$NodeConnection$runShellCommandGetOutput("until sudo netstat -tlpn | grep ${remoteNode.rpcPort} > /dev/null ; do sleep 1 ; done") - MaxLineLength:NodeConnection.kt$NodeConnection$val proxy: CordaRPCOps get() = rpcConnection?.proxy ?: throw IllegalStateException("proxy requested, but the client is not running") - MaxLineLength:NodeConnection.kt$NodeConnection.ShellCommandOutput$data MaxLineLength:NodeController.kt$NodeController$(cordappConfigDir / "${CordappController.FINANCE_WORKFLOWS_CORDAPP_FILENAME}.conf").writeText(config.nodeConfig.toFinanceConfText()) - MaxLineLength:NodeController.kt$NodeController$issuableCurrencies = nodeData.extraServices.filterIsInstance<CurrencyIssuer>().map { it.currency.toString() } - MaxLineLength:NodeController.kt$NodeController$require((config.nodeConfig.notary != null).xor(notaryIdentity != null)) { "There must be exactly one notary in the network" } MaxLineLength:NodeController.kt$NodeController$val nextPort = 1 + arrayOf(config.p2pAddress.port, config.rpcSettings.address.port, config.webAddress.port, config.h2port).max() as Int - MaxLineLength:NodeData.kt$SuggestedDetails$( // Mike: Rome? Why Rome? // Roger: Notaries public (also called "notaries", "notarial officers", or "public notaries") hold an office // which can trace its origins back to the ancient Roman Republic, when they were called scribae ("scribes"), // tabelliones forenses, or personae publicae.[4] // Mike: Can't argue with that. It's even got a citation. "Notary" to "Rome", "Bank of Breakfast Tea" to "Liverpool", "Bank of Big Apples" to "New York", "Bank of Baguettes" to "Paris", "Bank of Fondue" to "Geneve", "Bank of Maple Syrup" to "Toronto", "Bank of Golden Gates" to "San Francisco" ) MaxLineLength:NodeFlowManagerTest.kt$NodeFlowManagerTest$val nodeFlowManager = NodeFlowManager(FlowOverrideConfig(listOf(FlowOverride(Init::class.qualifiedName!!, Resp::class.qualifiedName!!)))) - MaxLineLength:NodeInfo.kt$NodeInfo - MaxLineLength:NodeInfoFilesCopier.kt$NodeInfoFilesCopier$atomicCopy(previouslySeenFile, newNodeFile.additionalNodeInfoDirectory.resolve(previouslySeenFile.fileName)) - MaxLineLength:NodeInfoFilesCopier.kt$NodeInfoFilesCopier$for (destination in this.values.filter { it.nodeDir != nodeData.nodeDir }.map { it.additionalNodeInfoDirectory }) { val fullDestinationPath = destination.resolve(path.fileName) atomicCopy(path, fullDestinationPath) } - MaxLineLength:NodeInfoFilesCopier.kt$NodeInfoFilesCopier$private fun allPreviouslySeenFiles() MaxLineLength:NodeInfoSchema.kt$NodeInfoSchemaV1$mappedTypes = listOf(PersistentNodeInfo::class.java, DBPartyAndCertificate::class.java, DBHostAndPort::class.java, NodePropertiesPersistentStore.DBNodeProperty::class.java) - MaxLineLength:NodeInfoSchema.kt$NodeInfoSchemaV1.DBPartyAndCertificate$@ManyToMany(mappedBy = "legalIdentitiesAndCerts", cascade = [(CascadeType.ALL)]) MaxLineLength:NodeInfoSchema.kt$NodeInfoSchemaV1.PersistentNodeInfo$(this.legalIdentitiesAndCerts.filter { it.isMain } + this.legalIdentitiesAndCerts.filter { !it.isMain }).map { it.toLegalIdentityAndCert() } - MaxLineLength:NodeInfoSchema.kt$NodeInfoSchemaV1.PersistentNodeInfo$inverseJoinColumns = [(JoinColumn(name = "party_name", foreignKey = ForeignKey(name = "FK__link_ni_p__info_p_cert")))] - MaxLineLength:NodeInfoSchema.kt$NodeInfoSchemaV1.PersistentNodeInfo$joinColumns = [(JoinColumn(name = "node_info_id", foreignKey = ForeignKey(name = "FK__link_nodeinfo_party__infos")))] - MaxLineLength:NodeInfoWatcher.kt$NodeInfoWatcher$ fun nodeInfoUpdates(): Observable<List<NodeInfoUpdate>> - MaxLineLength:NodeInfoWatcher.kt$NodeInfoWatcher$nodeInfoFilesMap[file] = NodeInfoFromFile(nodeInfoSigned.signed.raw.hash, file.lastModifiedTime()) - MaxLineLength:NodeInfoWatcher.kt$NodeInfoWatcher$val newOrChangedFile = previousLastModifiedTime == null || lastModifiedTime > previousLastModifiedTime - MaxLineLength:NodeInfoWatcher.kt$NodeInfoWatcher.Companion${ // By using the hash of the node's first name we ensure: // 1) node info files for the same node map to the same filename and thus avoid having duplicate files for // the same node // 2) avoid having to deal with characters in the X.500 name which are incompatible with the local filesystem val fileNameHash = nodeInfoAndSigned.nodeInfo.legalIdentities[0].name.serialize().hash nodeInfoAndSigned .signed .serialize() .open() .copyTo(path / "${NodeInfoFilesCopier.NODE_INFO_FILE_NAME_PREFIX}$fileNameHash", REPLACE_EXISTING) } - MaxLineLength:NodeInfoWatcherTest.kt$NodeInfoWatcherTest$val nodeInfoFiles = tempFolder.root.list().filter { it.startsWith(NodeInfoFilesCopier.NODE_INFO_FILE_NAME_PREFIX) } - MaxLineLength:NodeInstanceRequest.kt$NodeInstanceRequest$localImageId MaxLineLength:NodeInstanceRequest.kt$NodeInstanceRequest$return "NodeInstanceRequest(nodeInstanceName='$nodeInstanceName', actualX500='$actualX500', expectedFqName='$expectedFqName') ${super.toString()}" - MaxLineLength:NodeInstantiator.kt$NodeInstantiator$return instantiateNodeInstance(request.remoteImageName, request.instanceName, request.fqdn, request.instanceX500).thenApplyAsync { InstanceInfo(request.groupName, request.instanceName, request.fqdn, it.first, it.second) } - MaxLineLength:NodeInstantiator.kt$NodeInstantiator$return instantiateNodeInstance(request.remoteImageName, request.nodeInstanceName, request.expectedFqName, request.actualX500) .thenApplyAsync { (reachableName, portMapping) -> request.toNodeInstance(reachableName, portMapping) } - MaxLineLength:NodeInterestRates.kt$NodeInterestRates.Oracle$// TODO There is security problem with that. What if transaction contains several commands of the same type, but // Oracle gets signing request for only some of them with a valid partial tree? We sign over a whole transaction. // It will be fixed by adding partial signatures later. // DOCSTART 1 fun sign(ftx: FilteredTransaction): TransactionSignature MaxLineLength:NodeInterestRates.kt$NodeInterestRates.Oracle$knownFixes = parseFile(IOUtils.toString(this::class.java.classLoader.getResourceAsStream("net/corda/irs/simulation/example.rates.txt"), Charsets.UTF_8.name())) - MaxLineLength:NodeInterestRatesTest.kt$NodeInterestRatesTest$TransactionState(1000.DOLLARS.CASH issuedBy dummyCashIssuer.party ownedBy ALICE, Cash.PROGRAM_ID, DUMMY_NOTARY) MaxLineLength:NodeInterestRatesTest.kt$NodeInterestRatesTest$assertFailsWith<IllegalArgumentException> { oracle.sign(ftx) } - MaxLineLength:NodeInterestRatesTest.kt$NodeInterestRatesTest$private val services = MockServices(listOf("net.corda.finance.contracts.asset"), dummyCashIssuer, rigorousMock(), MEGA_CORP_KEY) MaxLineLength:NodeKeystoreCheckTest.kt$NodeKeystoreCheckTest$setPrivateKey(X509Utilities.CORDA_CLIENT_CA, nodeCA.keyPair.private, listOf(badNodeCACert, badRoot), signingCertStore.entryPassword) MaxLineLength:NodeKeystoreCheckTest.kt$NodeKeystoreCheckTest$val badNodeCACert = X509Utilities.createCertificate(CertificateType.NODE_CA, badRoot, badRootKeyPair, ALICE_NAME.x500Principal, nodeCA.keyPair.public) - MaxLineLength:NodeKeystoreCheckTest.kt$NodeKeystoreCheckTest$val badRoot = X509Utilities.createSelfSignedCACertificate(X500Principal("O=Bad Root,L=Lodnon,C=GB"), badRootKeyPair) MaxLineLength:NodeKeystoreCheckTest.kt$NodeKeystoreCheckTest$val p2pSslConfig = CertificateStoreStubs.P2P.withCertificatesDirectory(certificatesDirectory, keyStorePassword = keystorePassword, trustStorePassword = keystorePassword) - MaxLineLength:NodeKeystoreCheckTest.kt$NodeKeystoreCheckTest$val signingCertStore = CertificateStoreStubs.Signing.withCertificatesDirectory(certificatesDirectory, keystorePassword) - MaxLineLength:NodeMonitorModel.kt$NodeMonitorModel$// Terminate subscription such that nothing gets past this point to downstream Observables. retryableStateMachineUpdatesSubscription.get()?.unsubscribe() // Flag to everyone that proxy is no longer available. runLaterIfInitialized { proxyObservable.set(null) } // It is good idea to close connection to properly mark the end of it. During re-connect we will create a new // client and a new connection, so no going back to this one. Also the server might be down, so we are // force closing the connection to avoid propagation of notification to the server side. rpcConnection?.forceClose() // Perform re-connect. performRpcReconnect(nodeHostAndPort, username, password, shouldRetry = true) - MaxLineLength:NodeMonitorModel.kt$NodeMonitorModel$futureProgressTrackerUpdates.startWith(currentProgressTrackerUpdates).flatMap { it }.retry().subscribe(progressTrackingSubject) MaxLineLength:NodeMonitorModel.kt$NodeMonitorModel$private MaxLineLength:NodeMonitorModel.kt$NodeMonitorModel$val (statesSnapshot, vaultUpdates) = proxy.vaultTrackBy<ContractState>(QueryCriteria.VaultQueryCriteria(Vault.StateStatus.ALL), PageSpecification(DEFAULT_PAGE_NUM, MAX_PAGE_SIZE)) - MaxLineLength:NodeMonitorModel.kt$NodeMonitorModel$val stateMachineTransactionMapping: Observable<StateMachineTransactionMapping> = stateMachineTransactionMappingSubject MaxLineLength:NodeMonitorModel.kt$NodeMonitorModel${ // `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) { val proxy = wrapper.cordaRPCOps // Vault snapshot (force single page load with MAX_PAGE_SIZE) + updates val (statesSnapshot, vaultUpdates) = proxy.vaultTrackBy<ContractState>(QueryCriteria.VaultQueryCriteria(Vault.StateStatus.ALL), PageSpecification(DEFAULT_PAGE_NUM, MAX_PAGE_SIZE)) val unconsumedStates = statesSnapshot.states.filterIndexed { index, _ -> statesSnapshot.statesMetadata[index].status == Vault.StateStatus.UNCONSUMED }.toSet() val consumedStates = statesSnapshot.states.toSet() - unconsumedStates val initialVaultUpdate = Vault.Update(consumedStates, unconsumedStates, references = emptySet()) vaultUpdates.startWith(initialVaultUpdate).subscribe(vaultUpdatesSubject::onNext, {}) // Transactions val (transactions, newTransactions) = proxy.internalVerifiedTransactionsFeed() newTransactions.startWith(transactions).subscribe(transactionsSubject::onNext, {}) // SM -> TX mapping val (smTxMappings, futureSmTxMappings) = proxy.stateMachineRecordedTransactionMappingFeed() futureSmTxMappings.startWith(smTxMappings).subscribe(stateMachineTransactionMappingSubject::onNext, {}) // Parties on network val (parties, futurePartyUpdate) = proxy.networkMapFeed() futurePartyUpdate.startWith(parties.map(MapChange::Added)).subscribe(networkMapSubject::onNext, {}) } } val stateMachines = performRpcReconnect(nodeHostAndPort, username, password, shouldRetry = false) // Extract the flow tracking stream // TODO is there a nicer way of doing this? Stream of streams in general results in code like this... // TODO `progressTrackingSubject` doesn't seem to be used anymore - should it be removed? val currentProgressTrackerUpdates = stateMachines.mapNotNull { stateMachine -> ProgressTrackingEvent.createStreamFromStateMachineInfo(stateMachine) } val futureProgressTrackerUpdates = stateMachineUpdatesSubject.map { stateMachineUpdate -> if (stateMachineUpdate is StateMachineUpdate.Added) { ProgressTrackingEvent.createStreamFromStateMachineInfo(stateMachineUpdate.stateMachineInfo) ?: Observable.empty<ProgressTrackingEvent>() } else { Observable.empty<ProgressTrackingEvent>() } } // We need to retry, because when flow errors, we unsubscribe from progressTrackingSubject. So we end up with stream of state machine updates and no progress trackers. futureProgressTrackerUpdates.startWith(currentProgressTrackerUpdates).flatMap { it }.retry().subscribe(progressTrackingSubject) } - MaxLineLength:NodeMonitorModel.kt$ProgressTrackingEvent.Companion$future.map { ProgressTrackingEvent(stateMachine.id, it) }.startWith(ProgressTrackingEvent(stateMachine.id, current)) - MaxLineLength:NodeNamedCache.kt$DefaultNamedCacheFactory$name == "HibernateConfiguration_sessionFactories" -> caffeine.maximumSize(database.mappedSchemaCacheSize) - MaxLineLength:NodeNamedCache.kt$DefaultNamedCacheFactory$name == "NodeAttachmentService_attachmentContent" -> caffeine.maximumWeight(attachmentContentCacheSizeBytes) MaxLineLength:NodeNamedCache.kt$DefaultNamedCacheFactory$name.startsWith("RPCSecurityManagerShiroCache_") -> with(security?.authService?.options?.cache!!) { caffeine.maximumSize(maxEntries).expireAfterWrite(expireAfterSecs, TimeUnit.SECONDS) } MaxLineLength:NodeNamedCache.kt$DefaultNamedCacheFactory$open - MaxLineLength:NodeNamedCache.kt$DefaultNamedCacheFactory$override MaxLineLength:NodeNamedCache.kt$DefaultNamedCacheFactory$override fun bindWithConfig(nodeConfiguration: NodeConfiguration): BindableNamedCacheFactory MaxLineLength:NodeNamedCache.kt$DefaultNamedCacheFactory$override fun bindWithMetrics(metricRegistry: MetricRegistry): BindableNamedCacheFactory - MaxLineLength:NodeParameters.kt$NodeParameters - MaxLineLength:NodeParameters.kt$NodeParameters$/** * Create a new node parameters object with default values. Each parameter can be specified with its wither method which returns a copy * with that value. */ constructor() : this(providedName = null) - MaxLineLength:NodeParameters.kt$NodeParameters$fun withAdditionalCordapps(additionalCordapps: Set<TestCordapp>): NodeParameters - MaxLineLength:NodeParameters.kt$NodeParameters$fun withCustomOverrides(customOverrides: Map<String, Any?>): NodeParameters MaxLineLength:NodeParameters.kt$NodeParameters$fun withFlowOverrides(flowOverrides: Map<Class<out FlowLogic<*>>, Class<out FlowLogic<*>>>): NodeParameters - MaxLineLength:NodeParameters.kt$NodeParameters$fun withStartInSameProcess(startInSameProcess: Boolean?): NodeParameters - MaxLineLength:NodePerformanceTests.kt$NodePerformanceTests$connection.proxy.startFlow(::CashIssueFlow, 1.DOLLARS, OpaqueBytes.of(0), defaultNotaryIdentity).returnValue - MaxLineLength:NodeProcess.kt$NodeProcess$Factory - MaxLineLength:NodeProcess.kt$NodeProcess.Factory$networkParametersCopier = NetworkParametersCopier(testNetworkParameters(notaries = listOf(notaryInfo))) - MaxLineLength:NodeProcess.kt$NodeProcess.Factory.Companion$val formatter: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyyMMdd-HHmmss.SSS").withZone(systemDefault()) MaxLineLength:NodePropertiesPersistentStore.kt$FlowsDrainingModeOperationsImpl : FlowsDrainingModeOperations MaxLineLength:NodePropertiesPersistentStore.kt$NodePropertiesPersistentStore : NodePropertiesStore - MaxLineLength:NodeRPC.kt$NodeRPC : AutoCloseable - MaxLineLength:NodeRegistrationTest.kt$RegistrationHandler$require(!name.organisation.contains("\\s".toRegex())) { "Whitespace in the organisation name not supported" } - MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService : SchedulerServiceAutoCloseableSingletonSerializeAsToken - MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService$nextScheduledAction = schedulerRepo.getLatest(deduplicate.size + 1).firstOrNull { !deduplicate.contains(it.second) }?.second - MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService$private val schedulerRepo: ScheduledFlowRepository = PersistentScheduledFlowRepository(database) - MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService$val deduplicate = HashSet(startingStateRefs) // Take an immutable copy to remove races with afterDatabaseCommit. - MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService${ // We are earliest rescheduleWakeUp() } - MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService${ log.trace { "Scheduler starting FlowLogic $flowLogic" } //Add this to the in memory list of starting refs so it is not picked up on the next rescheduleWakeUp() startingStateRefs.add(scheduledState) flowLogic } - MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService.Companion$ // We should try to make the Clock used in our code injectable (for tests etc) and to use the extension below // to wait in our code, rather than <code>Thread.sleep()</code> or other time-based pauses. @Suspendable @VisibleForTesting // We specify full classpath on SettableFuture to differentiate it from the Quasar class of the same name fun awaitWithDeadline(clock: CordaClock, deadline: Instant, future: Future<*> = GuavaSettableFuture.create<Any>()): Boolean - MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService.Companion$ private fun <T : Any> makeStrandFriendlySettableFuture(future: Future<T>) - MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService.Companion$private - MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService.Companion${ // This will return when it times out, or when the clock mutates or when when the original future completes. originalFutureCompleted.get(nanos, TimeUnit.NANOSECONDS) } MaxLineLength:NodeSchedulerService.kt$NodeSchedulerService.FlowStartDeduplicationHandler$private inner - MaxLineLength:NodeSchedulerServiceTest.kt$NodeSchedulerServiceTest$private val database = configureDatabase(MockServices.makeTestDataSourceProperties(), DatabaseConfig(), { null }, { null }) - MaxLineLength:NodeSchedulerServiceTest.kt$NodeSchedulerServiceTestBase$verify(flowStarter, timeout(5000)).startFlow(argForWhich<ExternalEvent.ExternalStartFlowEvent<*>> { this.flowLogic == flowLogic }) - MaxLineLength:NodeSchemaService.kt$NodeSchemaService : SchemaServiceSingletonSerializeAsToken MaxLineLength:NodeSchemaService.kt$NodeSchemaService$fun internalSchemas() MaxLineLength:NodeSchemaService.kt$NodeSchemaService$override val schemaOptions: Map<MappedSchema, SchemaService.SchemaOptions> = requiredSchemas + extraSchemas.associateBy({ it }, { SchemaOptions() }) - MaxLineLength:NodeSchemaService.kt$NodeSchemaService$return VaultSchemaV1.VaultFungibleStates(owner = null, quantity = state.amount.quantity, issuer = null, issuerRef = null) MaxLineLength:NodeSchemaService.kt$NodeSchemaService$return VaultSchemaV1.VaultFungibleStates(state.owner, state.amount.quantity, state.amount.token.issuer.party, state.amount.token.issuer.reference) - MaxLineLength:NodeSchemaServiceTest.kt$NodeSchemaServiceTest$val mockNet = InternalMockNetwork(cordappsForAllNodes = cordappsForPackages(DummyLinearStateSchemaV1::class.packageName)) MaxLineLength:NodeSchemaServiceTest.kt$TestSchema.Child$@JoinColumns(JoinColumn(name = "transaction_id", referencedColumnName = "transaction_id"), JoinColumn(name = "output_index", referencedColumnName = "output_index")) MaxLineLength:NodeSchemaServiceTest.kt$TestSchema.Parent$@JoinColumns(JoinColumn(name = "transaction_id", referencedColumnName = "transaction_id"), JoinColumn(name = "output_index", referencedColumnName = "output_index")) MaxLineLength:NodeStartup.kt$NodeCliCommand$abstract MaxLineLength:NodeStartup.kt$NodeStartup$"""\____/ /_/ \__,_/\__,_/""" - MaxLineLength:NodeStartup.kt$NodeStartup$"Check your contracts carefully. The fine print\nis usually a clause for suspicion ${Emoji.santaClaus}" - MaxLineLength:NodeStartup.kt$NodeStartup$"How did my parents fight boredom before the internet?\nI asked my 17 siblings and they didn't know either." - MaxLineLength:NodeStartup.kt$NodeStartup$"My boss asked me who is the stupid one, me or him?\nI said everyone knows he doesn't hire stupid people." - MaxLineLength:NodeStartup.kt$NodeStartup$"Please see https://docs.corda.net/troubleshooting.html#slow-localhost-resolution for information on how to fix this. " - MaxLineLength:NodeStartup.kt$NodeStartup$"The good thing about lending out your time machine\nis that you basically get it back immediately." MaxLineLength:NodeStartup.kt$NodeStartup$"Your computer took over a second to resolve localhost due an incorrect configuration. Corda will work but start very slowly until this is fixed. " MaxLineLength:NodeStartup.kt$NodeStartup$Node.printWarning("This node is running in development mode! ${Emoji.developer} This is not safe for production deployment.") MaxLineLength:NodeStartup.kt$NodeStartup$fun initialiseAndRun(cmdLineOptions: SharedNodeCmdLineOptions, afterNodeInitialisation: RunAfterNodeInitialisation, requireCertificates: Boolean = false): Int @@ -7275,15 +4151,11 @@ MaxLineLength:NodeStartup.kt$NodeStartup$logger.warn("Found ${malformed.size} CorDapp(s) with unknown information. They will be unable to run on Corda in the future.") MaxLineLength:NodeStartup.kt$NodeStartup$nodeStartedMessage = "$nodeStartedMessage with additional Network Map keys ${conf.extraNetworkMapKeys.joinToString(prefix = "[", postfix = "]", separator = ", ")}" MaxLineLength:NodeStartup.kt$NodeStartup$printError("Unable to access certificates directory ${certDirectory}. This could be because the node has not been registered with the Identity Operator.") - MaxLineLength:NodeStartup.kt$NodeStartup$println("Application user '$appUser' does not have necessary permissions for Node base directory '$baseDirectory'.") - MaxLineLength:NodeStartup.kt$NodeStartup$println("Corda Node process in now exiting. Please check directory permissions and try starting the Node again.") MaxLineLength:NodeStartup.kt$NodeStartup$val configuration = cmdLineOptions.parseConfiguration(rawConfig).doIfValid { logRawConfig(rawConfig) }.doOnErrors(::logConfigurationErrors).optional ?: return ExitCodes.FAILURE - MaxLineLength:NodeStartup.kt$NodeStartup.Companion$private val logger by lazy { loggerFor<Node>() } // I guess this is lazy to allow for logging init, but why Node? MaxLineLength:NodeStartup.kt$NodeStartupCli$Node.printWarning("The --clear-network-map-cache flag has been deprecated and will be removed in a future version. Use the clear-network-cache command instead.") MaxLineLength:NodeStartup.kt$NodeStartupCli$Node.printWarning("The --initial-registration flag has been deprecated and will be removed in a future version. Use the initial-registration command instead.") MaxLineLength:NodeStartup.kt$NodeStartupCli$Node.printWarning("The --just-generate-node-info flag has been deprecated and will be removed in a future version. Use the generate-node-info command instead.") MaxLineLength:NodeStartup.kt$NodeStartupCli$Node.printWarning("The --just-generate-rpc-ssl-settings flag has been deprecated and will be removed in a future version. Use the generate-rpc-ssl-settings command instead.") - MaxLineLength:NodeStartup.kt$NodeStartupCli$initialRegistrationCli.networkRootTrustStorePathParameter = cmdLineOptions.networkRootTrustStorePathParameter MaxLineLength:NodeStartup.kt$NodeStartupCli$override fun additionalSubCommands() MaxLineLength:NodeStartup.kt$NodeStartupCli$println("Node was started before in `initial-registration` mode, but the registration was not completed.\nResuming registration.") MaxLineLength:NodeStartup.kt$NodeStartupCli$requireNotNull(cmdLineOptions.networkRootTrustStorePassword) { "Network root trust store password must be provided in registration mode using --network-root-truststore-password." } @@ -7291,24 +4163,14 @@ MaxLineLength:NodeStartup.kt$NodeStartupLogging$error is Errors.NativeIoException && error.message?.contains("Can't assign requested address") == true -> error.logAsExpected("Exception during node startup. Check that addresses in node config resolve correctly.") MaxLineLength:NodeStartup.kt$NodeStartupLogging$error is UnresolvedAddressException -> error.logAsExpected("Exception during node startup. Check that addresses in node config resolve correctly.") MaxLineLength:NodeStartup.kt$NodeStartupLogging$error.isOpenJdkKnownIssue() -> error.logAsExpected("Exception during node startup - ${error.message}. This is a known OpenJDK issue on some Linux distributions, please use OpenJDK from zulu.org or Oracle JDK.") - MaxLineLength:NodeStartup.kt$NodeStartupLogging$fun Throwable.logAsExpected(message: String? = this.message, print: (String?) -> Unit = logger::error) MaxLineLength:NodeStartup.kt$NodeStartupLogging$fun Throwable.logAsUnexpected(message: String? = this.message, error: Throwable = this, print: (String?, Throwable) -> Unit = logger::error) MaxLineLength:NodeStartup.kt$NodeStartupLogging.Companion$val startupErrors = setOf(MultipleCordappsForFlowException::class, CheckpointIncompatibleException::class, AddressBindingException::class, NetworkParametersReader::class, DatabaseIncompatibleException::class) - MaxLineLength:NodeStartup.kt$System.setProperty("defaultLogLevel", specifiedLogLevel) - MaxLineLength:NodeStartupCliTest.kt$NodeStartupCliTest$Assertions.assertThat(startup.cmdLineOptions.configFile).isEqualTo(workingDirectory / "another-base-dir" / "node.conf") - MaxLineLength:NodeStartupCliTest.kt$NodeStartupCliTest$CommandLine.populateCommand(startup, CommonCliConstants.BASE_DIR, (workingDirectory / "another-base-dir").toString()) - MaxLineLength:NodeStartupPerformanceTests.kt$NodeStartupPerformanceTests$// Measure the startup time of nodes. Note that this includes an RPC roundtrip, which causes e.g. Kryo initialisation. @Test fun `single node startup time`() MaxLineLength:NodeStatePersistenceTests.kt$NodeStatePersistenceTests$val nodeHandle = startNode(providedName = nodeName, rpcUsers = listOf(user), customOverrides = mapOf("devMode" to "false")).getOrThrow() - MaxLineLength:NodeStatePersistenceTests.kt$SendMessageFlow$val txBuilder = TransactionBuilder(notary).withItems(StateAndContract(messageState, MESSAGE_CONTRACT_PROGRAM_ID), txCommand) - MaxLineLength:NodeStatePersistenceTests.kt$SendMessageFlow.Companion$fun tracker() MaxLineLength:NodeTabView.kt$NodeTabView$CityDatabase.cityMap.values.map { it.countryCode }.toSet().map { it to Image(resources["/net/corda/demobench/flags/$it.png"]) }.toMap() - MaxLineLength:NodeTabView.kt$NodeTabView$notaryTypeToggleGroup.selectedValueProperty<NotaryService>() MaxLineLength:NodeTerminalView.kt$NodeTerminalView${ // TODO: Remove this special case once Rick's serialisation work means we can deserialise states that weren't on our own classpath. } - MaxLineLength:NodeTest.kt$NodeTest$assertEquals(node.generateNodeInfo(), node.generateNodeInfo()) MaxLineLength:NodeTestUtils.kt$ fun testActor(owningLegalIdentity: CordaX500Name = CordaX500Name("Test Company Inc.", "London", "GB")) MaxLineLength:NodeTestUtils.kt$ fun testContext(owningLegalIdentity: CordaX500Name = CordaX500Name("Test Company Inc.", "London", "GB")) MaxLineLength:NodeUnloadHandlerTests.kt$NodeUnloadHandlerTests$assertTrue("Timed out waiting for AbstractNode to invoke the test service shutdown callback", shutdownLatch.await(30, TimeUnit.SECONDS)) - MaxLineLength:NodeUnloadHandlerTests.kt$NodeUnloadHandlerTests$private val mockNet = InternalMockNetwork(cordappsForAllNodes = listOf(enclosedCordapp()), notarySpecs = emptyList()) MaxLineLength:NodeVaultService.kt$NodeVaultService$ @Throws(VaultQueryException::class) override fun <T : ContractState> _trackBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): DataFeed<Vault.Page<T>, Vault.Update<T>> MaxLineLength:NodeVaultService.kt$NodeVaultService$ private fun <T: ContractState> hasBeenSeen(update: Vault.Update<T>, snapshotStatesRefs: Set<StateRef>, snapshotConsumedStatesRefs: Set<StateRef>): Boolean MaxLineLength:NodeVaultService.kt$NodeVaultService$// Returns only output states that can be deserialised successfully. fun WireTransaction.deserializableOutputStates(): Map<Int, TransactionState<ContractState>> @@ -7316,184 +4178,88 @@ MaxLineLength:NodeVaultService.kt$NodeVaultService$@Throws(VaultQueryException::class) override MaxLineLength:NodeVaultService.kt$NodeVaultService$@Throws(VaultQueryException::class) private MaxLineLength:NodeVaultService.kt$NodeVaultService$Vault.Page(states = statesAndRefs, statesMetadata = statesMeta, stateTypes = criteriaParser.stateTypes, totalStatesAvailable = totalStates, otherResults = otherResults) - MaxLineLength:NodeVaultService.kt$NodeVaultService$fun <T> withValidDeserialization(list: List<T>, txId: SecureHash): Map<Int, T> MaxLineLength:NodeVaultService.kt$NodeVaultService$fun execute(configure: Root<*>.(CriteriaUpdate<*>, Array<Predicate>) -> Any?) MaxLineLength:NodeVaultService.kt$NodeVaultService$if (paging.pageNumber < DEFAULT_PAGE_NUM) throw VaultQueryException("Page specification: invalid page number ${paging.pageNumber} [page numbers start from $DEFAULT_PAGE_NUM]") MaxLineLength:NodeVaultService.kt$NodeVaultService$if (paging.pageSize < 1) throw VaultQueryException("Page specification: invalid page size ${paging.pageSize} [minimum is 1]") MaxLineLength:NodeVaultService.kt$NodeVaultService$if (paging.pageSize > MAX_PAGE_SIZE) throw VaultQueryException("Page specification: invalid page size ${paging.pageSize} [maximum is $MAX_PAGE_SIZE]") MaxLineLength:NodeVaultService.kt$NodeVaultService$isRelevant(value.data, keyManagementService.filterMyKeys(outputs.values.flatMap { it.data.participants.map { it.owningKey } }).toSet()) - MaxLineLength:NodeVaultService.kt$NodeVaultService$log.debug { "Vault Query for contract type: $contractStateType, criteria: $criteria, pagination: $paging, sorting: $sorting" } MaxLineLength:NodeVaultService.kt$NodeVaultService$log.trace { "Removing $consumedStateRefs consumed contract states and adding $producedStateRefs produced contract states to the database." } MaxLineLength:NodeVaultService.kt$NodeVaultService$log.warn("There are unknown contract state types in the vault, which will prevent these states from being used. The relevant CorDapps must be loaded for these states to be used. The types not on the classpath are ${unknownTypes.joinToString(", ", "[", "]")}.") MaxLineLength:NodeVaultService.kt$NodeVaultService$log.warn("trackBy is called with an already existing, open DB transaction. As a result, there might be states missing from both the snapshot and observable, included in the returned data feed, because of race conditions.") MaxLineLength:NodeVaultService.kt$NodeVaultService$private - MaxLineLength:NodeVaultService.kt$NodeVaultService$private val criteriaBuilder: CriteriaBuilder by lazy { database.hibernateConfig.sessionFactoryForRegisteredSchemas.criteriaBuilder } - MaxLineLength:NodeVaultService.kt$NodeVaultService$query.maxResults = if (pageSize > 0) pageSize else Integer.MAX_VALUE - MaxLineLength:NodeVaultService.kt$NodeVaultService$relevancyStatus = if (isRelevant) Vault.RelevancyStatus.RELEVANT else Vault.RelevancyStatus.NOT_RELEVANT - MaxLineLength:NodeVaultService.kt$NodeVaultService$return Vault.Update(consumedStateAndRefs.toSet(), producedStateAndRefs.toSet(), null, updateType, referenceStateAndRefs.toSet()) - MaxLineLength:NodeVaultService.kt$NodeVaultService$return Vault.Update(consumedStates.toSet(), ourNewStates.toSet(), references = newReferenceStateAndRefs.toSet()) - MaxLineLength:NodeVaultService.kt$NodeVaultService$return snapshotStatesRefs.containsAll(updateProducedStatesRefs) && snapshotConsumedStatesRefs.containsAll(updateConsumedStatesRefs) MaxLineLength:NodeVaultService.kt$NodeVaultService$softLockingCondition = QueryCriteria.SoftLockingCondition(QueryCriteria.SoftLockingType.UNLOCKED_AND_SPECIFIED, listOf(lockId)) - MaxLineLength:NodeVaultService.kt$NodeVaultService$throw StatesNotAvailableException("Attempted to reserve $stateRefs for $lockId but only $updatedRows rows available") MaxLineLength:NodeVaultService.kt$NodeVaultService$throw VaultQueryException("There are ${results.size} results, which exceeds the limit of $DEFAULT_PAGE_SIZE for queries that do not specify paging. In order to retrieve these results, provide a `PageSpecification(pageNumber, pageSize)` to the method invoked.") - MaxLineLength:NodeVaultService.kt$NodeVaultService$update.set(get<String>(VaultSchemaV1.VaultStates::lockId.name), criteriaBuilder.nullLiteral(String::class.java)) - MaxLineLength:NodeVaultService.kt$NodeVaultService$update.set<String>(get<String>(VaultSchemaV1.VaultStates::lockId.name), criteriaBuilder.nullLiteral(String::class.java)) MaxLineLength:NodeVaultService.kt$NodeVaultService$val criteriaParser = HibernateQueryCriteriaParser(contractStateType, contractStateTypeMappings, criteriaBuilder, criteriaQuery, queryRootVaultStates) - MaxLineLength:NodeVaultService.kt$NodeVaultService$val lockIdPredicate = criteriaBuilder.equal(get<String>(VaultSchemaV1.VaultStates::lockId.name), lockId.toString()) MaxLineLength:NodeVaultService.kt$NodeVaultService$val lockUpdateTime = criteriaBuilder.equal(get<Instant>(VaultSchemaV1.VaultStates::lockUpdateTime.name), softLockTimestamp) - MaxLineLength:NodeVaultService.kt$NodeVaultService$val myKeys by lazy { keyManagementService.filterMyKeys(ltx.outputs.flatMap { it.data.participants.map { it.owningKey } }) } - MaxLineLength:NodeVaultService.kt$NodeVaultService$val page = queryBy<ContractState>(QueryCriteria.VaultQueryCriteria(stateRefs = refsList.subList(offset, limit))).states - MaxLineLength:NodeVaultService.kt$NodeVaultService$val persistentStateRefs = stateRefs.map { PersistentStateRef(it.txhash.bytes.toHexString(), it.index) } MaxLineLength:NodeVaultService.kt$NodeVaultService$val results = _queryBy(criteria.and(countCriteria), PageSpecification(), Sort(emptyList()), contractStateType, true) // only skip pagination checks for total results count query - MaxLineLength:NodeVaultService.kt$NodeVaultService$val state = session.get<VaultSchemaV1.VaultStates>(VaultSchemaV1.VaultStates::class.java, PersistentStateRef(stateRef)) - MaxLineLength:NodeVaultService.kt$NodeVaultService$val stateOnly = stateAndRef.value.state.data // TODO: Optimise this. // // For EVERY state to be committed to the vault, this checks whether it is spendable by the recording // node. The behaviour is as follows: // // 1) All vault updates marked as RELEVANT will, of course, all have relevancy_status = 1 in the // "vault_states" table. // 2) For ALL_VISIBLE updates, those which are not relevant according to the relevancy rules will have // relevancy_status = 0 in the "vault_states" table. // // This is useful when it comes to querying for fungible states, when we do not want irrelevant states // included in the result. // // The same functionality could be obtained by passing in a list of participants to the vault query, // however this: // // * requires a join on the participants table which results in slow queries // * states may flip from being non-relevant to relevant // * it's more complicated for CorDapp developers // // Adding a new column in the "VaultStates" table was considered the best approach. val keys = stateOnly.participants.map { it.owningKey } val persistentStateRef = PersistentStateRef(stateAndRef.key) // This check is done to set the "relevancyStatus". When one performs a vault query, it is possible to return ALL states, ONLY // RELEVANT states or NOT relevant states. val isRelevant = isRelevant(stateOnly, keyManagementService.filterMyKeys(keys).toSet()) val constraintInfo = Vault.ConstraintInfo(stateAndRef.value.state.constraint) // Save a row for each party in the state_party table. // TODO: Perhaps these can be stored in a batch? stateOnly.participants.groupBy { it.owningKey }.forEach { participants -> val persistentParty = VaultSchemaV1.PersistentParty(persistentStateRef, participants.value.first()) session.save(persistentParty) } val stateToAdd = VaultSchemaV1.VaultStates( notary = stateAndRef.value.state.notary, contractStateClassName = stateAndRef.value.state.data.javaClass.name, stateStatus = Vault.StateStatus.UNCONSUMED, recordedTime = clock.instant(), relevancyStatus = if (isRelevant) Vault.RelevancyStatus.RELEVANT else Vault.RelevancyStatus.NOT_RELEVANT, constraintType = constraintInfo.type(), constraintData = constraintInfo.data() ) stateToAdd.stateRef = persistentStateRef session.save(stateToAdd) - MaxLineLength:NodeVaultService.kt$NodeVaultService$val stateRef = StateRef(SecureHash.parse(vaultState.stateRef!!.txId), vaultState.stateRef!!.index) MaxLineLength:NodeVaultService.kt$NodeVaultService$val stateStatusPredication = criteriaBuilder.equal(get<Vault.StateStatus>(VaultSchemaV1.VaultStates::stateStatus.name), Vault.StateStatus.UNCONSUMED) MaxLineLength:NodeVaultService.kt$NodeVaultService$val txIdPredicate = criteriaBuilder.equal(vaultStates.get<Vault.StateStatus>(VaultSchemaV1.VaultTxnNote::txId.name), txnId.toString()) - MaxLineLength:NodeVaultService.kt$NodeVaultService${ // We decrement by one if the client requests MAX_PAGE_SIZE, assuming they can not notice this because they don't have enough memory // to request `MAX_PAGE_SIZE` states at once. val paging = if (paging_.pageSize == Integer.MAX_VALUE) { paging_.copy(pageSize = Integer.MAX_VALUE - 1) } else { paging_ } log.debug { "Vault Query for contract type: $contractStateType, criteria: $criteria, pagination: $paging, sorting: $sorting" } return database.transaction { // calculate total results where a page specification has been defined var totalStates = -1L if (!skipPagingChecks && !paging.isDefault) { val count = builder { VaultSchemaV1.VaultStates::recordedTime.count() } val countCriteria = QueryCriteria.VaultCustomQueryCriteria(count, Vault.StateStatus.ALL) val results = _queryBy(criteria.and(countCriteria), PageSpecification(), Sort(emptyList()), contractStateType, true) // only skip pagination checks for total results count query totalStates = results.otherResults.last() as Long } val session = getSession() val criteriaQuery = criteriaBuilder.createQuery(Tuple::class.java) val queryRootVaultStates = criteriaQuery.from(VaultSchemaV1.VaultStates::class.java) // TODO: revisit (use single instance of parser for all queries) val criteriaParser = HibernateQueryCriteriaParser(contractStateType, contractStateTypeMappings, criteriaBuilder, criteriaQuery, queryRootVaultStates) // parse criteria and build where predicates criteriaParser.parse(criteria, sorting) // prepare query for execution val query = session.createQuery(criteriaQuery) // pagination checks if (!skipPagingChecks && !paging.isDefault) { // pagination if (paging.pageNumber < DEFAULT_PAGE_NUM) throw VaultQueryException("Page specification: invalid page number ${paging.pageNumber} [page numbers start from $DEFAULT_PAGE_NUM]") if (paging.pageSize < 1) throw VaultQueryException("Page specification: invalid page size ${paging.pageSize} [minimum is 1]") if (paging.pageSize > MAX_PAGE_SIZE) throw VaultQueryException("Page specification: invalid page size ${paging.pageSize} [maximum is $MAX_PAGE_SIZE]") } // For both SQLServer and PostgresSQL, firstResult must be >= 0. So we set a floor at 0. // TODO: This is a catch-all solution. But why is the default pageNumber set to be -1 in the first place? // Even if we set the default pageNumber to be 1 instead, that may not cover the non-default cases. // So the floor may be necessary anyway. query.firstResult = maxOf(0, (paging.pageNumber - 1) * paging.pageSize) val pageSize = paging.pageSize + 1 query.maxResults = if (pageSize > 0) pageSize else Integer.MAX_VALUE // detection too many results, protected against overflow // execution val results = query.resultList // final pagination check (fail-fast on too many results when no pagination specified) if (!skipPagingChecks && paging.isDefault && results.size > DEFAULT_PAGE_SIZE) { throw VaultQueryException("There are ${results.size} results, which exceeds the limit of $DEFAULT_PAGE_SIZE for queries that do not specify paging. In order to retrieve these results, provide a `PageSpecification(pageNumber, pageSize)` to the method invoked.") } val statesAndRefs: MutableList<StateAndRef<T>> = mutableListOf() val statesMeta: MutableList<Vault.StateMetadata> = mutableListOf() val otherResults: MutableList<Any> = mutableListOf() val stateRefs = mutableSetOf<StateRef>() results.asSequence() .forEachIndexed { index, result -> if (result[0] is VaultSchemaV1.VaultStates) { if (!paging.isDefault && index == paging.pageSize) // skip last result if paged return@forEachIndexed val vaultState = result[0] as VaultSchemaV1.VaultStates val stateRef = StateRef(SecureHash.parse(vaultState.stateRef!!.txId), vaultState.stateRef!!.index) stateRefs.add(stateRef) statesMeta.add(Vault.StateMetadata(stateRef, vaultState.contractStateClassName, vaultState.recordedTime, vaultState.consumedTime, vaultState.stateStatus, vaultState.notary, vaultState.lockId, vaultState.lockUpdateTime, vaultState.relevancyStatus, constraintInfo(vaultState.constraintType, vaultState.constraintData) )) } else { // TODO: improve typing of returned other results log.debug { "OtherResults: ${Arrays.toString(result.toArray())}" } otherResults.addAll(result.toArray().asList()) } } if (stateRefs.isNotEmpty()) statesAndRefs.addAll(uncheckedCast(servicesForResolution.loadStates(stateRefs))) Vault.Page(states = statesAndRefs, statesMetadata = statesMeta, stateTypes = criteriaParser.stateTypes, totalStatesAvailable = totalStates, otherResults = otherResults) } } - MaxLineLength:NodeVaultService.kt$NodeVaultService${ // When resolving transaction dependencies we might encounter contracts we haven't installed locally. // This will cause a failure as we can't deserialize such states in the context of the `appClassloader`. // For now we ignore these states. // In the future we will use the AttachmentsClassloader to correctly deserialize and asses the relevancy. log.debug { "Could not deserialize state $idx from transaction $txId. Cause: $e" } null } - MaxLineLength:NodeVaultService.kt$NodeVaultService${ val outputs: Map<Int, TransactionState<ContractState>> = tx.deserializableOutputStates() val ourNewStates = when (statesToRecord) { StatesToRecord.NONE -> throw AssertionError("Should not reach here") StatesToRecord.ONLY_RELEVANT -> outputs.filter { (_, value) -> isRelevant(value.data, keyManagementService.filterMyKeys(outputs.values.flatMap { it.data.participants.map { it.owningKey } }).toSet()) } StatesToRecord.ALL_VISIBLE -> outputs }.map { (idx, _) -> tx.outRef<ContractState>(idx) } // Retrieve all unconsumed states for this transaction's inputs. val consumedStates = loadStates(tx.inputs) // Is transaction irrelevant? If so, then we don't care about the reference states either. if (consumedStates.isEmpty() && ourNewStates.isEmpty()) { log.trace { "tx ${tx.id} was irrelevant to this vault, ignoring" } return null } // This list should only contain NEW states which we have not seen before as an output in another transaction. If we can't // obtain the references from the vault then the reference must be a state we have not seen before, therefore we should store it // in the vault. If StateToRecord is set to ALL_VISIBLE or ONLY_RELEVANT then we should store all of the previously unseen // states in the reference list. The assumption is that we might need to inspect them at some point if they were referred to // in the contracts of the input or output states. If states to record is none then we shouldn't record any reference states. val newReferenceStateAndRefs = if (tx.references.isEmpty()) { emptyList() } else { when (statesToRecord) { StatesToRecord.NONE -> throw AssertionError("Should not reach here") StatesToRecord.ALL_VISIBLE, StatesToRecord.ONLY_RELEVANT -> { val notSeenReferences = tx.references - loadStates(tx.references).map { it.ref } // TODO: This is expensive - is there another way? tx.toLedgerTransaction(servicesForResolution).deserializableRefStates() .filter { (_, stateAndRef) -> stateAndRef.ref in notSeenReferences } .values } } } return Vault.Update(consumedStates.toSet(), ourNewStates.toSet(), references = newReferenceStateAndRefs.toSet()) } - MaxLineLength:NodeVaultService.kt$NodeVaultService.Companion$ fun isRelevant(state: ContractState, myKeys: Set<PublicKey>): Boolean MaxLineLength:NodeVaultService.kt$NodeVaultService.InnerState$// For use during publishing only. val updatesPublisher: rx.Observer<Vault.Update<ContractState>> get() = _updatesPublisher.bufferUntilDatabaseCommit().tee(_rawUpdatesPublisher) MaxLineLength:NodeVaultService.kt$private MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$(services.validatedTransactions as WritableTransactionStorage).addTransaction(SignedTransaction(changeNotaryTx, listOf(NullKeys.NULL_SIGNATURE))) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$Cash().generateIssue(this, 100.DOLLARS `issued by` MEGA_CORP.ref(1), AnonymousParty(freshKey), DUMMY_NOTARY) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$Cash().generateIssue(this, 200.POUNDS `issued by` MEGA_CORP.ref(1), AnonymousParty(freshKey), DUMMY_NOTARY) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$CashUtils.generateSpend(services, this, Amount(amount.quantity, GBP), identity, thirdPartyIdentity.party.anonymise()) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$FungibleFoo : FungibleState MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$TransactionState(Cash.State(amount `issued by` issuer.ref(depositRef), identity.party), Cash.PROGRAM_ID, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$addOutputState(DummyDealContract.State(listOf(megaCorp.party), "Dummy linear id"), DUMMY_DEAL_PROGRAM_ID) MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$addOutputState(UniqueDummyFungibleContract.State(10.DOLLARS `issued by` DUMMY_CASH_ISSUER, megaCorp.party), UNIQUE_DUMMY_FUNGIBLE_CONTRACT_PROGRAM_ID) MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$addOutputState(UniqueDummyLinearContract.State(listOf(megaCorp.party), "Dummy linear id"), UNIQUE_DUMMY_LINEAR_CONTRACT_PROGRAM_ID) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$assertFalse { myKeys.isOwnableStateRelevant(createUnknownIdentity(), participants = listOf(identity.party)) } MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$assertThat(spendableStatesUSD[0].state.data.amount.token.issuer).isNotEqualTo(spendableStatesUSD[1].state.data.amount.token.issuer) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$assertThat(spendableStatesUSD[0].state.data.amount.token.issuer.reference).isIn(BOC.ref(1).reference, BOC.ref(2).reference) MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$assertThat(spendableStatesUSD[0].state.data.amount.token.issuer.reference).isNotEqualTo(spendableStatesUSD[1].state.data.amount.token.issuer.reference) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$assertThat(spendableStatesUSD[1].state.data.amount.token.issuer.reference).isIn(BOC.ref(1).reference, BOC.ref(2).reference) MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$cash.generateIssue(issuance, Amount(howMuch.quantity, Issued(DUMMY_CASH_ISSUER, howMuch.token)), services.myInfo.singleIdentity(), dummyNotary.party) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$makeTestIdentityService(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, DUMMY_CASH_ISSUER_IDENTITY, DUMMY_NOTARY_IDENTITY) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$private - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$services.recordTransactions(StatesToRecord.ALL_VISIBLE, listOf(createTx(6, megaCorp.party, bankOfCorda.party))) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$services.recordTransactions(StatesToRecord.ONLY_RELEVANT, listOf(createTx(3, miniCorp.party, megaCorp.party))) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val cashStateWithNewNotary = StateAndRef(initialCashState.state.copy(notary = newNotary), StateRef(changeNotaryTx.id, 0)) MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val changeNotaryTx = NotaryChangeTransactionBuilder(listOf(initialCashState.ref), issueStx.notary!!, newNotary, services.networkParametersService.currentHash).build() MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val criteriaByLockId = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(softLockId))) MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val criteriaByLockId1 = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(softLockId1))) MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val criteriaByLockId2 = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(softLockId2))) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val criteriaLocked = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.LOCKED_ONLY)) MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val criteriaLocked = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(lockId))) MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val expectedNotaryChangeUpdate = Vault.Update(setOf(initialCashState), setOf(cashStateWithNewNotary), null, Vault.UpdateType.NOTARY_CHANGE) - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val myKeys = services.keyManagementService.filterMyKeys(listOf(identity.owningKey, myAnonymousIdentity.owningKey)).toSet() - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val states = vaultService.queryBy<Cash.State>(VaultQueryCriteria(stateRefs = listOf(w1[1].ref, w1[2].ref))).states MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val thirdPartyIdentity = thirdPartyServices.keyManagementService.freshKeyAndCert(thirdPartyServices.myInfo.singleIdentityAndCert(), false) MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val unlockedStates = vaultService.queryBy<Cash.State>(VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY))).states MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val unlockedStates1 = vaultService.queryBy<Cash.State>(VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY))).states MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val unlockedStates2 = vaultService.queryBy<Cash.State>(VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY))).states - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$val w1 = vaultService.queryBy<Cash.State>(PageSpecification(pageNumber = 1, pageSize = Integer.MAX_VALUE)).states MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$vaultService.queryBy(Cash.State::class.java, QueryCriteria.VaultQueryCriteria(relevancyStatus = Vault.RelevancyStatus.ALL), PageSpecification(1)).totalStatesAvailable - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest$withIssuerRefs: Set<OpaqueBytes>? = null - MaxLineLength:NodeVaultServiceTest.kt$NodeVaultServiceTest.Companion$val cordappPackages = listOf("net.corda.finance.contracts.asset", CashSchemaV1::class.packageName, "net.corda.testing.contracts", "net.corda.testing.internal.vault") - MaxLineLength:NodeVersioningTest.kt$NodeVersioningTest$assertThat(rpc.startFlow(NodeVersioningTest::GetPlatformVersionFlow).returnValue.getOrThrow()).isEqualTo(PLATFORM_VERSION) MaxLineLength:NodeWebServer.kt$NodeWebServer$/** Fetch WebServerPluginRegistry classes registered in META-INF/services/net.corda.webserver.services.WebServerPluginRegistry files that exist in the classpath */ val pluginRegistries: List<WebServerPluginRegistry> by lazy { ServiceLoader.load(WebServerPluginRegistry::class.java).toList() } - MaxLineLength:NodeWebServer.kt$NodeWebServer$if (e is BindException || e is Errors.NativeIoException && e.message?.contains("Address already in use") == true) { throw AddressBindingException(address) } else { throw e } MaxLineLength:NodeWebServer.kt$NodeWebServer$val sslConnector = ServerConnector(server, SslConnectionFactory(sslContextFactory, "http/1.1"), HttpConnectionFactory(httpsConfiguration)) - MaxLineLength:NodeWebServer.kt$NodeWebServer.<no name provided>$@Throws(IOException::class) override - MaxLineLength:NonEmptySet.kt$NonEmptySet.Companion$elements.forEach { copy += it } - MaxLineLength:NonInvalidatingCache.kt$NonInvalidatingCache.Companion$private MaxLineLength:NonInvalidatingCache.kt$NonInvalidatingWeightBasedCache.Companion$private MaxLineLength:NonInvalidatingUnboundCache.kt$NonInvalidatingUnboundCache$constructor(name: String, cacheFactory: NamedCacheFactory, loadFunction: (K) -> V, removalListener: RemovalListener<K, V> = RemovalListener { _, _, _ -> }, keysToPreload: () -> Iterable<K> = { emptyList() }) : this(buildCache(name, cacheFactory, loadFunction, removalListener, keysToPreload)) MaxLineLength:NonInvalidatingUnboundCache.kt$NonInvalidatingUnboundCache.Companion$private - MaxLineLength:NonInvalidatingUnboundCache.kt$NonInvalidatingUnboundCache.Companion$val builder = Caffeine.newBuilder().removalListener(removalListener).executor(SameThreadExecutor.getExecutor()) MaxLineLength:NonValidatingNotaryFlow.kt$NonValidatingNotaryFlow : NotaryServiceFlow - MaxLineLength:NonValidatingNotaryFlow.kt$NonValidatingNotaryFlow$"Notary specified by the transaction ($notary) is not on the network parameter whitelist: ${notaryWhitelist.joinToString()}" - MaxLineLength:NonValidatingNotaryFlow.kt$NonValidatingNotaryFlow$"expected either ${FilteredTransaction::class.java.simpleName} or ${NotaryChangeWireTransaction::class.java.simpleName}" MaxLineLength:NonValidatingNotaryFlow.kt$NonValidatingNotaryFlow$?: MaxLineLength:NonValidatingNotaryFlow.kt$NonValidatingNotaryFlow$is FilteredTransaction -> TransactionParts(tx.id, tx.inputs, tx.timeWindow, tx.notary, tx.references, networkParametersHash = tx.networkParametersHash) MaxLineLength:NonValidatingNotaryFlow.kt$NonValidatingNotaryFlow$is NotaryChangeWireTransaction - MaxLineLength:NonValidatingNotaryServiceTests.kt$NonValidatingNotaryServiceTests$private - MaxLineLength:NonValidatingNotaryServiceTests.kt$NonValidatingNotaryServiceTests$val modifiedSignature = NotarisationRequestSignature(randomKeyPair.sign(bytesToSign), aliceNode.services.myInfo.platformVersion) MaxLineLength:NonValidatingNotaryServiceTests.kt$NonValidatingNotaryServiceTests.<no name provided>$val alteredMessage = InMemoryMessage(message.topic, OpaqueBytes(alteredMessageData.serialize().bytes), message.uniqueMessageId) MaxLineLength:Notarise.kt$NotaryDemoClientApi$rpc.startFlow(::RPCStartableNotaryFlowClient, it).returnValue.toCompletableFuture().thenApply { it.map { it.by.toStringShort() } } MaxLineLength:NotaryChangeFlow.kt$NotaryChangeFlow$val signableData = SignableData(tx.id, SignatureMetadata(serviceHub.myInfo.platformVersion, Crypto.findSignatureScheme(myKey).schemeNumberID)) MaxLineLength:NotaryChangeTests.kt$NotaryChangeTests$assertTrue { originalLinkedStates.size == notaryChangeLinkedStates.size && originalLinkedStates.containsAll(notaryChangeLinkedStates) } - MaxLineLength:NotaryChangeTests.kt$NotaryChangeTests$clientNodeB.services.recordTransactions(clientNodeA.services.validatedTransactions.getTransaction(issued.ref.txhash)!!) MaxLineLength:NotaryChangeTests.kt$NotaryChangeTests$private - MaxLineLength:NotaryChangeTests.kt$fun issueInvalidState(services: ServiceHub, identity: Party, notary: Party): StateAndRef<DummyContract.SingleOwnerState> MaxLineLength:NotaryChangeTests.kt$fun issueMultiPartyState(nodeA: StartedMockNode, nodeB: StartedMockNode, notaryNode: StartedMockNode, notaryIdentity: Party): StateAndRef<DummyContract.MultiOwnerState> - MaxLineLength:NotaryChangeTests.kt$fun issueState(services: ServiceHub, nodeIdentity: Party, notaryIdentity: Party): StateAndRef<DummyContract.SingleOwnerState> - MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeLedgerTransaction$ private fun checkNewNotaryWhitelisted() - MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeLedgerTransaction$?: - MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeLedgerTransaction$@Deprecated("NotaryChangeLedgerTransaction should not be created directly, use NotaryChangeWireTransaction.resolve instead.") - MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeLedgerTransaction$override fun equals(other: Any?): Boolean - MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeLedgerTransaction$val inputPositionIndex: Map<StateRef, Int> = inputs.mapIndexed { index, stateAndRef -> stateAndRef.ref to index }.toMap() MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeWireTransaction$ @CordaInternal internal fun resolveOutputComponent(services: ServicesForResolution, stateRef: StateRef, params: NetworkParameters): SerializedBytes<TransactionState<ContractState>> - MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeWireTransaction$ @DeleteForDJVM fun resolve(services: ServiceHub, sigs: List<TransactionSignature>) MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeWireTransaction$@CordaInternal internal MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeWireTransaction$@Deprecated("Required only for backwards compatibility purposes. This type of transaction should not be constructed outside Corda code.", ReplaceWith("NotaryChangeTransactionBuilder"), DeprecationLevel.WARNING) - MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeWireTransaction$@Deprecated("Required only for backwards compatibility purposes. This type of transaction should not be constructed outside Corda code.", ReplaceWith("NotaryChangeTransactionBuilder"), DeprecationLevel.WARNING) constructor(inputs: List<StateRef>, notary: Party, newNotary: Party) : this(listOf(inputs, notary, newNotary).map { it.serialize() }) - MaxLineLength:NotaryChangeTransactions.kt$NotaryChangeWireTransaction$return NotaryChangeLedgerTransaction.create(resolvedInputs, notary, newNotary, id, sigs, resolvedNetworkParameters) - MaxLineLength:NotaryError.kt$NotaryError.Conflict$"${consumedStates.asSequence().joinToString(",\n", limit = 5) { it.key.toString() + " -> " + it.value }}.\n" MaxLineLength:NotaryError.kt$NotaryError.Conflict$"To find out if any of the conflicting transactions have been generated by this node you can use the hashLookup Corda shell command." MaxLineLength:NotaryError.kt$NotaryError.Conflict$override - MaxLineLength:NotaryError.kt$NotaryError.TimeWindowInvalid$override fun toString() MaxLineLength:NotaryError.kt$NotaryError.WrongNotary$@Deprecated("Deprecated since platform version 4. This object is no longer used, [TransactionInvalid] will be reported in case of notary mismatch") - MaxLineLength:NotaryError.kt$NotaryException$/** Id of the transaction to be notarised. Can be _null_ if an error occurred before the id could be resolved. */ val txId: SecureHash? = null - MaxLineLength:NotaryError.kt$StateConsumptionDetails$fun copy(hashOfTransactionId: SecureHash): StateConsumptionDetails - MaxLineLength:NotaryFlow.kt$NotaryFlow.Client$ private fun generateRequestSignature(): NotarisationRequestSignature MaxLineLength:NotaryFlow.kt$NotaryFlow.Client$"Notary $notaryParty is not on the network parameter whitelist. A non-whitelisted notary can only be used for notary change transactions" MaxLineLength:NotaryFlow.kt$NotaryFlow.Client$?: MaxLineLength:NotaryFlow.kt$NotaryFlow.Client$@Suspendable private - MaxLineLength:NotaryFlow.kt$NotaryFlow.Client$NotarySendTransactionFlow : DataVendingFlow - MaxLineLength:NotaryFlow.kt$NotaryFlow.Client$check - MaxLineLength:NotaryFlow.kt$NotaryFlow.Client$it is StateRef || it is ReferenceStateRef || it is TimeWindow || it == notaryParty || it is NetworkParametersHash - MaxLineLength:NotaryFlow.kt$NotaryFlow.Client$protected - MaxLineLength:NotaryFlow.kt$NotaryFlow.Client$val historicNotary = (serviceHub.networkParametersService as NetworkParametersStorage).getHistoricNotary(notaryParty) ?: throw IllegalStateException("The notary party $notaryParty specified by transaction ${stx.id}, is not recognised as a current or historic notary.") MaxLineLength:NotaryFlow.kt$NotaryFlow.Client$val notarisationRequest = NotarisationRequest(stx.inputs.map { it.copy(txhash = SecureHash.parse(it.txhash.toString())) }, stx.id) MaxLineLength:NotaryFlow.kt$NotaryFlow.Client.NotarySendTransactionFlow$@Suspendable override MaxLineLength:NotaryFlow.kt$NotaryFlow.Client.NotarySendTransactionFlow$private MaxLineLength:NotaryFlow.kt$net.corda.core.flows.NotaryFlow.kt - MaxLineLength:NotaryLoader.kt$NotaryLoader$ private fun maybeInstallSerializationFilter(serviceClass: Class<out NotaryService>) - MaxLineLength:NotaryLoader.kt$NotaryLoader$ private fun scanCorDapps(cordappLoader: CordappLoader): Class<out NotaryService> MaxLineLength:NotaryLoader.kt$NotaryLoader$ private fun validateNotaryType(myNotaryIdentity: PartyAndCertificate?, services: ServiceHubInternal) MaxLineLength:NotaryLoader.kt$NotaryLoader$+ MaxLineLength:NotaryLoader.kt$NotaryLoader$?: - MaxLineLength:NotaryLoader.kt$NotaryLoader$fun loadService(myNotaryIdentity: PartyAndCertificate?, services: ServiceHubInternal, cordappLoader: CordappLoader): NotaryService MaxLineLength:NotaryLoader.kt$NotaryLoader$throw IllegalStateException("There is a discrepancy in the configured notary type and the one advertised in the network parameters - shutting down. " + "Configured as validating: ${configuredAsValidatingNotary}. Advertised as validating: ${validatingNotaryInNetworkMapCache}") - MaxLineLength:NotaryLoader.kt$NotaryLoader$val notaryParty = myNotaryIdentity?.party ?: throw IllegalStateException("Could not establish notary identity of this node") - MaxLineLength:NotaryServiceFlow.kt$NotaryServiceFlow : FlowLogic - MaxLineLength:NotaryServiceFlow.kt$NotaryServiceFlow$ @Suspendable abstract fun verifyTransaction(requestPayload: NotarisationPayload) MaxLineLength:NotaryServiceFlow.kt$NotaryServiceFlow$"The notary specified on the transaction: [$notary] does not match the notary service's identity: [${service.notaryIdentityKey}] " MaxLineLength:NotaryServiceFlow.kt$NotaryServiceFlow$@Suspendable private MaxLineLength:NotaryServiceFlow.kt$NotaryServiceFlow$abstract - MaxLineLength:NotaryServiceTests.kt$NotaryServiceTests$assertThat(notaryError.cause).hasMessageContaining("Transaction for notarisation contains unknown parameters hash: $hash") - MaxLineLength:NotaryServiceTests.kt$NotaryServiceTests$assertThat(notaryError.cause).hasMessageContaining("Transaction for notarisation doesn't contain network parameters hash.") - MaxLineLength:NotaryServiceTests.kt$NotaryServiceTests.Companion$ fun notariseWithTooManyInputs(node: TestStartedNode, party: Party, notary: Party, network: InternalMockNetwork) MaxLineLength:NotaryServiceTests.kt$NotaryServiceTests.Companion$val signableData = SignableData(tx.id, SignatureMetadata(myInfo.platformVersion, Crypto.findSignatureScheme(myKey).schemeNumberID)) - MaxLineLength:NotarySpec.kt$NotarySpec - MaxLineLength:NotarySpec.kt$NotarySpec$// These extra fields are handled this way to preserve Kotlin wire compatibility wrt additional parameters with default values. constructor(name: CordaX500Name, validating: Boolean = true, rpcUsers: List<User> = emptyList(), verifierType: VerifierType = VerifierType.InMemory, cluster: ClusterSpec? = null, maximumHeapSize: String = "512m"): this(name, validating, rpcUsers, verifierType, cluster) { this.maximumHeapSize = maximumHeapSize } - MaxLineLength:NotaryUtils.kt$"Expected a signature by ${intendedSigner.owningKey.toBase58String()}, but received by ${signature.by.toBase58String()}}" - MaxLineLength:NotaryUtils.kt$require(notary.owningKey.isFulfilledBy(signingKeys)) { "Insufficient signatures to fulfill the notary signing requirement for $notary" } MaxLineLength:NotaryWhitelistTests.kt$NotaryWhitelistTests$ @Test fun `can perform notary change on a de-listed notary`() - MaxLineLength:NotaryWhitelistTests.kt$NotaryWhitelistTests$ @Test fun `can't perform a regular transaction on a de-listed notary`() MaxLineLength:NotaryWhitelistTests.kt$NotaryWhitelistTests$notarySpecs = listOf(MockNetworkNotarySpec(oldNotaryName, validating = isValidating), MockNetworkNotarySpec(newNotaryName, validating = isValidating)) MaxLineLength:NotaryWhitelistTests.kt$NotaryWhitelistTests$private MaxLineLength:NotaryWhitelistTests.kt$NotaryWhitelistTests${ // Issue a state using the old notary. It is currently whitelisted. val stateFakeNotary = issueStateOnOldNotary(oldNotary) // Remove old notary from the whitelist val parameters = aliceNode.services.networkParameters val newParameters = removeOldNotary(parameters) mockNet.nodes.forEach { (it.networkParametersStorage as MockNetworkParametersStorage).setCurrentParametersUnverified(newParameters) } // Re-point the state to the remaining whitelisted notary. The transaction itself should be considered valid, even though the old notary is not whitelisted. val futureChange = aliceNode.services.startFlow(NotaryChangeFlow(stateFakeNotary, newNotary)).resultFuture mockNet.runNetwork() val newSTate = futureChange.getOrThrow() // Create a valid transaction consuming the re-pointed state. val validTxBuilder = TransactionBuilder(newNotary) .addInputState(newSTate) .addCommand(dummyCommand(alice.owningKey)) val validStx = aliceNode.services.signInitialTransaction(validTxBuilder) // The transaction verifies. validStx.verify(aliceNode.services, false) // Notarisation should succeed. val future = runNotaryClient(validStx) future.getOrThrow() } MaxLineLength:NotaryWhitelistTests.kt$NotaryWhitelistTests${ Assume.assumeTrue(isValidating) // Skip the test for non-validating notaries val fakeNotaryKeyPair = generateKeyPair() val fakeNotaryParty = Party(DUMMY_NOTARY_NAME.copy(organisation = "Fake notary"), fakeNotaryKeyPair.public) // Issue a state using an unlisted notary. This transaction should not verify when checked by counterparties. val stateFakeNotary = issueStateWithFakeNotary(fakeNotaryParty, fakeNotaryKeyPair) // Re-point the state to the whitelisted notary. The transaction itself should be considered valid, even though the old notary is not whitelisted. val notaryChangeLtx = changeNotary(stateFakeNotary, fakeNotaryParty, fakeNotaryKeyPair) // Create a valid transaction consuming the re-pointed state. val inputStateValidNotary = notaryChangeLtx.outRef<DummyContract.State>(0) val validTxBuilder = TransactionBuilder(oldNotary) .addInputState(inputStateValidNotary) .addCommand(dummyCommand(alice.owningKey)) val validStx = aliceNode.services.signInitialTransaction(validTxBuilder) // The transaction itself verifies, as no resolution is done here. validStx.verify(aliceNode.services, false) val future = runNotaryClient(validStx) // The notary should reject this transaction – the issue transaction in the dependencies should not verify. val ex = assertFailsWith(NotaryException::class) { future.getOrThrow() } assert(ex.error is NotaryError.TransactionInvalid) assertEquals(validStx.id, ex.txId) } - MaxLineLength:NotaryWhitelistTests.kt$NotaryWhitelistTests${ val notaryChangeTx = NotaryChangeTransactionBuilder( listOf(inputState.ref), fakeNotaryParty, oldNotary, aliceNode.services.networkParametersService.currentHash ).build() val notaryChangeAliceSig = getAliceSig(notaryChangeTx) val notaryChangeNotarySig = run { val metadata = SignatureMetadata(4, Crypto.findSignatureScheme(fakeNotaryParty.owningKey).schemeNumberID) val data = SignableData(notaryChangeTx.id, metadata) fakeNotaryKeyPair.sign(data) } val notaryChangeStx = SignedTransaction(notaryChangeTx, listOf(notaryChangeAliceSig, notaryChangeNotarySig)) aliceNode.services.validatedTransactions.addTransaction(notaryChangeStx) // Resolving the ledger transaction verifies the whitelist checking logic – for notary change transactions the old notary // does not need to be whitelisted. val notaryChangeLtx = notaryChangeStx.resolveNotaryChangeTransaction(aliceNode.services) notaryChangeLtx.verifyRequiredSignatures() return notaryChangeLtx } - MaxLineLength:NotaryWireFormat.kt$NotarisationPayload - MaxLineLength:NotaryWireFormat.kt$NotarisationRequest - MaxLineLength:NotaryWireFormat.kt$NotarisationRequest$/** States this request specifies to be consumed. Sorted to ensure the serialized form does not get affected by the state order. */ val statesToConsume: List<StateRef> get() = _statesToConsumeSorted // Getter required for AMQP serialization - MaxLineLength:NullKeys.kt$NullKeys$/** A signature with a key and value of zero. Useful when you want a signature object that you know won't ever be used. */ val NULL_SIGNATURE = TransactionSignature(ByteArray(32), NullPublicKey, SignatureMetadata(1, -1)) - MaxLineLength:OGStub.kt$BimmAnalysisUtils$first: CurrencyParameterSensitivities MaxLineLength:OGStub.kt$BimmAnalysisUtils$fun computeMargin(combinedRatesProvider: ImmutableRatesProvider?, normalizer: PortfolioNormalizer, calculatorTotal: RwamBimmNotProductClassesCalculator, first: CurrencyParameterSensitivities, second: MultiCurrencyAmount): Triple<Double, Double, Double> - MaxLineLength:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$val defnsCcp1 = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE_CCP1, SETTINGS_RESOURCE_CCP1, CALIBRATION_RESOURCE_CCP1) - MaxLineLength:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$val defnsCcp2 = RatesCalibrationCsvLoader.load(GROUPS_RESOURCE_CCP2, SETTINGS_RESOURCE_CCP2, CALIBRATION_RESOURCE_CCP2) MaxLineLength:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$val marketData = ImmutableMarketData.builder(VAL_DATE).addValueMap(quotesCcp1).addValueMap(quotesCcp2).addTimeSeriesMap(fixings).build() MaxLineLength:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$val marketDataConfig = MarketDataConfig.builder().add(CURVE_GROUP_NAME_CCP1, curveGroupDefinitionCcp1).add(CURVE_GROUP_NAME_CCP2, curveGroupDefinitionCcp2).build() MaxLineLength:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$val tradeInfo = TradeInfo.builder().id(StandardId.of("example", "1")).addAttribute(TradeAttributeType.DESCRIPTION, "Fixed vs Libor 3m").counterparty(ctptyId).settlementDate(LocalDate.of(2014, 9, 12)).build() - MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$PeriodicSchedule.builder() .startDate(LocalDate.of(2014, 9, 12)) .endDate(LocalDate.of(2016, 6, 12)) .frequency(Frequency.P3M) .businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)) MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$PeriodicSchedule.builder() .startDate(LocalDate.of(2014, 9, 12)) .endDate(LocalDate.of(2016, 6, 12)) .stubConvention(StubConvention.SHORT_INITIAL) .frequency(Frequency.P6M) - MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$PeriodicSchedule.builder() .startDate(LocalDate.of(2014, 9, 12)) .endDate(LocalDate.of(2020, 9, 12)) .frequency(Frequency.P3M) .businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)) MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$return SwapTrade.builder().product(Swap.of(payLeg, receiveLeg)).info(TradeInfo.builder().id(StandardId.of("example", "10")).addAttribute(TradeAttributeType.DESCRIPTION, "Zero-coupon fixed vs libor 3m").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 9, 12)).build()).build() MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$return SwapTrade.builder().product(Swap.of(payLeg, receiveLeg)).info(TradeInfo.builder().id(StandardId.of("example", "11")).addAttribute(TradeAttributeType.DESCRIPTION, "Compounding fixed vs fed funds").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 2, 5)).build()).build() MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$return SwapTrade.builder().product(Swap.of(payLeg, receiveLeg)).info(TradeInfo.builder().id(StandardId.of("example", "12")).addAttribute(TradeAttributeType.DESCRIPTION, "Compounding fed funds vs libor 3m").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 9, 12)).build()).build() @@ -7505,7 +4271,6 @@ MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$return SwapTrade.builder().product(Swap.of(payLeg, receiveLeg)).info(TradeInfo.builder().id(StandardId.of("example", "8")).addAttribute(TradeAttributeType.DESCRIPTION, "Fixed vs Libor 6m (interpolated 3m short initial stub)").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 9, 12)).build()).build() MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$return SwapTrade.builder().product(Swap.of(payLeg, receiveLeg)).info(TradeInfo.builder().id(StandardId.of("example", "9")).addAttribute(TradeAttributeType.DESCRIPTION, "Fixed vs Libor 6m (interpolated 4m short initial stub)").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 9, 12)).build()).build() MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$return SwapTrade.builder().product(Swap.of(receiveLeg, payLeg)).info(TradeInfo.builder().id(StandardId.of("example", "14")).addAttribute(TradeAttributeType.DESCRIPTION, "GBP Libor 3m vs USD Libor 3m").counterparty(StandardId.of("example", "A")).settlementDate(LocalDate.of(2014, 1, 24)).build()).build() - MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$val calculationResults = ReportCalculationResults.of(valuationDate, trades, columns, results, functions, refData) MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$val payLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.PAY).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 1, 24)).endDate(LocalDate.of(2021, 1, 24)).frequency(Frequency.P3M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.GBLO)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P3M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NotionalSchedule.of(Currency.GBP, 61600000.0)).calculation(IborRateCalculation.of(IborIndices.GBP_LIBOR_3M)).build() MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$val payLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.PAY).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 1, 24)).endDate(LocalDate.of(2021, 1, 24)).frequency(Frequency.P6M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.GBLO)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P6M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NotionalSchedule.builder().currency(Currency.USD).amount(ValueSchedule.of(100000000.0)).initialExchange(true).finalExchange(true).build()).calculation(FixedRateCalculation.of(0.03, DayCounts.THIRTY_U_360)).build() MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$val payLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.PAY).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 1, 24)).endDate(LocalDate.of(2021, 1, 24)).frequency(Frequency.P6M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.GBLO)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P6M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(NotionalSchedule.of(Currency.USD, 100000000.0)).calculation(FixedRateCalculation.of(0.03, DayCounts.THIRTY_U_360)).build() @@ -7525,331 +4290,132 @@ MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$val receiveLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 9, 12)).endDate(LocalDate.of(2016, 7, 12)).stubConvention(StubConvention.SHORT_INITIAL).frequency(Frequency.P6M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P6M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(notional).calculation(FixedRateCalculation.of(0.01, DayCounts.THIRTY_U_360)).build() MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$val receiveLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 9, 12)).endDate(LocalDate.of(2020, 9, 12)).frequency(Frequency.P3M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.P3M).paymentDateOffset(DaysAdjustment.NONE).build()).notionalSchedule(notional).calculation(OvernightRateCalculation.builder().index(OvernightIndices.USD_FED_FUND).accrualMethod(OvernightAccrualMethod.AVERAGED).build()).build() MaxLineLength:OGSwapPricingExample.kt$SwapPricingExample$val receiveLeg = RateCalculationSwapLeg.builder().payReceive(PayReceive.RECEIVE).accrualSchedule(PeriodicSchedule.builder().startDate(LocalDate.of(2014, 9, 12)).endDate(LocalDate.of(2021, 9, 12)).frequency(Frequency.P3M).businessDayAdjustment(BusinessDayAdjustment.of(MODIFIED_FOLLOWING, HolidayCalendarIds.USNY)).build()).paymentSchedule(PaymentSchedule.builder().paymentFrequency(Frequency.TERM).paymentDateOffset(DaysAdjustment.NONE).compoundingMethod(CompoundingMethod.STRAIGHT).build()).notionalSchedule(notional).calculation(IborRateCalculation.of(IborIndices.USD_LIBOR_3M)).build() - MaxLineLength:OGTrade.kt$OGTrade$val groups: List<LedgerTransaction.InOutGroup<IRSState, UniqueIdentifier>> = tx.groupStates { state -> state.linearId } - MaxLineLength:ObjectBuilder.kt$ConstructorCaller$"Constructor for ${javaConstructor.declaringClass} (isAccessible=${javaConstructor.isAccessible}) " - MaxLineLength:ObjectBuilder.kt$EvolutionObjectBuilder.Companion$ fun makeProvider(typeIdentifier: TypeIdentifier, constructor: LocalConstructorInformation, localProperties: Map<String, LocalPropertyInformation>, remoteTypeInformation: RemoteTypeInformation.Composable, mustPreserveData: Boolean): () -> ObjectBuilder - MaxLineLength:ObjectBuilder.kt$ObjectBuilder.Companion$ConstructorBasedObjectBuilder(ConstructorCaller(constructor.observedMethod), constructorIndices.values.toIntArray()) - MaxLineLength:ObjectBuilder.kt$ObjectBuilder.Companion$is LocalPropertyInformation.PrivateConstructorPairedProperty -> property.constructorSlot.parameterIndex MaxLineLength:ObjectBuilder.kt$ObjectBuilder.Companion$private - MaxLineLength:ObjectBuilder.kt$ObjectBuilderProvider : - MaxLineLength:ObjectDiffer.kt$DiffTree$is Step -> branches.flatMap { (step, tree) -> tree.toPaths().map { it.copy(path = listOf(step) + it.path) } } - MaxLineLength:ObjectDiffer.kt$ObjectDiffer$val branches = aFields.mapNotNull { field -> diff(field.get(a), field.get(b))?.let { field.name to it } } MaxLineLength:ObjectSerializer.kt$AbstractObjectSerializer$override - MaxLineLength:ObjectSerializer.kt$ComposableObjectReader$"${propertySerializers.size} properties in described type ${typeIdentifier.prettyPrint(false)}" - MaxLineLength:ObjectSerializer.kt$ComposableObjectReader$fun readObject(obj: Any, schemas: SerializationSchemas, input: DeserializationInput, context: SerializationContext): Any MaxLineLength:ObjectSerializer.kt$ComposableObjectSerializer$override - MaxLineLength:ObjectSerializer.kt$ComposableObjectWriter$fun writeObject(obj: Any, data: Data, type: Type, output: SerializationOutput, context: SerializationContext, debugIndent: Int) MaxLineLength:ObjectSerializer.kt$EvolutionObjectSerializer$override - MaxLineLength:ObjectSerializer.kt$EvolutionObjectSerializer.Companion$ComposableTypePropertySerializer.makeForEvolution(name, isCalculated, property.type.typeIdentifier, type) - MaxLineLength:ObjectSerializer.kt$EvolutionObjectSerializer.Companion$val type = localProperty?.type?.observedType ?: property.type.typeIdentifier.getLocalType(classLoader) - MaxLineLength:ObjectSerializer.kt$ObjectSerializer.Companion$"Trying to build an object serializer for ${typeInformation.typeIdentifier.prettyPrint(false)}, " - MaxLineLength:ObjectSerializer.kt$ObjectSerializer.Companion$val writer = ComposableObjectWriter(typeNotation, typeInformation.interfacesOrEmptyList, propertySerializers) - MaxLineLength:Obligation.kt$ fun <P : AbstractParty, T : Any> sumAmountsDue(balances: Map<Pair<P, P>, Amount<T>>): Map<P, Long> MaxLineLength:Obligation.kt$ fun <P : Any> extractAmountsDue(product: Obligation.Terms<P>, states: Iterable<Obligation.State<P>>): Map<Pair<AbstractParty, AbstractParty>, Amount<Obligation.Terms<P>>> MaxLineLength:Obligation.kt$Obligation$"amount in settle command ${command.value.amount} matches settled total $totalAmountSettled" using (command.value.amount == totalAmountSettled) - MaxLineLength:Obligation.kt$Obligation$"amounts paid must match recipients to settle" using inputs.map { it.owner }.containsAll(amountReceivedByOwner.keys) - MaxLineLength:Obligation.kt$Obligation$"output state corresponds exactly to input state, with lifecycle changed" using (expectedOutput == actualOutput) - MaxLineLength:Obligation.kt$Obligation$// Insist that we can be the only contract consuming inputs, to ensure no other contract can think it's being // settled as well "all move commands relate to this contract" using (moveCommands.map { it.value.contract } .all { it == null || it == this@Obligation.javaClass }) // Settle commands exclude all other commands, so we don't need to check for contracts moving at the same // time. "amounts paid must match recipients to settle" using inputs.map { it.owner }.containsAll(amountReceivedByOwner.keys) "amount in settle command ${command.value.amount} matches settled total $totalAmountSettled" using (command.value.amount == totalAmountSettled) "signatures are present from all obligors" using command.signers.containsAll(requiredSigners) "there are no zero sized inputs" using inputs.none { it.amount.quantity == 0L } "at obligor $obligor the obligations after settlement balance" using (inputAmount == outputAmount + Amount(totalPenniesSettled, groupingKey)) - MaxLineLength:Obligation.kt$Obligation$NetType.CLOSE_OUT -> require(command.signers.intersect(involvedParties).isNotEmpty()) { "any involved party has signed" } - MaxLineLength:Obligation.kt$Obligation$NetType.PAYMENT -> require(command.signers.containsAll(involvedParties)) { "all involved parties have signed" } MaxLineLength:Obligation.kt$Obligation$val exitCommand = tx.commands.select<Commands.Exit<P>>(parties = null, signers = exitKeys).singleOrNull { it.value.amount.token == key } MaxLineLength:Obligation.kt$Obligation$val inputAmount = inputs.sumObligationsOrNull<P>() ?: throw IllegalArgumentException("there is at least one obligation input for this group") MaxLineLength:Obligation.kt$Obligation$val inputAmount: Amount<Issued<Terms<P>>> = inputs.sumObligationsOrNull() ?: throw IllegalArgumentException("there is at least one obligation input for this group") MaxLineLength:Obligation.kt$Obligation$val involvedParties: Set<PublicKey> = groupInputs.map { it.beneficiary.owningKey }.union(groupInputs.map { it.obligor.owningKey }).toSet() - MaxLineLength:Obligation.kt$Obligation${ val template = key.template // Create two maps of balances from obligors to beneficiaries, one for input states, the other for output states. val inputBalances = extractAmountsDue(template, groupInputs) val outputBalances = extractAmountsDue(template, groupOutputs) // Sum the columns of the matrices. This will yield the net amount payable to/from each party to/from all other participants. // The two summaries must match, reflecting that the amounts owed match on both input and output. requireThat { "all input states use the same template" using (groupInputs.all { it.template == template }) "all output states use the same template" using (groupOutputs.all { it.template == template }) "amounts owed on input and output must match" using (sumAmountsDue(inputBalances) == sumAmountsDue (outputBalances)) } // TODO: Handle proxies nominated by parties, i.e. a central clearing service val involvedParties: Set<PublicKey> = groupInputs.map { it.beneficiary.owningKey }.union(groupInputs.map { it.obligor.owningKey }).toSet() when (command.value.type) { // For close-out netting, allow any involved party to sign NetType.CLOSE_OUT -> require(command.signers.intersect(involvedParties).isNotEmpty()) { "any involved party has signed" } // Require signatures from all parties (this constraint can be changed for other contracts, and is used as a // placeholder while exact requirements are established), or fail the transaction. NetType.PAYMENT -> require(command.signers.containsAll(involvedParties)) { "all involved parties have signed" } } } - MaxLineLength:Obligation.kt$Obligation.Commands$SetLifecycle : CommandData - MaxLineLength:Obligation.kt$Obligation.State$override fun withNewOwner(newOwner: AbstractParty) MaxLineLength:Obligation.kt$infix fun <T : Any> Obligation.State<T>.between(parties: Pair<AbstractParty, AbstractParty>) - MaxLineLength:ObligationTests.kt$ObligationTests$ @Test fun `generate close-out net transaction with remainder`() - MaxLineLength:ObligationTests.kt$ObligationTests$ @Test fun `generate payment net transaction with remainder`() MaxLineLength:ObligationTests.kt$ObligationTests$ObligationUtils.generatePaymentNetting(this, obligationAliceToBob.state.data.amount.token, DUMMY_NOTARY, obligationAliceToBob, obligationBobToAlice) MaxLineLength:ObligationTests.kt$ObligationTests$ObligationUtils.generatePaymentNetting(this, obligationAliceToBobState.amount.token, DUMMY_NOTARY, obligationAliceToBob, obligationBobToAlice) MaxLineLength:ObligationTests.kt$ObligationTests$ObligationUtils.generateSettle(this, listOf(obligationTx.outRef<Obligation.State<Currency>>(0)), listOf(cashTx.outRef(0)), Cash.Commands.Move(), DUMMY_NOTARY) MaxLineLength:ObligationTests.kt$ObligationTests$assertNotEquals(oneKDollarsFromMiniToMega.bilateralNetState, oneKDollarsFromMiniToMega.copy(template = megaCorpPoundSettlement).bilateralNetState) - MaxLineLength:ObligationTests.kt$ObligationTests$command(ALICE_PUBKEY, Obligation.Commands.Settle(Amount(oneMillionDollars.quantity / 2, inState.amount.token))) - MaxLineLength:ObligationTests.kt$ObligationTests$command(ALICE_PUBKEY, Obligation.Commands.Settle(Amount(oneMillionDollars.quantity, inState.amount.token))) - MaxLineLength:ObligationTests.kt$ObligationTests$command(ALICE_PUBKEY, Obligation.Commands.Settle(Amount(oneUnitFcoj.quantity, oneUnitFcojObligation.amount.token))) MaxLineLength:ObligationTests.kt$ObligationTests$command(CHARLIE.owningKey, Obligation.Commands.Exit(Amount(200.DOLLARS.quantity, inState.amount.token.copy(product = megaCorpDollarSettlement)))) MaxLineLength:ObligationTests.kt$ObligationTests$command(CHARLIE.owningKey, Obligation.Commands.Exit(Amount(200.POUNDS.quantity, inState.amount.token.copy(product = megaCorpPoundSettlement)))) MaxLineLength:ObligationTests.kt$ObligationTests$fiveKDollarsFromMegaToMega.copy(template = megaCorpDollarSettlement.copy(acceptableContracts = NonEmptySet.of(SecureHash.randomSHA256()))).bilateralNetState MaxLineLength:ObligationTests.kt$ObligationTests$fiveKDollarsFromMegaToMega.copy(template = megaCorpDollarSettlement.copy(acceptableIssuedProducts = miniCorpIssuer)).bilateralNetState - MaxLineLength:ObligationTests.kt$ObligationTests$fiveKDollarsFromMegaToMega.copy(template = megaCorpDollarSettlement.copy(dueBefore = sixPm)).bilateralNetState - MaxLineLength:ObligationTests.kt$ObligationTests$fiveKDollarsFromMegaToMini - MaxLineLength:ObligationTests.kt$ObligationTests$get() = Obligation.State(Obligation.Lifecycle.NORMAL, DUMMY_OBLIGATION_ISSUER, token.OBLIGATION_DEF, quantity, NULL_PARTY) - MaxLineLength:ObligationTests.kt$ObligationTests$get() = Obligation.Terms(NonEmptySet.of(cashContractBytes.sha256() as SecureHash), NonEmptySet.of(this), TEST_TX_TIME) - MaxLineLength:ObligationTests.kt$ObligationTests$input(Obligation.PROGRAM_ID, inState.copy(template = inState.template.copy(acceptableIssuedProducts = megaIssuedDollars))) - MaxLineLength:ObligationTests.kt$ObligationTests$input(Obligation.PROGRAM_ID, inState.copy(template = inState.template.copy(acceptableIssuedProducts = megaIssuedPounds))) - MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, "Alice's $1,000,000 obligation to Bob", oneMillionDollars.OBLIGATION between Pair(ALICE, BOB)) - MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, "Alice's $500,000 obligation to Bob", halfAMillionDollars.OBLIGATION between Pair(ALICE, BOB)) - MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, "Alice's 1 FCOJ obligation to Bob", oneUnitFcojObligation between Pair(ALICE, BOB)) MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, "Alice's defaulted $1,000,000 obligation to Bob", (oneMillionDollars.OBLIGATION between Pair(ALICE, BOB) at futureTestTime).copy(lifecycle = Lifecycle.DEFAULTED)) MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, "Alice's defaulted $1,000,000 obligation to Bob", (oneMillionDollars.OBLIGATION between Pair(ALICE, BOB) at pastTestTime).copy(lifecycle = Lifecycle.DEFAULTED)) MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, "Alice's defaulted $1,000,000 obligation to Bob", (oneMillionDollars.OBLIGATION between Pair(ALICE, BOB)).copy(lifecycle = Lifecycle.DEFAULTED)) - MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, "Bob's $1,000,000 obligation to Alice", oneMillionDollars.OBLIGATION between Pair(BOB, ALICE)) MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, "MegaCorp's $1,000,000 obligation to Alice", oneMillionDollars.OBLIGATION between Pair(MEGA_CORP, ALICE)) MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, "MegaCorp's $1,000,000 obligation to Bob", oneMillionDollars.OBLIGATION between Pair(MEGA_CORP, BOB)) - MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, "change", oneMillionDollars.splitEvenly(2).first().OBLIGATION between Pair(ALICE, BOB)) - MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, inState.copy(beneficiary = AnonymousParty(BOB_PUBKEY), quantity = 200000L)) MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, inState.copy(template = inState.template.copy(acceptableIssuedProducts = megaIssuedDollars), quantity = inState.quantity - 200.DOLLARS.quantity)) MaxLineLength:ObligationTests.kt$ObligationTests$output(Obligation.PROGRAM_ID, inState.copy(template = inState.template.copy(acceptableIssuedProducts = megaIssuedPounds), quantity = inState.quantity - 200.POUNDS.quantity)) - MaxLineLength:ObligationTests.kt$ObligationTests$private - MaxLineLength:ObligationTests.kt$ObligationTests$private inline - MaxLineLength:ObligationTests.kt$ObligationTests$private val cashContractBytes = fakeAttachment("file1.txt", "https://www.big-book-of-banking-law.gov/cash-claims.html") MaxLineLength:ObligationTests.kt$ObligationTests$private val ledgerServices get() = MockServices(listOf("net.corda.finance.contracts.asset", "net.corda.testing.contracts"), MEGA_CORP.name, identityService) - MaxLineLength:ObligationTests.kt$ObligationTests$val commodityContractBytes = fakeAttachment("file1.txt", "https://www.big-book-of-banking-law.gov/commodity-claims.html") MaxLineLength:ObligationTests.kt$ObligationTests$val defaultedObligation: Obligation.State<Currency> = (oneMillionDollars.OBLIGATION between Pair(ALICE, BOB)).copy(lifecycle = Lifecycle.DEFAULTED) - MaxLineLength:ObligationTests.kt$ObligationTests$val expected = obligationBobToAliceState.copy(quantity = obligationBobToAliceState.quantity - obligationAliceToBobState.quantity) - MaxLineLength:ObligationTests.kt$ObligationTests$val expected: Map<Pair<AbstractParty, AbstractParty>, Amount<Currency>> = emptyMap() // Zero balances are stripped before returning MaxLineLength:ObligationTests.kt$ObligationTests$val expected: Map<Pair<AbstractParty, AbstractParty>, Amount<Obligation.Terms<Currency>>> = mapOf(Pair(Pair(MEGA_CORP, MINI_CORP), Amount(amount.quantity, amount.token.product))) MaxLineLength:ObligationTests.kt$ObligationTests$val obligationAliceToBob = getStateAndRef((2000000.DOLLARS `issued by` defaultIssuer).OBLIGATION between Pair(ALICE, BOB), Obligation.PROGRAM_ID) - MaxLineLength:ObligationTests.kt$ObligationTests$val obligationAliceToBob = getStateAndRef(oneMillionDollars.OBLIGATION between Pair(ALICE, BOB), Obligation.PROGRAM_ID) MaxLineLength:ObligationTests.kt$ObligationTests$val obligationBobToAlice = getStateAndRef((2000000.DOLLARS `issued by` defaultIssuer).OBLIGATION between Pair(BOB, ALICE), Obligation.PROGRAM_ID) - MaxLineLength:ObligationTests.kt$ObligationTests$val obligationBobToAlice = getStateAndRef(oneMillionDollars.OBLIGATION between Pair(BOB, ALICE), Obligation.PROGRAM_ID) MaxLineLength:ObligationTests.kt$ObligationTests$val obligationDef = Obligation.Terms(NonEmptySet.of(commodityContractBytes.sha256() as SecureHash), NonEmptySet.of(defaultFcoj), TEST_TX_TIME) MaxLineLength:ObligationTests.kt$ObligationTests$val pounds = Obligation.State(Lifecycle.NORMAL, MINI_CORP, megaCorpPoundSettlement, 658.POUNDS.quantity, AnonymousParty(BOB_PUBKEY)) - MaxLineLength:ObligationTests.kt$ObligationTests$val simple: Map<Pair<AbstractParty, AbstractParty>, Amount<Currency>> = mapOf(Pair(Pair(ALICE, BOB), Amount(100000000, GBP))) - MaxLineLength:ObligationTests.kt$ObligationTests$val txState = TransactionState(state, contractClassName, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint) MaxLineLength:ObligationTests.kt$ObligationTests.<no name provided>$override fun loadState(stateRef: StateRef): TransactionState<*> - MaxLineLength:ObligationUtils.kt$ObligationUtils$ @JvmStatic fun <P : Any> generateCloseOutNetting(tx: TransactionBuilder, signer: AbstractParty, vararg inputs: StateAndRef<Obligation.State<P>>) MaxLineLength:ObligationUtils.kt$ObligationUtils$"all obligation states are in the normal state" using (statesAndRefs.all { it.state.data.lifecycle == Obligation.Lifecycle.NORMAL }) - MaxLineLength:ObligationUtils.kt$ObligationUtils$"all obligation states have the same beneficiary" using (statesAndRefs.all { it.state.data.beneficiary == obligationOwner }) - MaxLineLength:ObligationUtils.kt$ObligationUtils$"all obligation states have the same obligor" using (statesAndRefs.all { it.state.data.obligor == obligationIssuer }) - MaxLineLength:ObligationUtils.kt$ObligationUtils$"all states are in the normal lifecycle state " using (states.all { it.lifecycle == Obligation.Lifecycle.NORMAL }) - MaxLineLength:ObligationUtils.kt$ObligationUtils$Obligation.State(Obligation.Lifecycle.NORMAL, obligor, issuanceDef, amount.quantity, beneficiary) - MaxLineLength:ObligationUtils.kt$ObligationUtils$deriveState = { state, amount, owner -> state.copy(data = state.data.withNewOwnerAndAmount(amount, owner)) } - MaxLineLength:ObligationUtils.kt$ObligationUtils$private - MaxLineLength:ObligationUtils.kt$ObligationUtils$require(states.all { it.lifecycle == existingLifecycle }) { "initial lifecycle must be $existingLifecycle for all input states" } MaxLineLength:ObligationUtils.kt$ObligationUtils$tx.addCommand(Obligation.Commands.Settle(Amount((obligationTotal - obligationRemaining).quantity, issuanceDef)), obligationIssuer.owningKey) MaxLineLength:ObligationUtils.kt$ObligationUtils$tx.addOutputState(Obligation.State(Obligation.Lifecycle.NORMAL, obligationIssuer, template, obligationRemaining.quantity, obligationOwner), Obligation.PROGRAM_ID, notary) MaxLineLength:ObligationUtils.kt$ObligationUtils$tx.addOutputState(assetState.withNewOwnerAndAmount(assetState.amount - change, assetState.owner), Obligation.PROGRAM_ID, notary) - MaxLineLength:ObligationUtils.kt$ObligationUtils$tx.addOutputState(assetState.withNewOwnerAndAmount(assetState.amount, obligationOwner), Obligation.PROGRAM_ID, notary) - MaxLineLength:ObligationUtils.kt$ObligationUtils$tx.addOutputState(assetState.withNewOwnerAndAmount(change, obligationOwner), Obligation.PROGRAM_ID, notary) - MaxLineLength:ObligationUtils.kt$ObligationUtils$val changeOwner = assetStates.map { it.state.data.owner }.toSet().firstOrNull() ?: throw InsufficientBalanceException(amountIssued) - MaxLineLength:ObligationUtils.kt$ObligationUtils${ val states = statesAndRefs.map { it.state } val obligationIssuer = states.first().data.obligor val obligationOwner = states.first().data.beneficiary requireThat { "all fungible asset states use the same notary" using (assetStatesAndRefs.all { it.state.notary == notary }) "all obligation states are in the normal state" using (statesAndRefs.all { it.state.data.lifecycle == Obligation.Lifecycle.NORMAL }) "all obligation states use the same notary" using (statesAndRefs.all { it.state.notary == notary }) "all obligation states have the same obligor" using (statesAndRefs.all { it.state.data.obligor == obligationIssuer }) "all obligation states have the same beneficiary" using (statesAndRefs.all { it.state.data.beneficiary == obligationOwner }) } // TODO: A much better (but more complex) solution would be to have two iterators, one for obligations, // one for the assets, and step through each in a semi-synced manner. For now however we just bundle all the states // on each side together val issuanceDef = getIssuanceDefinitionOrThrow(statesAndRefs.map { it.state.data }) val template: Obligation.Terms<P> = issuanceDef.product val obligationTotal: Amount<P> = Amount(states.map { it.data }.sumObligations<P>().quantity, template.product) var obligationRemaining: Amount<P> = obligationTotal val assetSigners = HashSet<AbstractParty>() statesAndRefs.forEach { tx.addInputState(it) } // Move the assets to the new beneficiary assetStatesAndRefs.forEach { ref -> if (obligationRemaining.quantity > 0L) { tx.addInputState(ref) val assetState = ref.state.data val amount = Amount(assetState.amount.quantity, assetState.amount.token.product) obligationRemaining -= if (obligationRemaining >= amount) { tx.addOutputState(assetState.withNewOwnerAndAmount(assetState.amount, obligationOwner), Obligation.PROGRAM_ID, notary) amount } else { val change = Amount(obligationRemaining.quantity, assetState.amount.token) // Split the state in two, sending the change back to the previous beneficiary tx.addOutputState(assetState.withNewOwnerAndAmount(change, obligationOwner), Obligation.PROGRAM_ID, notary) tx.addOutputState(assetState.withNewOwnerAndAmount(assetState.amount - change, assetState.owner), Obligation.PROGRAM_ID, notary) Amount(0L, obligationRemaining.token) } assetSigners.add(assetState.owner) } } // If we haven't cleared the full obligation, add the remainder as an output if (obligationRemaining.quantity > 0L) { tx.addOutputState(Obligation.State(Obligation.Lifecycle.NORMAL, obligationIssuer, template, obligationRemaining.quantity, obligationOwner), Obligation.PROGRAM_ID, notary) } else { // Destroy all of the states } // Add the asset move command and obligation settle tx.addCommand(moveCommand, assetSigners.map { it.owningKey }) tx.addCommand(Obligation.Commands.Settle(Amount((obligationTotal - obligationRemaining).quantity, issuanceDef)), obligationIssuer.owningKey) } MaxLineLength:ObservableFold.kt$ fun <A, K> Observable<A>.recordAsAssociation(toKey: (A) -> K, merge: (K, oldValue: A, newValue: A) -> A = { _, _, newValue -> newValue }): ObservableMap<K, A> - MaxLineLength:ObservableFold.kt$ fun <T, R> Observable<T>.fold(accumulator: R, folderFun: (R, T) -> Unit): R - MaxLineLength:ObservableUtilities.kt$ fun <A> Collection<ObservableValue<out A>>.sequence(): ObservableList<A> MaxLineLength:ObservableUtilities.kt$ fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>> - MaxLineLength:ObservableUtilities.kt$ fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>> - MaxLineLength:ObservableUtilities.kt$Pair(left, ChosenList(rightValue.map { it ?: FXCollections.emptyObservableList() }, "ChosenList from leftOuterJoin")) - MaxLineLength:ObservableUtilities.kt$net.corda.client.jfx.utils.ObservableUtilities.kt - MaxLineLength:ObservableUtilities.kt$return AssociatedList(AggregatedList(this, toKey) { key, members -> Pair(key, members) }, { it.first }) { key, pair -> pair.second.map { assemble(key, it) } } MaxLineLength:ObservableUtilities.kt${ //TODO This is a tactical work round for an issue with SAM conversion (https://youtrack.jetbrains.com/issue/ALL-1552) so that the M10 explorer works. return uncheckedCast(uncheckedCast<Any, ObservableList<A?>>(this).filtered { t -> t != null }) } - MaxLineLength:ObserverNodeTransactionTests.kt$ObserverNodeTransactionTests$ReportToCounterparty : FlowLogic - MaxLineLength:ObserverNodeTransactionTests.kt$ObserverNodeTransactionTests$StartMessageChainFlow : FlowLogic MaxLineLength:ObserverNodeTransactionTests.kt$ObserverNodeTransactionTests$node.services.startFlow(ReportToCounterparty(regulator.info.singleIdentity(), transactionList[transactionIdx])).resultFuture.getOrThrow() - MaxLineLength:ObserverNodeTransactionTests.kt$ObserverNodeTransactionTests.ContinueMessageChainFlow$val txCommand = Command(MessageChainContract.Commands.Send(), messageState.participants.map { it.owningKey }) - MaxLineLength:ObserverNodeTransactionTests.kt$ObserverNodeTransactionTests.ContinueMessageChainFlow.Companion$FINALISING_TRANSACTION : Step - MaxLineLength:ObserverNodeTransactionTests.kt$ObserverNodeTransactionTests.ContinueMessageChainFlow.Companion$fun tracker() MaxLineLength:ObserverNodeTransactionTests.kt$ObserverNodeTransactionTests.StartMessageChainFlow$val txBuilder = TransactionBuilder(notary).withItems(StateAndContract(messageState, MESSAGE_CHAIN_CONTRACT_PROGRAM_ID), txCommand) - MaxLineLength:ObserverNodeTransactionTests.kt$ObserverNodeTransactionTests.StartMessageChainFlow$val txCommand = Command(MessageChainContract.Commands.Send(), messageState.participants.map { it.owningKey }) - MaxLineLength:ObserverNodeTransactionTests.kt$ObserverNodeTransactionTests.StartMessageChainFlow.Companion$FINALISING_TRANSACTION : Step - MaxLineLength:ObserverNodeTransactionTests.kt$ObserverNodeTransactionTests.StartMessageChainFlow.Companion$fun tracker() MaxLineLength:OffsetDateTimeSerializer.kt$OffsetDateTimeSerializer : Proxy - MaxLineLength:OffsetDateTimeSerializer.kt$OffsetDateTimeSerializer$override fun toProxy(obj: OffsetDateTime): OffsetDateTimeProxy MaxLineLength:OffsetDateTimeSerializer.kt$OffsetDateTimeSerializer$override val additionalSerializers: Iterable<CustomSerializer<out Any>> = listOf(LocalDateTimeSerializer(factory), ZoneIdSerializer(factory)) MaxLineLength:OffsetTimeSerializer.kt$OffsetTimeSerializer : Proxy MaxLineLength:OffsetTimeSerializer.kt$OffsetTimeSerializer$override val additionalSerializers: Iterable<CustomSerializer<out Any>> = listOf(LocalTimeSerializer(factory), ZoneIdSerializer(factory)) - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset$abstract - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset$abstract fun extractCommands(commands: Collection<CommandWithParties<CommandData>>): Collection<CommandWithParties<C>> - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset$val changeOwner = assetStates.map { it.state.data.owner }.toSet().firstOrNull() ?: throw InsufficientBalanceException(amountIssued) - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$ @Throws(InsufficientBalanceException::class) @JvmStatic @Deprecated("Replaced with generateExit() which takes in a party to pay change to") fun <S : FungibleAsset<T>, T : Any> generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, assetStates: List<StateAndRef<S>>, deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>, generateMoveCommand: () -> CommandData, generateExitCommand: (Amount<Issued<T>>) -> CommandData): Set<PublicKey> - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$ @Throws(InsufficientBalanceException::class) @JvmStatic fun <S : FungibleAsset<T>, T : Any> generateExit(tx: TransactionBuilder, amountIssued: Amount<Issued<T>>, assetStates: List<StateAndRef<S>>, payChangeTo: AbstractParty, deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S>, generateMoveCommand: () -> CommandData, generateExitCommand: (Amount<Issued<T>>) -> CommandData): Set<PublicKey> - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$amount: Amount<T> MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$deriveState: (TransactionState<S>, Amount<Issued<T>>, AbstractParty) -> TransactionState<S> - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$generateExitCommand: (Amount<Issued<T>>) -> CommandData MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$generateMoveCommand: () -> CommandData - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$log.trace { "Gathered coins: requested $amount, available $gatheredAmount, change: ${gatheredAmount - amount}" } - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$remainingFromEachIssuer[remainingFromEachIssuer.lastIndex] = Pair(token, Amount(delta, token)) - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$return generateExit(tx, amountIssued, assetStates, owner, deriveState, generateMoveCommand, generateExitCommand) - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$return generateSpend(tx, listOf(PartyAndAmount(to, amount)), acceptableStates, payChangeTo, deriveState, generateMoveCommand) - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion$val owner = assetStates.map { it.state.data.owner }.toSet().firstOrNull() ?: throw InsufficientBalanceException(amountIssued) - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion${ // Discussion // // This code is analogous to the Wallet.send() set of methods in bitcoinj, and has the same general outline. // // First we must select a set of asset states (which for convenience we will call 'coins' here, as in bitcoinj). // The input states can be considered our "vault", and may consist of different products, and with different // issuers and deposits. // // Coin selection is a complex problem all by itself and many different approaches can be used. It is easily // possible for different actors to use different algorithms and approaches that, for example, compete on // privacy vs efficiency (number of states created). Some spends may be artificial just for the purposes of // obfuscation and so on. // // Having selected input states of the correct asset, we must craft output states for the amount we're sending and // the "change", which goes back to us. The change is required to make the amounts balance. We may need more // than one change output in order to avoid merging assets from different deposits. The point of this design // is to ensure that ledger entries are immutable and globally identifiable. // // Finally, we add the states to the provided partial transaction. // TODO: We should be prepared to produce multiple transactions spending inputs from // different notaries, or at least group states by notary and take the set with the // highest total value. // TODO: Check that re-running this on the same transaction multiple times does the right thing. // The notary may be associated with a locked state only. tx.notary = acceptableStates.firstOrNull()?.state?.notary // Calculate the total amount we're sending (they must be all of a compatible token). val totalSendAmount = payments.map { it.amount }.sumOrThrow() // Select a subset of the available states we were given that sums up to >= totalSendAmount. val (gathered, gatheredAmount) = gatherCoins(acceptableStates, totalSendAmount) check(gatheredAmount >= totalSendAmount) val keysUsed = gathered.map { it.state.data.owner.owningKey } // Now calculate the output states. This is complicated by the fact that a single payment may require // multiple output states, due to the need to keep states separated by issuer. We start by figuring out // how much we've gathered for each issuer: this map will keep track of how much we've used from each // as we work our way through the payments. val statesGroupedByIssuer = gathered.groupBy { it.state.data.amount.token } val remainingFromEachIssuer = statesGroupedByIssuer .mapValues { it.value.map { it.state.data.amount }.sumOrThrow() }.toList().toMutableList() val outputStates = mutableListOf<TransactionState<S>>() for ((party, paymentAmount) in payments) { var remainingToPay = paymentAmount.quantity while (remainingToPay > 0) { val (token, remainingFromCurrentIssuer) = remainingFromEachIssuer.last() val templateState = statesGroupedByIssuer[token]!!.first().state val delta = remainingFromCurrentIssuer.quantity - remainingToPay when { delta > 0 -> { // The states from the current issuer more than covers this payment. outputStates += deriveState(templateState, Amount(remainingToPay, token), party) remainingFromEachIssuer[remainingFromEachIssuer.lastIndex] = Pair(token, Amount(delta, token)) remainingToPay = 0 } delta == 0L -> { // The states from the current issuer exactly covers this payment. outputStates += deriveState(templateState, Amount(remainingToPay, token), party) remainingFromEachIssuer.removeAt(remainingFromEachIssuer.lastIndex) remainingToPay = 0 } delta < 0 -> { // The states from the current issuer don't cover this payment, so we'll have to use >1 output // state to cover this payment. outputStates += deriveState(templateState, remainingFromCurrentIssuer, party) remainingFromEachIssuer.removeAt(remainingFromEachIssuer.lastIndex) remainingToPay -= remainingFromCurrentIssuer.quantity } } } } // Whatever values we have left over for each issuer must become change outputs. for ((token, amount) in remainingFromEachIssuer) { val templateState = statesGroupedByIssuer[token]!!.first().state outputStates += deriveState(templateState, amount, payChangeTo) } for (state in gathered) tx.addInputState(state) for (state in outputStates) tx.addOutputState(state) // What if we already have a move command with the right keys? Filter it out here or in platform code? tx.addCommand(generateMoveCommand(), keysUsed) return Pair(tx, keysUsed) } - MaxLineLength:OnLedgerAsset.kt$OnLedgerAsset.Companion${ // The states from the current issuer don't cover this payment, so we'll have to use >1 output // state to cover this payment. outputStates += deriveState(templateState, remainingFromCurrentIssuer, party) remainingFromEachIssuer.removeAt(remainingFromEachIssuer.lastIndex) remainingToPay -= remainingFromCurrentIssuer.quantity } - MaxLineLength:OpaqueBytesSubSequenceSerializer.kt$OpaqueBytesSubSequenceSerializer$CustomSerializer.Proxy<OpaqueBytesSubSequence, OpaqueBytes>(OpaqueBytesSubSequence::class.java, OpaqueBytes::class.java, factory) - MaxLineLength:OpaqueBytesSubSequenceSerializer.kt$OpaqueBytesSubSequenceSerializer$override fun fromProxy(proxy: OpaqueBytes): OpaqueBytesSubSequence MaxLineLength:OpenGammaCordaUtils.kt$ fun InitialMarginTriple.toCordaCompatible() MaxLineLength:OpenGammaCordaUtils.kt$return MultiCurrencyAmount.of(this.amounts.map { CurrencyAmount.of(Currency.of(it.currency.code).serialize().deserialize(), twoDecimalPlaces((it.amount))) }) MaxLineLength:OptionalSerializer.kt$OptionalSerializer : Proxy MaxLineLength:OracleNodeTearOffTests.kt$OracleNodeTearOffTests$TransactionBuilder(DUMMY_NOTARY) .withItems(TransactionState(1000.DOLLARS.CASH issuedBy dummyCashIssuer.party ownedBy alice.party, Cash.PROGRAM_ID, DUMMY_NOTARY)) - MaxLineLength:OracleNodeTearOffTests.kt$OracleNodeTearOffTests$TransactionState(1000.DOLLARS.CASH issuedBy dummyCashIssuer.party ownedBy alice.party, Cash.PROGRAM_ID, DUMMY_NOTARY) - MaxLineLength:OverridePKSerializerTest.kt$OverridePKSerializerTest.TestPublicKeySerializer$get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templates. - MaxLineLength:P2PFlowsDrainingModeTest.kt$P2PFlowsDrainingModeTest$driver MaxLineLength:P2PFlowsDrainingModeTest.kt$P2PFlowsDrainingModeTest$nodeA.rpc.hasCancelledDrainingShutdown().doOnError(Throwable::printStackTrace).doOnError { successful = false }.doOnCompleted { successful = true }.doAfterTerminate(latch::countDown).subscribe() MaxLineLength:P2PFlowsDrainingModeTest.kt$P2PFlowsDrainingModeTest$nodeA.rpc.waitForShutdown().doOnError(Throwable::printStackTrace).doOnError { successful = false }.doOnCompleted(nodeA::stop) MaxLineLength:P2PFlowsDrainingModeTest.kt$P2PFlowsDrainingModeTest$nodeA.waitForShutdown().doOnError(Throwable::printStackTrace).doAfterTerminate { successful = false }.doAfterTerminate(latch::countDown).subscribe() MaxLineLength:P2PFlowsDrainingModeTest.kt$P2PFlowsDrainingModeTest$nodeA.waitForShutdown().doOnError(Throwable::printStackTrace).doOnError { successful = false }.doOnCompleted { successful = true }.doAfterTerminate(latch::countDown).subscribe() MaxLineLength:P2PFlowsDrainingModeTest.kt$P2PFlowsDrainingModeTest$val nodeA = startNode(providedName = ALICE_NAME, rpcUsers = users).getOrThrow() var successful = false val latch = CountDownLatch(1) // This would not be needed, as `terminate(true)` sets draining mode anyway, but it's here to ensure that it removes the persistent value anyway. nodeA.rpc.setFlowsDrainingModeEnabled(true) nodeA.rpc.waitForShutdown().doOnError(Throwable::printStackTrace).doOnError { successful = false }.doOnCompleted(nodeA::stop).doOnCompleted { val nodeARestarted = startNode(providedName = ALICE_NAME, rpcUsers = users).getOrThrow() successful = !nodeARestarted.rpc.isFlowsDrainingModeEnabled() }.doAfterTerminate(latch::countDown).subscribe() nodeA.rpc.terminate(true) latch.await() assertThat(successful).isTrue() - MaxLineLength:P2PMessageDeduplicator.kt$P2PMessageDeduplicator$fromPersistentEntity = { Pair(DeduplicationId(it.id), MessageMeta(it.insertionTime, it.hash, it.seqNo)) } MaxLineLength:P2PMessageDeduplicator.kt$P2PMessageDeduplicator$private - MaxLineLength:P2PMessageDeduplicator.kt$P2PMessageDeduplicator$private fun isDuplicateInDatabase(msg: ReceivedMessage): Boolean MaxLineLength:P2PMessageDeduplicator.kt$P2PMessageDeduplicator$val senderHash: String? = if (receivedSenderUUID != null && receivedSenderSeqNo != null) senderHash(SenderKey(receivedSenderUUID, msg.peer, msg.isSessionInit)) else null - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient : SingletonSerializeAsTokenMessagingServiceAddressToArtemisQueueResolver MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$ fun start(myIdentity: PublicKey, serviceIdentity: PublicKey?, maxMessageSize: Int, advertisedAddress: NetworkHostAndPort = serverAddress) - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$// Never time out on our loopback Artemis connections. If we switch back to using the InVM transport this // would be the default and the two lines below can be deleted. connectionTTL = 60000 clientFailureCheckPeriod = 30000 minLargeMessageSize = maxMessageSize + JOURNAL_HEADER_SIZE isUseGlobalPools = nodeSerializationEnv != null - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$deliverTo(msg, HandlerRegistration(msg.topic, deliverTo), MessageDeduplicationHandler(artemisMessage, msg)) MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$log.trace { "Received message from: ${message.address} user: $user topic: $topic id: $uniqueMessageId senderUUID: $receivedSenderUUID senderSeqNo: $receivedSenderSeqNo isSessionInit: $isSessionInit" } - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$log.warn("Received message ${msg.uniqueMessageId} for ${msg.topic} that doesn't have any registered handlers yet") MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$override - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$p2pConsumer = P2PMessagingConsumer(inboxes, createNewSession, isDrainingModeOn, drainingModeWasChangedEvents) - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$p2pConsumer!!.messages // this `run()` method is semantically meant to block until the message consumption runs, hence the latch here .doOnCompleted(latch::countDown) MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$return ArtemisReceivedMessage(topic, CordaX500Name.parse(user), platformVersion, uniqueMessageId, receivedSenderUUID, receivedSenderSeqNo, isSessionInit, message) - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$return NodeClientMessage(topic, OpaqueBytes(data), deduplicationId.deduplicationId, deduplicationId.senderUUID, additionalHeaders) - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$throw IllegalStateException("Cannot add another acking handler for $topic, there is already an acking one") MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$val createNewSession = { sessionFactory!!.createSession(ArtemisMessagingComponent.NODE_P2P_USER, ArtemisMessagingComponent.NODE_P2P_USER, false, true, true, false, ActiveMQClient.DEFAULT_ACK_BATCH_SIZE) } - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$val isSessionInit = message.getStringProperty(P2PMessagingHeaders.Type.KEY) == P2PMessagingHeaders.Type.SESSION_INIT_VALUE MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$val receivedSenderSeqNo = if (message.containsProperty(P2PMessagingHeaders.senderSeqNo)) message.getLongProperty(P2PMessagingHeaders.senderSeqNo) else null - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient$val uniqueMessageId = message.required(HDR_DUPLICATE_DETECTION_ID) { DeduplicationId(message.getStringProperty(it)) } - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient${ val running = state.locked { // We allow stop() to be called without a run() in between, but it must have at least been started. check(started) val prevRunning = running running = false networkChangeSubscription?.unsubscribe() require(p2pConsumer != null, { "stop can't be called twice" }) require(producer != null, { "stop can't be called twice" }) close(p2pConsumer) p2pConsumer = null close(producer) producer = null producerSession!!.commit() close(executorProducer) executorProducer = null executorSession!!.commit() close(bridgeNotifyConsumer) knownQueues.clear() eventsSubscription?.unsubscribe() eventsSubscription = null prevRunning } if (running && !nodeExecutor.isOnThread) { // Wait for the main loop to notice the consumer has gone and finish up. shutdownLatch.await() } // Only first caller to gets running true to protect against double stop, which seems to happen in some integration tests. state.locked { locator?.close() } } - MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient.ArtemisReceivedMessage$override val data: ByteSequence by lazy { OpaqueBytes(ByteArray(message.bodySize).apply { message.bodyBuffer.readBytes(this) }) } MaxLineLength:P2PMessagingClient.kt$P2PMessagingClient.MessageDeduplicationHandler$private inner MaxLineLength:P2PMessagingClient.kt$P2PMessagingConsumer$drainingModeWasChangedEvents.filter { change -> change.switchedOff() }.doOnNext { existingOnlyConsumer.switchTo(initialAndExistingConsumer) }.subscribe() MaxLineLength:P2PMessagingClient.kt$P2PMessagingConsumer$drainingModeWasChangedEvents.filter { change -> change.switchedOn() }.doOnNext { initialAndExistingConsumer.switchTo(existingOnlyConsumer) }.subscribe() - MaxLineLength:P2PMessagingClient.kt$P2PMessagingConsumer.Companion$private const val initialSessionMessages = "${P2PMessagingHeaders.Type.KEY}<>'${P2PMessagingHeaders.Type.SESSION_INIT_VALUE}'" - MaxLineLength:P2PMessagingTest.kt$P2PMessagingTest$ inline fun MessagingService.runOnNextMessage(topic: String, crossinline callback: (ReceivedMessage) -> Unit) - MaxLineLength:P2PMessagingTest.kt$P2PMessagingTest$internalServices.networkService.send("test.request", TestRequest(replyTo = internalServices.networkService.myAddress), target) - MaxLineLength:P2PMessagingTest.kt$P2PMessagingTest$private - MaxLineLength:P2PMessagingTest.kt$P2PMessagingTest${ // Setup each node in the distributed service to return back it's NodeInfo so that we can know which node is being used participatingServiceNodes.forEach { node -> node.respondWith(node.services.myInfo) } val serviceAddress = originatingNode.services.networkMapCache.run { originatingNode.internalServices.networkService.getAddressOfParty(getPartyInfo(getNotary(serviceName)!!)!!) } val participatingNodes = HashSet<Any>() // Try several times so that we can be fairly sure that any node not participating is not due to Artemis' selection // strategy. 3 attempts for each node seems to be sufficient. // This is not testing the distribution of the requests - DistributedServiceTests already does that for (it in 1..participatingServiceNodes.size * 3) { participatingNodes += originatingNode.receiveFrom(serviceAddress).getOrThrow(10.seconds) if (participatingNodes.size == participatingServiceNodes.size) { break } } assertThat(participatingNodes).containsOnlyElementsOf(participatingServiceNodes.map { it.services.myInfo }) } - MaxLineLength:PackageOwnershipVerificationTests.kt$PackageOwnershipVerificationTests$output(DUMMY_CONTRACT, "c1", DUMMY_NOTARY, null, HashAttachmentConstraint(SecureHash.allOnesHash), DummyContractState()) MaxLineLength:PackageUtils.kt$fun NodeHandle.logFile(): File - MaxLineLength:Parameters.kt$Parameters$@CommandLine.Option(names = ["-d", "--double-spend-ratio"], description = ["The double spend ratio (default: 0.02)"]) - MaxLineLength:Parameters.kt$Parameters$@CommandLine.Option(names = ["-n", "--num-transactions"], description = ["How many transactions to generate (default: 20)"]) - MaxLineLength:ParametersUtilities.kt$ fun NetworkParameters.addNotary(party: Party, validating: Boolean = true): NetworkParameters - MaxLineLength:PartialMerkleTree.kt$PartialMerkleTree - MaxLineLength:PartialMerkleTree.kt$PartialMerkleTree$PartialTree - MaxLineLength:PartialMerkleTree.kt$PartialMerkleTree$if (!leafIndexHelper(leaf, this.root, flagPath)) throw MerkleTreeException("The provided hash $leaf is not in the tree.") MaxLineLength:PartialMerkleTree.kt$PartialMerkleTree.Companion$ fun rootAndUsedHashes(node: PartialTree, usedHashes: MutableList<SecureHash>): SecureHash - MaxLineLength:PartialMerkleTree.kt$PartialMerkleTree.Companion$// Check if a MerkleTree is full binary tree. Returns the height of the tree if full, otherwise throws exception. private fun checkFull(tree: MerkleTree, level: Int = 0): Int - MaxLineLength:PartialMerkleTreeTest.kt$PartialMerkleTreeTest$assertFailsWith<MerkleTreeException> { PartialMerkleTree.build(merkleTree, listOf<SecureHash>(SecureHash.sha256("20"))) } MaxLineLength:PartialMerkleTreeTest.kt$PartialMerkleTreeTest$assertFailsWith<MerkleTreeException> { PartialMerkleTree.build(merkleTree, listOf<SecureHash>(SecureHash.sha256("20"), SecureHash.sha256("1"), SecureHash.sha256("5"))) } - MaxLineLength:PartialMerkleTreeTest.kt$PartialMerkleTreeTest$networkParameters = testNetworkParameters(minimumPlatformVersion = 4, notaries = listOf(NotaryInfo(DUMMY_NOTARY, true))) MaxLineLength:PartialMerkleTreeTest.kt$PartialMerkleTreeTest$val pmt = PartialMerkleTree.build(merkleTree, listOf<SecureHash>(SecureHash.sha256("1"), SecureHash.sha256("5"), SecureHash.sha256("0"), SecureHash.sha256("19"))) - MaxLineLength:PartialMerkleTreeTest.kt$PartialMerkleTreeTest${ // We even use the same privacySalt, and thus the only difference between the two transactions is the notary party. val privacySalt = PrivacySalt() val wtx1 = makeSimpleCashWtx(DUMMY_NOTARY, privacySalt) val wtx2 = makeSimpleCashWtx(MEGA_CORP, privacySalt) assertEquals(wtx1.privacySalt, wtx2.privacySalt) assertNotEquals(wtx1.id, wtx2.id) } - MaxLineLength:Party.kt$Party : AbstractParty - MaxLineLength:Party.kt$Party$constructor(certificate: X509Certificate) : this(CordaX500Name.build(certificate.subjectX500Principal), Crypto.toSupportedPublicKey(certificate.publicKey)) - MaxLineLength:PartyAndCertificate.kt$PartyAndCertificate MaxLineLength:PartyAndCertificate.kt$PartyAndCertificate$require(role?.isIdentity ?: false) { "Party certificate ${certificate.subjectDN} does not have a well known or confidential identity role. Found: $role" } - MaxLineLength:PartyAndCertificate.kt$PartyAndCertificate$throw CertPathValidatorException("Child certificate whose issuer includes a Corda role, must also specify Corda role") MaxLineLength:PartyAndCertificate.kt$PartyAndCertificate$throw CertPathValidatorException("The issuing certificate for $certificateString has role $parentRole, expected one of ${role.validParents}") - MaxLineLength:PathManager.kt$PathManager<T : PathManager<T>> : Closeable - MaxLineLength:PathManagerTests.kt$PathManagerTests$MyPathManager : PathManager - MaxLineLength:PathUtils.kt$ fun Path.attributes(vararg options: LinkOption): BasicFileAttributes - MaxLineLength:PathUtils.kt$inline MaxLineLength:Perceivable.kt$@Suppress("UNUSED_PARAMETER") start: Perceivable<Instant> MaxLineLength:Perceivable.kt$@Suppress("UNUSED_PARAMETER") start: String MaxLineLength:Perceivable.kt$Interest$val interest: Perceivable<BigDecimal> - MaxLineLength:Perceivable.kt$Interest(Const(amount), dayCountConvention, interest, const(parseDate(start).toInstant()), const(parseDate(end).toInstant())) MaxLineLength:Perceivable.kt$PerceivableComparison<T> : Perceivable - MaxLineLength:Perceivable.kt$PerceivableOperation<T> : Perceivable - MaxLineLength:Perceivable.kt$fun fix(source: String, date: LocalDate, tenor: Tenor): Perceivable<BigDecimal> MaxLineLength:Perceivable.kt$fun interest(@Suppress("UNUSED_PARAMETER") amount: BigDecimal, @Suppress("UNUSED_PARAMETER") dayCountConvention: String, @Suppress("UNUSED_PARAMETER") interest: BigDecimal /* todo - appropriate type */, @Suppress("UNUSED_PARAMETER") start: Perceivable<Instant>, @Suppress("UNUSED_PARAMETER") end: Perceivable<Instant>): Perceivable<BigDecimal> MaxLineLength:Perceivable.kt$fun interest(@Suppress("UNUSED_PARAMETER") amount: BigDecimal, @Suppress("UNUSED_PARAMETER") dayCountConvention: String, @Suppress("UNUSED_PARAMETER") interest: BigDecimal /* todo - appropriate type */, @Suppress("UNUSED_PARAMETER") start: String, @Suppress("UNUSED_PARAMETER") end: String): Perceivable<BigDecimal> MaxLineLength:Perceivable.kt$fun interest(@Suppress("UNUSED_PARAMETER") amount: BigDecimal, @Suppress("UNUSED_PARAMETER") dayCountConvention: String, @Suppress("UNUSED_PARAMETER") interest: Perceivable<BigDecimal> /* todo - appropriate type */, @Suppress("UNUSED_PARAMETER") start: Perceivable<Instant>, @Suppress("UNUSED_PARAMETER") end: Perceivable<Instant>): Perceivable<BigDecimal> MaxLineLength:Perceivable.kt$fun interest(@Suppress("UNUSED_PARAMETER") amount: BigDecimal, @Suppress("UNUSED_PARAMETER") dayCountConvention: String, @Suppress("UNUSED_PARAMETER") interest: Perceivable<BigDecimal> /* todo - appropriate type */, @Suppress("UNUSED_PARAMETER") start: String, @Suppress("UNUSED_PARAMETER") end: String): Perceivable<BigDecimal> - MaxLineLength:Perceivable.kt$operator fun Perceivable<BigDecimal>.minus(n: Double) - MaxLineLength:Perceivable.kt$operator fun Perceivable<BigDecimal>.times(n: Double) MaxLineLength:PeriodSerializer.kt$PeriodSerializer : Proxy - MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService : SingletonSerializeAsTokenIdentityServiceInternal - MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService$/** Stores notary identities obtained from the network parameters, for which we don't need to perform a database lookup. */ private val notaryIdentityCache = HashSet<Party>() MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService$// Allows us to eliminate keys we know belong to others by using the cache contents that might have been seen during other identity activity. // Concentrating activity on the identity cache works better than spreading checking across identity and key management, because we cache misses too. fun stripNotOurKeys(keys: Iterable<PublicKey>): Iterable<PublicKey> - MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService$@Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) - MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService$@Throws(CertificateExpiredException::class, CertificateNotYetValidException::class, InvalidAlgorithmParameterException::class) override MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService$@Throws(UnknownAnonymousPartyException::class) override - MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService$_caCertStore = CertStore.getInstance("Collection", CollectionCertStoreParameters(caCertificates.toSet() + trustRoot)) MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService$fun loadIdentities(identities: Collection<PartyAndCertificate> = emptySet(), confidentialIdentities: Collection<PartyAndCertificate> = emptySet()) MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService$fun start(trustRoot: X509Certificate, caCertificates: List<X509Certificate> = emptyList(), notaryIdentities: List<Party> = emptyList()) MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService$override - MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService$override fun certificateFromKey(owningKey: PublicKey): PartyAndCertificate? MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService${ // Because this is supposed to be new and random, there's no way we have it in the database already, so skip the pessimistic check. keyToParties[key] = identity } - MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService${ // Skip database lookup if the party is a notary identity. // This also prevents an issue where the notary identity can't be resolved if it's not in the network map cache. The node obtains // a trusted list of notary identities from the network parameters automatically. return if (party is Party && party in notaryIdentityCache) { party } else { database.transaction { super.wellKnownPartyFromAnonymous(party) } } } - MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService.Companion$PartyAndCertificate(X509CertificateFactory().delegate.generateCertPath(it.identity.inputStream())) MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService.Companion$fun createPKMap(cacheFactory: NamedCacheFactory): AppendOnlyPersistentMap<SecureHash, PartyAndCertificate, PersistentIdentity, String> MaxLineLength:PersistentIdentityService.kt$PersistentIdentityService.Companion$fun createX500Map(cacheFactory: NamedCacheFactory): AppendOnlyPersistentMap<CordaX500Name, SecureHash, PersistentIdentityNames, String> - MaxLineLength:PersistentIdentityServiceTests.kt$PersistentIdentityServiceTests$ @Test fun `assert ownership`() - MaxLineLength:PersistentIdentityServiceTests.kt$PersistentIdentityServiceTests$ @Test fun `get anonymous identity by key`() MaxLineLength:PersistentIdentityServiceTests.kt$PersistentIdentityServiceTests$listOf("Organisation A", "Organisation B", "Organisation C") .map { getTestPartyAndCertificate(CordaX500Name(organisation = it, locality = "London", country = "GB"), generateKeyPair().public) } MaxLineLength:PersistentIdentityServiceTests.kt$PersistentIdentityServiceTests$val alicente = getTestPartyAndCertificate(CordaX500Name(organisation = "Alicente Worldwide", locality = "London", country = "GB"), generateKeyPair().public) MaxLineLength:PersistentKeyManagementService.kt$PersistentKeyManagementService$//It looks for the PublicKey in the (potentially) CompositeKey that is ours, and then returns the associated PrivateKey to use in signing private fun getSigningKeyPair(publicKey: PublicKey): KeyPair - MaxLineLength:PersistentKeyManagementService.kt$PersistentKeyManagementService$override - MaxLineLength:PersistentKeyManagementService.kt$PersistentKeyManagementService$private val database: CordaPersistence MaxLineLength:PersistentKeyManagementService.kt$PersistentKeyManagementService$val pk = publicKey.keys.first { keysMap[it] != null } //TODO here for us to re-write this using an actual query if publicKey.keys.size > 1 - MaxLineLength:PersistentKeyManagementService.kt$PersistentKeyManagementService.Companion$fun createKeyMap(cacheFactory: NamedCacheFactory): AppendOnlyPersistentMap<PublicKey, PrivateKey, PersistentKey, String> MaxLineLength:PersistentMap.kt$PersistentMap$ExplicitRemoval<K, V, E, EK> : RemovalListener - MaxLineLength:PersistentMap.kt$PersistentMap$cache.getAll(session.createQuery(criteriaQuery).resultList.map { e -> fromPersistentEntity(e as E).first }.asIterable()) - MaxLineLength:PersistentMap.kt$PersistentMap${ // This happens when the key was queried before with no value associated. We invalidate the cached null // value and recursively call set again. This is to avoid race conditions where another thread queries after // the invalidate but before the set. cache.invalidate(key) return set(key, value) } MaxLineLength:PersistentMap.kt$PersistentMap.NotReallyMutableEntry$private MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache$"SELECT DISTINCT l FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.legalIdentitiesAndCerts l WHERE l.name = :name" MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache$"SELECT n FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.addresses a WHERE a.host = :host AND a.port = :port" MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache$"SELECT n FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.legalIdentitiesAndCerts l WHERE l.name = :name" MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache$"SELECT n FROM ${NodeInfoSchemaV1.PersistentNodeInfo::class.java.name} n JOIN n.legalIdentitiesAndCerts l WHERE l.owningKeyHash = :owningKeyHash" - MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache$private - MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache$private val identityService: IdentityService - MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache$val failures = node.legalIdentitiesAndCerts.mapNotNull { Try.on { it.verify(identityService.trustAnchor) } as? Try.Failure } MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache$val info = findByIdentityKey(session, nodeInfo.legalIdentitiesAndCerts.first().owningKey).singleOrNull { it.serial == nodeInfo.serial } - MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache$where(builder.equal(get<String>(NodeInfoSchemaV1.PersistentNodeInfo::hash.name), nodeHash.toString())) - MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache${ // TODO For now the main legal identity is left in NodeInfo, this should be set comparision/come up with index for NodeInfo? val info = findByIdentityKey(session, nodeInfo.legalIdentitiesAndCerts.first().owningKey) val nodeInfoEntry = generateMappedObject(nodeInfo) if (info.isNotEmpty()) { nodeInfoEntry.id = info.first().id } session.merge(nodeInfoEntry) // invalidate cache last - this way, we might serve up the wrong info for a short time, but it will get refreshed // on the next load invalidateCaches(nodeInfo) } - MaxLineLength:PersistentNetworkMapCache.kt$PersistentNetworkMapCache${ // findByIdentityKey might returns multiple node info with the same key, need to pick the right one by comparing serial. val info = findByIdentityKey(session, nodeInfo.legalIdentitiesAndCerts.first().owningKey).singleOrNull { it.serial == nodeInfo.serial } info?.let { session.remove(it) } // invalidate cache last - this way, we might serve up the wrong info for a short time, but it will get refreshed // on the next load invalidateCaches(nodeInfo) } - MaxLineLength:PersistentNetworkMapCacheTest.kt$PersistentNetworkMapCacheTest$assertThat(charlieNetMapCache.getNodesByLegalName(DUMMY_NOTARY_NAME)).containsOnlyElementsOf(distServiceNodeInfos) MaxLineLength:PersistentNetworkMapCacheTest.kt$PersistentNetworkMapCacheTest$private val charlieNetMapCache = PersistentNetworkMapCache(TestingNamedCacheFactory(), database, InMemoryIdentityService(trustRoot = DEV_ROOT_CA.certificate)) - MaxLineLength:PersistentScheduledFlowRepository.kt$PersistentScheduledFlowRepository$criteriaQuery.orderBy(session.criteriaBuilder.asc(shed.get<NodeSchedulerService.PersistentScheduledState>("scheduledAt"))) MaxLineLength:PersistentScheduledFlowRepository.kt$PersistentScheduledFlowRepository$private MaxLineLength:PersistentScheduledFlowRepository.kt$PersistentScheduledFlowRepository$return Pair(StateRef(SecureHash.parse(txId), index), ScheduledStateRef(StateRef(SecureHash.parse(txId), index), scheduledStateRecord.scheduledAt)) - MaxLineLength:PersistentScheduledFlowRepository.kt$PersistentScheduledFlowRepository$val criteriaQuery = session.criteriaBuilder.createQuery(NodeSchedulerService.PersistentScheduledState::class.java) - MaxLineLength:PersistentScheduledFlowRepository.kt$PersistentScheduledFlowRepository$val elem = session.find(NodeSchedulerService.PersistentScheduledState::class.java, toPersistentEntityKey(key)) - MaxLineLength:PersistentScheduledFlowRepository.kt$PersistentScheduledFlowRepository$val existingEntry = session.find(NodeSchedulerService.PersistentScheduledState::class.java, toPersistentEntityKey(value.ref)) - MaxLineLength:PersistentStateService.kt$PersistentStateService MaxLineLength:PersistentStateServiceTests.kt$PersistentStateServiceTests$persistentStateService.persist(setOf(StateAndRef(TransactionState(TestState(), DummyContract.PROGRAM_ID, MEGA_CORP, constraint = AlwaysAcceptAttachmentConstraint), StateRef(SecureHash.sha256("dummy"), 0)))) - MaxLineLength:PersistentStateServiceTests.kt$PersistentStateServiceTests$val database = configureDatabase(makeTestDataSourceProperties(), DatabaseConfig(), rigorousMock(), rigorousMock(), schemaService) - MaxLineLength:PersistentStateServiceTests.kt$PersistentStateServiceTests.<no name provided>$override val schemaOptions: Map<MappedSchema, SchemaService.SchemaOptions> = mapOf(testSchema to SchemaService.SchemaOptions()) - MaxLineLength:PersistentTypes.kt$DirectStatePersistable : StatePersistable MaxLineLength:PersistentTypes.kt$IndirectStatePersistable<T : DirectStatePersistable> : StatePersistable - MaxLineLength:PersistentTypes.kt$MappedSchemaValidator$SchemaCrossReferenceReport MaxLineLength:PersistentTypes.kt$MappedSchemaValidator$annotations.any { annotation -> annotation.toString().startsWith("@javax.persistence.") && annotation !is javax.persistence.Transient } MaxLineLength:PersistentTypes.kt$MappedSchemaValidator${ field -> field.type.enclosingClass != null && MappedSchema::class.java.isAssignableFrom(field.type.enclosingClass) && hasJpaAnnotation(field.declaredAnnotations) && field.type.enclosingClass != schema.javaClass } MaxLineLength:PersistentTypes.kt$MappedSchemaValidator${ method -> method.returnType.enclosingClass != null && MappedSchema::class.java.isAssignableFrom(method.returnType.enclosingClass) && method.returnType.enclosingClass != schema.javaClass && hasJpaAnnotation(method.declaredAnnotations) } MaxLineLength:PersistentTypes.kt$MappedSchemaValidator.SchemaCrossReferenceReport$"MappedSchema '${schema.substringAfterLast(".")}' entity '$entity' field '$fieldOrMethod' is of type '$fieldOrMethodType' " - MaxLineLength:PersistentTypes.kt$PersistentState : DirectStatePersistable MaxLineLength:PersistentUniquenessProvider.kt$PersistentUniquenessProvider : UniquenessProviderSingletonSerializeAsToken MaxLineLength:PersistentUniquenessProvider.kt$PersistentUniquenessProvider$commitOne(request.states, request.txId, request.callerIdentity, request.requestSignature, request.timeWindow, request.references) - MaxLineLength:PersistentUniquenessProvider.kt$PersistentUniquenessProvider$if (consumingTx != null) conflictingStates[stateRef] = StateConsumptionDetails(consumingTx.sha256(), type) MaxLineLength:PersistentUniquenessProvider.kt$PersistentUniquenessProvider$private - MaxLineLength:PersistentUniquenessProvider.kt$PersistentUniquenessProvider$request.future.setException(NotaryInternalException(NotaryError.General(Exception("Internal service error.")))) - MaxLineLength:PersistentUniquenessProvider.kt$PersistentUniquenessProvider.Companion$fun createMap(cacheFactory: NamedCacheFactory): AppendOnlyPersistentMap<StateRef, SecureHash, CommittedState, PersistentStateRef> - MaxLineLength:PhysicalLocationStructures.kt$WorldCoordinate$fun latitudeToScreenY(lat: Double) - MaxLineLength:PhysicalLocationStructures.kt$WorldCoordinate$require(longitude in leftLongitude..rightLongitude){"Longitude must be between $leftLongitude and $rightLongitude"} MaxLineLength:PortfolioApi.kt$PortfolioApi$ @POST @Path("{party}/portfolio/valuations/calculate") @Produces(MediaType.APPLICATION_JSON) fun startPortfolioCalculations(params: ValuationCreationParams = ValuationCreationParams(LocalDate.of(2016, 6, 6)), @PathParam("party") partyName: String): Response MaxLineLength:PortfolioApi.kt$PortfolioApi$counterparties = counterParties.flatMap { it.legalIdentitiesAndCerts.map { ApiParty(it.owningKey.toBase58String(), it.name) } } - MaxLineLength:PortfolioApi.kt$PortfolioApi$rpc.startFlow(SimmRevaluation::Initiator, getPortfolioStateAndRefWith(otherParty).ref, params.valuationDate) MaxLineLength:PortfolioApi.kt$PortfolioApi$val history = AggregatedHistoryView(state.valuation!!.trades, notional.toDouble(), LocalDate.now(), state.valuation!!.margin.first, mtm) - MaxLineLength:PortfolioApi.kt$PortfolioApi.AggregatedHistoryView$data - MaxLineLength:PortfolioApiUtils.kt$PortfolioApiUtils$"fixedRatePayer" to (fixedRatePayer.nameOrNull()?.organisation ?: fixedRatePayer.owningKey.toBase58String()) MaxLineLength:PortfolioApiUtils.kt$PortfolioApiUtils$"floatingRatePayer" to (floatingRatePayer.nameOrNull()?.organisation ?: floatingRatePayer.owningKey.toBase58String()) MaxLineLength:PortfolioApiUtils.kt$PortfolioApiUtils$InitialMarginView - MaxLineLength:PortfolioApiUtils.kt$PortfolioApiUtils$val completeSubgroups = subgroups.mapValues { it.value.mapValues { it.value[0].third.toDouble() }.toSortedMap() } MaxLineLength:PortfolioApiUtils.kt$PortfolioApiUtils$val processedSensitivities = valuation.totalSensivities.sensitivities.map { it.marketDataName to it.parameterMetadata.map { it.label }.zip(it.sensitivity.toList()).toMap() }.toMap() - MaxLineLength:PortfolioApiUtils.kt$PortfolioApiUtils$val trade = if (state.buyer == ownParty as AbstractParty) state.swap.toFloatingLeg() else state.swap.toFloatingLeg() MaxLineLength:PortfolioApiUtils.kt$PortfolioApiUtils$val yieldCurveCurrenciesValues = marketData.filter { !it.key.contains("/") }.map { it -> Triple(it.key.split("-")[0], it.key.split("-", limit = 2)[1], it.value) } - MaxLineLength:PortfolioState.kt$PortfolioState$override - MaxLineLength:PortfolioState.kt$PortfolioState$return ScheduledActivity(flow, LocalDate.now().plus(1, ChronoUnit.DAYS).atStartOfDay().toInstant(ZoneOffset.UTC)) MaxLineLength:PortfolioState.kt$PortfolioState$return TransactionBuilder(notary).withItems(StateAndContract(copy(), PORTFOLIO_SWAP_PROGRAM_ID), Command(PortfolioSwap.Commands.Agree(), participants.map { it.owningKey })) - MaxLineLength:PortfolioState.kt$PortfolioState$val flow = flowLogicRefFactory.create("net.corda.vega.flows.SimmRevaluation\$Initiator", thisStateRef, LocalDate.now()) - MaxLineLength:PortfolioSwap.kt$PortfolioSwap$val groups: List<LedgerTransaction.InOutGroup<PortfolioState, UniqueIdentifier>> = tx.groupStates { state -> state.linearId } - MaxLineLength:PrettyPrint.kt$PrettyPrint$println("val ${createPartyName(it)} = Party(\"${it.name.organisation}\", \"${it.owningKey.toStringShort()}\")") - MaxLineLength:PrintingInterceptor.kt$PrintingInterceptor$val (continuation, nextState) = delegate.executeTransition(fiber, previousState, event, transition, actionExecutor) MaxLineLength:PrintingInterceptor.kt$PrintingInterceptor$val transitionRecord = TransitionDiagnosticRecord(Instant.now(), fiber.id, previousState, nextState, event, transition, continuation) - MaxLineLength:PrivateKeySerializationTest.kt$PrivateKeySerializationTest$assertTrue { privateKey.checkpointSerialize(context = CheckpointSerializationDefaults.CHECKPOINT_CONTEXT).bytes.isNotEmpty() } - MaxLineLength:PrivateKeySerializationTest.kt$PrivateKeySerializationTest.Companion$return privateKeys.map { arrayOf<Any>(it, PrivateKeySerializationTest::class.java.simpleName + "-" + it.javaClass.simpleName) } - MaxLineLength:PrivateKeySerializationTest.kt$PrivateKeySerializationTest.Companion$val privateKeys: List<PrivateKey> = Crypto.supportedSignatureSchemes().filterNot { Crypto.COMPOSITE_KEY === it } .map { Crypto.generateKeyPair(it).private } MaxLineLength:PrivateKeySerializer.kt$PrivateKeySerializer$override val schemaForDocumentation = Schema(listOf(RestrictedType(type.toString(), "", listOf(type.toString()), AMQPTypeIdentifiers.primitiveTypeName(ByteArray::class.java), descriptor, emptyList()))) - MaxLineLength:ProcessUtilities.kt$ProcessUtilities$return startJavaProcess(C::class.java.name, arguments, classPath, workingDirectory, jdwpPort, extraJvmArguments, maximumHeapSize) - MaxLineLength:ProfileController.kt$ProfileController$StreamSupport.stream(fs.rootDirectories.spliterator(), false) .flatMap { Files.find(it, 2, BiPredicate { p, attr -> "node.conf" == p?.fileName.toString() && attr.isRegularFile }) } - MaxLineLength:ProfileController.kt$ProfileController$StreamSupport.stream(fs.rootDirectories.spliterator(), false) .flatMap { Files.find(it, 3, BiPredicate { p, attr -> p.inCordappsDir && p.isCordapp && attr.isRegularFile }) } - MaxLineLength:ProgressTracker.kt$ProgressTracker$/** * A list of all steps label in this ProgressTracker and the children, with the indent level provided starting at zero. * Note that UNSTARTED is never counted, and DONE is only counted at the calling level. */ val allStepsLabels: List<Pair<Int, String>> get() = _allStepsLabels() - MaxLineLength:ProgressTracker.kt$ProgressTracker$if (it is Change.Structural || it is Change.Rendering) rebuildStepsTree() else recalculateStepsTreeIndex() MaxLineLength:ProgressTracker.kt$ProgressTracker$log.warnOnce("Found ProgressTracker Step(s) with the same label: ${labels.groupBy { it }.filter { it.value.size > 1 }.map { it.key }}") - MaxLineLength:ProgressTracker.kt$ProgressTracker$private fun _allStepsLabels(level: Int = 0): List<Pair<Int, String>> - MaxLineLength:ProgressTracker.kt$ProgressTracker${ // This gets the index of the current step in the context of this progress tracker, so it will always be at the top level in // the allStepsCache. val index = _allStepsCache.indexOf(Pair(0, currentStep)) return if (index >= 0) index else 0 } - MaxLineLength:ProgressTracker.kt$ProgressTracker${ steps.forEach { configureChildTrackerForStep(it) } // Immediately update the step tree observable to ensure the first update the client receives is the initial state of the progress // tracker. _stepsTreeChanges.onNext(allStepsLabels) this.currentStep = UNSTARTED } MaxLineLength:ProgressTracker.kt$ProgressTracker.Step$private fun definitionLocation(): String MaxLineLength:Properties.kt$DelegatedProperty$private abstract MaxLineLength:Properties.kt$FunctionalListProperty$override fun <MAPPED> mapValid(mappedTypeName: String, convert: (List<TYPE>) -> Validated<MAPPED, Configuration.Validation.Error>): Configuration.Property.Definition.Required<MAPPED> @@ -7857,13 +4423,8 @@ MaxLineLength:Properties.kt$FunctionalListProperty$private MaxLineLength:Properties.kt$FunctionalListProperty$return delegate.schema?.let { schema -> valueDescription(valueIn(configuration).asSequence().map { element -> valueDescription(element, serialiseValue) }.map { it as ConfigObject }.map(ConfigObject::toConfig).map { schema.describe(it, serialiseValue) }.toList(), serialiseValue) } ?: valueDescription(valueIn(configuration), serialiseValue) MaxLineLength:Properties.kt$FunctionalListProperty$val errors = list.asSequence().map { configObject(key to ConfigValueFactory.fromAnyRef(it)) }.mapIndexed { index, value -> delegate.validate(value.toConfig(), options).errors.map { error -> error.withContainingPath(*error.containingPath(index).toTypedArray()) } }.fold(emptyList<Configuration.Validation.Error>()) { one, other -> one + other }.toSet() - MaxLineLength:Properties.kt$FunctionalProperty$errors += convert.invoke(delegate.valueIn(target)).mapErrors { error -> error.with(delegate.key, mappedTypeName) }.errors MaxLineLength:Properties.kt$FunctionalProperty$override fun <M> mapValid(mappedTypeName: String, convert: (MAPPED) -> Valid<M>): Configuration.Property.Definition.Standard<M> - MaxLineLength:Properties.kt$FunctionalProperty$override fun describe(configuration: Config, serialiseValue: (Any?) -> ConfigValue) - MaxLineLength:Properties.kt$FunctionalProperty$override val typeName: String = if (super.typeName == "#$mappedTypeName") super.typeName else "$mappedTypeName(${super.typeName})" MaxLineLength:Properties.kt$FunctionalProperty$private - MaxLineLength:Properties.kt$ListMappingProperty$errors += convert.invoke(delegate.valueIn(target)).mapErrors { error -> error.with(delegate.key, mappedTypeName) }.errors - MaxLineLength:Properties.kt$ListMappingProperty$override MaxLineLength:Properties.kt$ListMappingProperty$override fun describe(configuration: Config, serialiseValue: (Any?) -> ConfigValue): ConfigValue? MaxLineLength:Properties.kt$ListMappingProperty$private MaxLineLength:Properties.kt$ListProperty$errors += valueIn(target).asSequence().map { element -> element as ConfigObject }.map(ConfigObject::toConfig).mapIndexed { index, targetConfig -> schema.validate(targetConfig, options).errors.map { error -> error.withContainingPath(*error.containingPath(index).toTypedArray()) } }.fold(emptyList<Configuration.Validation.Error>()) { one, other -> one + other }.toSet() @@ -7877,230 +4438,99 @@ MaxLineLength:Properties.kt$OptionalDelegatedProperty$private MaxLineLength:Properties.kt$OptionalDelegatedProperty$val missingValueError = errors.asSequence().filterIsInstance<Configuration.Validation.Error.MissingValue>().filter { it.pathAsString == key }.singleOrNull() MaxLineLength:Properties.kt$OptionalPropertyWithDefault$override fun describe(configuration: Config, serialiseValue: (Any?) -> ConfigValue): ConfigValue? - MaxLineLength:Properties.kt$OptionalPropertyWithDefault$override fun validate(target: Config, options: Configuration.Validation.Options): Valid<Config> MaxLineLength:Properties.kt$OptionalPropertyWithDefault$private MaxLineLength:Properties.kt$RequiredDelegatedProperty$private abstract MaxLineLength:Properties.kt$StandardProperty$errors += nestedSchema.validate(nestedConfig, options).errors.map { error -> error.withContainingPathPrefix(*key.split(".").toTypedArray()) } MaxLineLength:Properties.kt$StandardProperty$internal open MaxLineLength:Properties.kt$StandardProperty$override fun <MAPPED> mapValid(mappedTypeName: String, convert: (TYPE) -> Valid<MAPPED>): Configuration.Property.Definition.Standard<MAPPED> - MaxLineLength:Properties.kt$StandardProperty$return schema?.describe(configuration.getConfig(key), serialiseValue) ?: valueDescription(valueIn(configuration), serialiseValue) - MaxLineLength:Properties.kt$private - MaxLineLength:Properties.kt$private fun isErrorExpected(error: ConfigException) MaxLineLength:Properties.kt$private val expectedExceptionTypes = setOf(ConfigException.Missing::class, ConfigException.WrongType::class, ConfigException.BadValue::class, ConfigException.BadPath::class, ConfigException.Parse::class) - MaxLineLength:PropertyDescriptor.kt$// Construct a map of PropertyDescriptors by name, by merging the raw field map with the map of classified property methods private fun Map<String, Map<MethodClassifier, Method>>.toClassProperties(fieldMap: Map<String, Field>): Map<String, PropertyDescriptor> - MaxLineLength:PropertyDescriptor.kt$// Merge the given method into a map of methods by method classifier, picking the least generic method for each classifier. private fun EnumMap<MethodClassifier, Method>.merge(classifier: MethodClassifier, method: Method): EnumMap<MethodClassifier, Method> - MaxLineLength:PropertyDescriptor.kt$?: - MaxLineLength:PropertyDescriptor.kt$private - MaxLineLength:PropertyTest.kt$PropertyTest$val property = Configuration.Property.Definition.long(key).map(::AtomicLong).list().map { list -> list.map(AtomicLong::get).max() } MaxLineLength:PropertyTest.kt$PropertyTest$val property = Configuration.Property.Definition.long(key).map(::AtomicLong).list().map { list -> list.map(AtomicLong::get).max() }.optional() - MaxLineLength:PropertyValidationTest.kt$PropertyValidationTest$assertThat(errors.first()) MaxLineLength:PropertyValidationTest.kt$PropertyValidationTest$return invalid(Configuration.Validation.Error.BadValue.of("Value must be of format \"host(String):port(Int > 0)\" e.g., \"127.0.0.1:8080\"")) - MaxLineLength:PropertyValidationTest.kt$PropertyValidationTest$val nestedPropertySchema = Configuration.Schema.withProperties(Configuration.Property.Definition.long(nestedKey)) - MaxLineLength:ProtonWrapperTests.kt$ProtonWrapperTests$private - MaxLineLength:ProtonWrapperTests.kt$ProtonWrapperTests$serverParams.endpointIdentificationAlgorithm = null - MaxLineLength:ProtonWrapperTests.kt$ProtonWrapperTests$signingCertificateStore.get(true).also { it.registerDevSigningCertificates(ALICE_NAME, rootCa.certificate, intermediateCa) } - MaxLineLength:ProtonWrapperTests.kt$ProtonWrapperTests$sslConfig.keyStore.get(true).also { it.registerDevP2pCertificates(ALICE_NAME, rootCa.certificate, intermediateCa) } - MaxLineLength:ProtonWrapperTests.kt$ProtonWrapperTests$val client = ArtemisMessagingClient(artemisConfig.p2pSslOptions, NetworkHostAndPort("localhost", artemisPort), maxMessageSize) - MaxLineLength:ProtonWrapperTests.kt$ProtonWrapperTests$val signingCertificateStore = CertificateStoreStubs.Signing.withCertificatesDirectory(certificatesDirectory, "serverstorepass") - MaxLineLength:ProtonWrapperTests.kt$ProtonWrapperTests$val sslConfig = CertificateStoreStubs.P2P.withCertificatesDirectory(certificatesDirectory, keyStorePassword = "serverstorepass") - MaxLineLength:ProtonWrapperTests.kt$ProtonWrapperTests${ val maxMessageSize = 100_000 val (server, artemisClient) = createArtemisServerAndClient(maxMessageSize) val amqpClient = createClient(maxMessageSize) val clientConnected = amqpClient.onConnection.toFuture() amqpClient.start() assertEquals(true, clientConnected.get().connected) assertEquals(CHARLIE_NAME, CordaX500Name.build(clientConnected.get().remoteCert!!.subjectX500Principal)) val artemis = artemisClient.started!! val sendAddress = P2P_PREFIX + "Test" artemis.session.createQueue(sendAddress, RoutingType.ANYCAST, "queue", true) val consumer = artemis.session.createConsumer("queue") val testProperty = mutableMapOf<String, Any?>() testProperty["TestProp"] = "1" // Send normal message. val testData = ByteArray(maxMessageSize) val message = amqpClient.createMessage(testData, sendAddress, CHARLIE_NAME.toString(), testProperty) amqpClient.write(message) assertEquals(MessageStatus.Acknowledged, message.onComplete.get()) val received = consumer.receive() assertEquals("1", received.getStringProperty("TestProp")) assertArrayEquals(testData, ByteArray(received.bodySize).apply { received.bodyBuffer.readBytes(this) }) // Send message larger then max message size. val largeData = ByteArray(maxMessageSize + 1) // Create message will fail. assertThatThrownBy { amqpClient.createMessage(largeData, sendAddress, CHARLIE_NAME.toString(), testProperty) }.hasMessageContaining("Message exceeds maxMessageSize network parameter") // Send normal message again to confirm the large message didn't reach the server and client is not killed by the message. val message2 = amqpClient.createMessage(testData, sendAddress, CHARLIE_NAME.toString(), testProperty) amqpClient.write(message2) assertEquals(MessageStatus.Acknowledged, message2.onComplete.get()) val received2 = consumer.receive() assertEquals("1", received2.getStringProperty("TestProp")) assertArrayEquals(testData, ByteArray(received2.bodySize).apply { received2.bodyBuffer.readBytes(this) }) amqpClient.stop() artemisClient.stop() server.stop() } - MaxLineLength:ProviderMap.kt$// Among the others, we should register [CordaSecurityProvider] as the first provider, to ensure that when invoking [SecureRandom()] // the [platformSecureRandom] is returned (which is registered in CordaSecurityProvider). // Note that internally, [SecureRandom()] will look through all registered providers. // Then it returns the first PRNG algorithm of the first provider that has registered a SecureRandom // implementation (in our case [CordaSecurityProvider]), or null if none of the registered providers supplies // a SecureRandom implementation. Security.insertProviderAt(it, 1) // The position is 1-based. - MaxLineLength:ProviderMap.kt$// This map is required to defend against users that forcibly call Security.addProvider / Security.removeProvider // that could cause unexpected and suspicious behaviour. // i.e. if someone removes a Provider and then he/she adds a new one with the same name. // The val is private to avoid any harmful state changes. val providerMap = listOf(cordaBouncyCastleProvider, cordaSecurityProvider, bouncyCastlePQCProvider).map { it.name to it }.toMap() MaxLineLength:ProviderMap.kt$// This registration is needed for reading back EdDSA key from java keystore. // TODO: Find a way to make JKS work with bouncy castle provider or implement our own provide so we don't have to register bouncy castle provider. Security.addProvider(it) - MaxLineLength:ProviderMap.kt$<no name provided>$override fun generatePublic(keyInfo: SubjectPublicKeyInfo) - MaxLineLength:ProviderMap.kt$@DeleteForDJVM fun platformSecureRandomFactory(): SecureRandom MaxLineLength:PublicKeySerializer.kt$PublicKeySerializer$override val schemaForDocumentation = Schema(listOf(RestrictedType(type.toString(), "", listOf(type.toString()), AMQPTypeIdentifiers.primitiveTypeName(ByteArray::class.java), descriptor, emptyList()))) - MaxLineLength:PublicKeySerializer.kt$PublicKeySerializer${ // TODO: Instead of encoding to the default X509 format, we could have a custom per key type (space-efficient) serialiser. output.writeObject(obj.encoded, data, clazz, context) } - MaxLineLength:PublicKeyToTextConverter.kt$PublicKeyToTextConverter$override fun convertToEntityAttribute(text: String?): PublicKey? - MaxLineLength:PushedNode.kt$PushedNode$fun toNodeInstanceRequest(nodeInstanceName: String, actualX500: String, expectedFqName: String): NodeInstanceRequest MaxLineLength:PushedNode.kt$PushedNode$return NodeInstanceRequest(configFile, baseDirectory, copiedNodeConfig, copiedNodeDir, nodeConfig, localImageId, remoteImageName, nodeInstanceName, actualX500, expectedFqName) - MaxLineLength:QuasarInstrumentationHook.kt$ fun recordUsedInstrumentedCallStack() MaxLineLength:QuasarInstrumentationHook.kt$QuasarInstrumentationHook$val instrumentClassMethods = clazz.methods.filter { it.name == "instrumentClass" } // TODO this is very brittle, we want to match on a specific instrumentClass() function. We could use the function signature, but that may change between versions anyway. Why is this function overloaded?? instrumentClassMethods[0].insertBefore( "$hookClassName.${::recordScannedClass.name}(className);" ) - MaxLineLength:QuasarInstrumentationHook.kt$QuasarInstrumentationHookAgent.Companion$println("Instrumented classes: ${classRecorder.instrumentedClasses.size}") classRecorder.instrumentedClasses.forEach { println(" $it") } println("Used instrumented classes: ${classRecorder.usedInstrumentedClasses.size}") classRecorder.usedInstrumentedClasses.forEach { println(" $it") } println("Scanned classes: ${classRecorder.scannedClasses.size}") classRecorder.scannedClasses.keys.take(20).forEach { println(" $it") } println(" (...)") val scannedTree = PackageTree.fromStrings(classRecorder.scannedClasses.keys.toList(), '/') val instrumentedTree = PackageTree.fromStrings(classRecorder.instrumentedClasses.keys.toList(), '/') val alwaysExclude = arguments.alwaysExcluded?.let { PackageTree.fromStrings(it, arguments.separator) } val alwaysExcludedTree = alwaysExclude?.let { instrumentedTree.truncate(it) } ?: instrumentedTree println("Suggested exclude globs:") val truncate = arguments.truncate?.let { PackageTree.fromStrings(it, arguments.separator) } // The separator append is a hack, it causes a package with an empty name to be added to the exclude tree, // which practically causes that level of the tree to be always expanded in the output globs. val expand = arguments.expand?.let { PackageTree.fromStrings(it.map { "$it${arguments.separator}" }, arguments.separator) } val truncatedTree = truncate?.let { scannedTree.truncate(it) } ?: scannedTree val expandedTree = expand?.let { alwaysExcludedTree.merge(it) } ?: alwaysExcludedTree val globs = truncatedTree.toGlobs(expandedTree) globs.forEach { println(" $it") } println("Quasar exclude expression:") println(" x(${globs.joinToString(";")})") - MaxLineLength:QuasarInstrumentationHook.kt$QuasarInstrumentationHookAgent.Companion$val expand = arguments.expand?.let { PackageTree.fromStrings(it.map { "$it${arguments.separator}" }, arguments.separator) } MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria$@CordaSerializable sealed MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria$AndComposition : AttachmentQueryCriteriaAndVisitor MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria$OrComposition : AttachmentQueryCriteriaOrVisitor MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$@DeprecatedConstructorForDeserialization(version = 2) constructor(uploaderCondition: ColumnPredicate<String>?, filenameCondition: ColumnPredicate<String>?) : this(uploaderCondition, filenameCondition, null) - MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$fun isSigned(isSignedPredicate: ColumnPredicate<Boolean>): AttachmentsQueryCriteria MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$fun withContractClassNames(contractClassNamesPredicate: ColumnPredicate<List<ContractClassName>>): AttachmentsQueryCriteria - MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$fun withFilename(filenamePredicate: ColumnPredicate<String>): AttachmentsQueryCriteria MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$fun withSigners(signersPredicate: ColumnPredicate<List<PublicKey>>): AttachmentsQueryCriteria MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$fun withUploadDate(uploadDatePredicate: ColumnPredicate<Instant>): AttachmentsQueryCriteria - MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$fun withUploader(uploaderPredicate: ColumnPredicate<String>): AttachmentsQueryCriteria - MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$fun withVersion(versionPredicate: ColumnPredicate<Int>): AttachmentsQueryCriteria MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$uploadDateCondition: ColumnPredicate<Instant>? = null - MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$val contractClassNamesCondition: ColumnPredicate<List<ContractClassName>>? = null - MaxLineLength:QueryCriteria.kt$AttachmentQueryCriteria.AttachmentsQueryCriteria$val versionCondition: ColumnPredicate<Int>? = null - MaxLineLength:QueryCriteria.kt$AttachmentsQueryCriteriaParser : BaseQueryCriteriaParser - MaxLineLength:QueryCriteria.kt$BaseQueryCriteriaParser<Q: GenericQueryCriteria<Q, P>, in P: BaseQueryCriteriaParser<Q,P,S>, in S : BaseSort> MaxLineLength:QueryCriteria.kt$GenericQueryCriteria.ChainableQueryCriteria$AndVisitor<Q : GenericQueryCriteria<Q, P>, in P : BaseQueryCriteriaParser<Q, P, S>, in S : BaseSort> : GenericQueryCriteria MaxLineLength:QueryCriteria.kt$GenericQueryCriteria.ChainableQueryCriteria$OrVisitor<Q : GenericQueryCriteria<Q, P>, in P : BaseQueryCriteriaParser<Q, P, S>, in S : BaseSort> : GenericQueryCriteria MaxLineLength:QueryCriteria.kt$QueryCriteria$@CordaSerializable sealed MaxLineLength:QueryCriteria.kt$QueryCriteria$AndComposition : QueryCriteriaAndVisitor MaxLineLength:QueryCriteria.kt$QueryCriteria$OrComposition : QueryCriteriaOrVisitor - MaxLineLength:QueryCriteria.kt$QueryCriteria.FungibleAssetQueryCriteria$( participants: List<AbstractParty>? = null, owner: List<AbstractParty>? = null, quantity: ColumnPredicate<Long>? = null, issuer: List<AbstractParty>? = null, issuerRef: List<OpaqueBytes>? = null, status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes: Set<Class<out ContractState>>? = null ) MaxLineLength:QueryCriteria.kt$QueryCriteria.FungibleAssetQueryCriteria$fun withContractStateTypes(contractStateTypes: Set<Class<out ContractState>>): FungibleAssetQueryCriteria - MaxLineLength:QueryCriteria.kt$QueryCriteria.FungibleAssetQueryCriteria$fun withParticipants(participants: List<AbstractParty>): FungibleAssetQueryCriteria MaxLineLength:QueryCriteria.kt$QueryCriteria.FungibleAssetQueryCriteria$fun withRelevancyStatus(relevancyStatus: Vault.RelevancyStatus): FungibleAssetQueryCriteria MaxLineLength:QueryCriteria.kt$QueryCriteria.FungibleStateQueryCriteria$fun withContractStateTypes(contractStateTypes: Set<Class<out ContractState>>): FungibleStateQueryCriteria - MaxLineLength:QueryCriteria.kt$QueryCriteria.FungibleStateQueryCriteria$fun withParticipants(participants: List<AbstractParty>): FungibleStateQueryCriteria MaxLineLength:QueryCriteria.kt$QueryCriteria.FungibleStateQueryCriteria$fun withRelevancyStatus(relevancyStatus: Vault.RelevancyStatus): FungibleStateQueryCriteria - MaxLineLength:QueryCriteria.kt$QueryCriteria.LinearStateQueryCriteria$( participants: List<AbstractParty>? = null, linearId: List<UniqueIdentifier>? = null, status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes: Set<Class<out ContractState>>? = null, relevancyStatus: Vault.RelevancyStatus = Vault.RelevancyStatus.ALL ) MaxLineLength:QueryCriteria.kt$QueryCriteria.LinearStateQueryCriteria$fun withContractStateTypes(contractStateTypes: Set<Class<out ContractState>>): LinearStateQueryCriteria - MaxLineLength:QueryCriteria.kt$QueryCriteria.LinearStateQueryCriteria$fun withParticipants(participants: List<AbstractParty>): LinearStateQueryCriteria - MaxLineLength:QueryCriteria.kt$QueryCriteria.LinearStateQueryCriteria$fun withRelevancyStatus(relevancyStatus: Vault.RelevancyStatus): LinearStateQueryCriteria MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultCustomQueryCriteria$fun withContractStateTypes(contractStateTypes: Set<Class<out ContractState>>): VaultCustomQueryCriteria<L> - MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultCustomQueryCriteria$fun withExpression(expression: CriteriaExpression<L, Boolean>): VaultCustomQueryCriteria<L> MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultCustomQueryCriteria$fun withRelevancyStatus(relevancyStatus: Vault.RelevancyStatus): VaultCustomQueryCriteria<L> - MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$( status: Vault.StateStatus = Vault.StateStatus.UNCONSUMED, contractStateTypes: Set<Class<out ContractState>>? = null, stateRefs: List<StateRef>? = null, notary: List<AbstractParty>? = null, softLockingCondition: SoftLockingCondition? = null, timeCondition: TimeCondition? = null ) MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$@DeprecatedConstructorForDeserialization(version = 2) constructor(status: Vault.StateStatus, contractStateTypes: Set<Class<out ContractState>>?) : this(status, contractStateTypes, participants = null) - MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$@DeprecatedConstructorForDeserialization(version = 3) constructor(status: Vault.StateStatus, contractStateTypes: Set<Class<out ContractState>>?, stateRefs: List<StateRef>?) : this( status, contractStateTypes, stateRefs, participants = null ) MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$@DeprecatedConstructorForDeserialization(version = 4) constructor(status: Vault.StateStatus, contractStateTypes: Set<Class<out ContractState>>?, stateRefs: List<StateRef>?, notary: List<AbstractParty>?) : this( status, contractStateTypes, stateRefs, notary, participants = null ) MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$@DeprecatedConstructorForDeserialization(version = 5) constructor(status: Vault.StateStatus, contractStateTypes: Set<Class<out ContractState>>?, stateRefs: List<StateRef>?, notary: List<AbstractParty>?, softLockingCondition: SoftLockingCondition?) : this( status, contractStateTypes, stateRefs, notary, softLockingCondition, participants = null ) MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$fun withConstraintTypes(constraintTypes: Set<Vault.ConstraintInfo.Type>): VaultQueryCriteria - MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$fun withConstraints(constraints: Set<Vault.ConstraintInfo>): VaultQueryCriteria MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$fun withContractStateTypes(contractStateTypes: Set<Class<out ContractState>>): VaultQueryCriteria - MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$fun withRelevancyStatus(relevancyStatus: Vault.RelevancyStatus): VaultQueryCriteria MaxLineLength:QueryCriteria.kt$QueryCriteria.VaultQueryCriteria$fun withSoftLockingCondition(softLockingCondition: SoftLockingCondition): VaultQueryCriteria - MaxLineLength:QueryCriteriaUtils.kt$/** * Note: use [PageSpecification] to correctly handle a number of bounded pages of a pre-configured page size. */ // Here we subtract 1 to allow the Vault to figure out whether there are more results and pages by querying for `pageSize + 1`. const val MAX_PAGE_SIZE = Int.MAX_VALUE - 1 - MaxLineLength:QueryCriteriaUtils.kt$Builder$@Deprecated("Does not support fields from a MappedSuperclass. Use equivalent on a FieldInfo.") fun <R : Comparable<R>> Field.comparePredicate(operator: BinaryComparisonOperator, value: R) MaxLineLength:QueryCriteriaUtils.kt$Builder$@Deprecated("Does not support fields from a MappedSuperclass. Use equivalent on a FieldInfo.") fun <R> Field.functionPredicate(predicate: ColumnPredicate<R>, groupByColumns: List<Column<Any, R>>? = null, orderBy: Sort.Direction? = null) MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun <O, R : Comparable<R>> KProperty1<O, R?>.`in`(collection: Collection<R>, exactMatch: Boolean = true) MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun <O, R : Comparable<R>> KProperty1<O, R?>.notIn(collection: Collection<R>, exactMatch: Boolean = true) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun <O, R> KProperty1<O, R?>.equal(value: R, exactMatch: Boolean = true) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun <O, R> KProperty1<O, R?>.notEqual(value: R, exactMatch: Boolean = true) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun <O> KProperty1<O, String?>.like(string: String, exactMatch: Boolean = true) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun <O> KProperty1<O, String?>.notLike(string: String, exactMatch: Boolean = true) MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun <R : Comparable<R>> `in`(collection: Collection<R>, exactMatch: Boolean = true) MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun <R : Comparable<R>> notIn(collection: Collection<R>, exactMatch: Boolean = true) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun <R> equal(value: R, exactMatch: Boolean = true) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun <R> notEqual(value: R, exactMatch: Boolean = true) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmOverloads fun notLike(string: String, exactMatch: Boolean = true) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic @JvmOverloads @Deprecated("Does not support fields from a MappedSuperclass. Use equivalent on a FieldInfo.") fun <R : Comparable<R>> Field.`in`(collection: Collection<R>, exactMatch: Boolean = true) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic @JvmOverloads @Deprecated("Does not support fields from a MappedSuperclass. Use equivalent on a FieldInfo.") fun <R : Comparable<R>> Field.notIn(collection: Collection<R>, exactMatch: Boolean = true) MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic @JvmOverloads @Deprecated("Does not support fields from a MappedSuperclass. Use equivalent on a FieldInfo.") fun <R> Field.avg(groupByColumns: List<Field>? = null, orderBy: Sort.Direction? = null) MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic @JvmOverloads @Deprecated("Does not support fields from a MappedSuperclass. Use equivalent on a FieldInfo.") fun <R> Field.max(groupByColumns: List<Field>? = null, orderBy: Sort.Direction? = null) MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic @JvmOverloads @Deprecated("Does not support fields from a MappedSuperclass. Use equivalent on a FieldInfo.") fun <R> Field.min(groupByColumns: List<Field>? = null, orderBy: Sort.Direction? = null) MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic @JvmOverloads @Deprecated("Does not support fields from a MappedSuperclass. Use equivalent on a FieldInfo.") fun <R> Field.sum(groupByColumns: List<Field>? = null, orderBy: Sort.Direction? = null) MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic @JvmOverloads fun <R : Comparable<R>> FieldInfo.`in`(collection: Collection<R>, exactMatch: Boolean = true) MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic @JvmOverloads fun <R : Comparable<R>> FieldInfo.notIn(collection: Collection<R>, exactMatch: Boolean = true) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic fun <R : Comparable<R>> FieldInfo.greaterThan(value: R) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic fun <R : Comparable<R>> FieldInfo.greaterThanOrEqual(value: R) - MaxLineLength:QueryCriteriaUtils.kt$Builder$@JvmStatic fun <R : Comparable<R>> FieldInfo.lessThanOrEqual(value: R) MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <O, R : Comparable<R>> KProperty1<O, R?>.comparePredicate(operator: BinaryComparisonOperator, value: R) - MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <O, R : Comparable<R>> KProperty1<O, R?>.greaterThan(value: R) MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <O, R : Comparable<R>> KProperty1<O, R?>.greaterThanOrEqual(value: R) - MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <O, R : Comparable<R>> KProperty1<O, R?>.lessThan(value: R) MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <O, R : Comparable<R>> KProperty1<O, R?>.lessThanOrEqual(value: R) - MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <O, R> KProperty1<O, R?>.count() MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <O, R> KProperty1<O, R?>.functionPredicate(predicate: ColumnPredicate<R>, groupByColumns: List<Column<O, R>>? = null, orderBy: Sort.Direction? = null) MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <O, R> KProperty1<O, R?>.predicate(predicate: ColumnPredicate<R>) - MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <R : Comparable<R>> FieldInfo.comparePredicate(operator: BinaryComparisonOperator, value: R) - MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <R : Comparable<R>> compare(operator: BinaryComparisonOperator, value: R) - MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <R : Comparable<R>> greaterThanOrEqual(value: R) MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <R> FieldInfo.functionPredicate(predicate: ColumnPredicate<R>, groupByColumns: List<Column<Any, R>>? = null, orderBy: Sort.Direction? = null) MaxLineLength:QueryCriteriaUtils.kt$Builder$fun <R> FieldInfo.predicate(predicate: ColumnPredicate<R>) - MaxLineLength:QueryCriteriaUtils.kt$Builder$functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.AVG), groupByColumns?.map { Column(it) }, orderBy) MaxLineLength:QueryCriteriaUtils.kt$Builder$functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.AVG), groupByColumns?.map { Column<Any, R>(it) }, orderBy) - MaxLineLength:QueryCriteriaUtils.kt$Builder$functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.MAX), groupByColumns?.map { Column(it) }, orderBy) MaxLineLength:QueryCriteriaUtils.kt$Builder$functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.MAX), groupByColumns?.map { Column<Any, R>(it) }, orderBy) - MaxLineLength:QueryCriteriaUtils.kt$Builder$functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.MIN), groupByColumns?.map { Column(it) }, orderBy) MaxLineLength:QueryCriteriaUtils.kt$Builder$functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.MIN), groupByColumns?.map { Column<Any, R>(it) }, orderBy) - MaxLineLength:QueryCriteriaUtils.kt$Builder$functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.SUM), groupByColumns?.map { Column(it) }, orderBy) MaxLineLength:QueryCriteriaUtils.kt$Builder$functionPredicate(ColumnPredicate.AggregateFunction(AggregateFunctionType.SUM), groupByColumns?.map { Column<Any, R>(it) }, orderBy) MaxLineLength:QueryCriteriaUtils.kt$Column.Companion$when (property) { // This is to ensure that, for a JPA Entity, a field declared in a MappedSuperclass will not cause Hibernate to reject a query referencing it. // TODO remove the cast and access the owner properly after it will be exposed as Kotlin's public API (https://youtrack.jetbrains.com/issue/KT-24170). is CallableReference -> ((property as CallableReference).owner as KClass<*>).javaObjectType else -> property.javaGetter!!.declaringClass } - MaxLineLength:QueryCriteriaUtils.kt$ColumnPredicate$BinaryComparison<C : Comparable<C>> : ColumnPredicate - MaxLineLength:QueryCriteriaUtils.kt$ColumnPredicate$CollectionExpression<C> : ColumnPredicate - MaxLineLength:QueryCriteriaUtils.kt$ColumnPredicate$EqualityComparison<C> : ColumnPredicate MaxLineLength:QueryCriteriaUtils.kt$CriteriaExpression$BinaryLogical<O> : CriteriaExpression MaxLineLength:QueryCriteriaUtils.kt$CriteriaExpression$ColumnPredicateExpression<O, C> : CriteriaExpression - MaxLineLength:R3Pty.kt$R3Pty : AutoCloseable - MaxLineLength:R3Pty.kt$R3Pty$private MaxLineLength:RPCApi.kt$RPCApi.ServerToClient$FailedToDeserializeReply : RuntimeException MaxLineLength:RPCApi.kt$RPCApi.ServerToClient.Companion$val id = message.invocationId(RPC_ID_FIELD_NAME, RPC_ID_TIMESTAMP_FIELD_NAME) ?: throw IllegalStateException("Cannot parse invocation id from client message.") MaxLineLength:RPCApi.kt$RPCApi.ServerToClient.Companion$val observableId = message.invocationId(OBSERVABLE_ID_FIELD_NAME, OBSERVABLE_ID_TIMESTAMP_FIELD_NAME) ?: throw IllegalStateException("Cannot parse invocation id from client message.") - MaxLineLength:RPCApi.kt$RPCApi.ServerToClient.Companion$val payload = message.getBodyAsByteArray().deserialize<Notification<*>>(context = poolWithIdContext) - MaxLineLength:RPCApi.kt$RPCApi.ServerToClient.Companion${ val id = message.invocationId(RPC_ID_FIELD_NAME, RPC_ID_TIMESTAMP_FIELD_NAME) ?: throw IllegalStateException("Cannot parse invocation id from client message.") val poolWithIdContext = context.withProperty(RpcRequestOrObservableIdKey, id) // The result here is a Try<> that represents the attempt to try the operation on the server side. // If anything goes wrong with deserialisation of the response, we propagate it differently because // we also need to pass through the invocation and dedupe IDs. val result: Try<Any?> = try { message.getBodyAsByteArray().deserialize(context = poolWithIdContext) } catch (e: Exception) { throw FailedToDeserializeReply(id, e) } RpcReply( id = id, deduplicationIdentity = deduplicationIdentity, result = result ) } - MaxLineLength:RPCApi.kt$RPCApi.ServerToClient.Observation$message.bodyBuffer.writeBytes(content.safeSerialize(context) { Notification.createOnError<Void?>(it) }.bytes) - MaxLineLength:RPCApi.kt$net.corda.nodeapi.RPCApi.kt MaxLineLength:RPCApi.kt$private MaxLineLength:RPCApi.kt$private fun ClientMessage.invocationId(valueProperty: String, timestampProperty: String): InvocationId? MaxLineLength:RPCApi.kt$private fun ClientMessage.sessionId(valueProperty: String, timestampProperty: String): SessionId? - MaxLineLength:RPCApi.kt$private fun SessionId.mapTo(message: ClientMessage) MaxLineLength:RPCApi.kt$private fun Trace.mapToExternal(message: ClientMessage) MaxLineLength:RPCApi.kt$return invocationId(RPC_ID_FIELD_NAME, RPC_ID_TIMESTAMP_FIELD_NAME) ?: throw IllegalStateException("Cannot extract reply id from client message.") MaxLineLength:RPCApi.kt$return sessionId(RPC_SESSION_ID_FIELD_NAME, RPC_SESSION_ID_TIMESTAMP_FIELD_NAME) ?: throw IllegalStateException("Cannot extract the session id from client message.") - MaxLineLength:RPCClient.kt$RPCClient$reconnectAttempts = if (haPoolTransportConfigurations.isEmpty()) rpcConfiguration.maxReconnectAttempts else 0 - MaxLineLength:RPCClient.kt$RPCClient$throw RPCException("Requested minimum protocol version (${rpcConfiguration.minimumServerProtocolVersion}) is higher" + " than the server's supported protocol version ($serverProtocolVersion)") - MaxLineLength:RPCClient.kt$RPCClient$val ops: I = uncheckedCast(Proxy.newProxyInstance(rpcOpsClass.classLoader, arrayOf(rpcOpsClass), proxyHandler)) - MaxLineLength:RPCClientProxyHandler.kt$ObservableContext - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler : InvocationHandler - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$ fun notifyServerAndClose() - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$ private fun close(notify: Boolean = true) - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$artemisMessage.putLongProperty(RPCApi.DEDUPLICATION_SEQUENCE_NUMBER_FIELD_NAME, deduplicationSequenceNumber.getAndIncrement()) - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$consumerSession = sessionFactory!!.createSession(rpcUsername, rpcPassword, false, true, true, false, DEFAULT_ACK_BATCH_SIZE) - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$if (deduplicationChecker.checkDuplicateMessageId(serverToClient.deduplicationIdentity, deduplicationSequenceNumber)) { log.info("Message duplication detected, discarding message") return } - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$log - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$log.debug("Server locator is closed or garbage collected. Proxy may have been closed during reconnect.") - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$log.error("RPC reply arrived to unknown RPC ID ${serverToClient.id}, this indicates an internal RPC error.") MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$private - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$private val deduplicationChecker = DeduplicationChecker(rpcConfiguration.deduplicationCacheExpiry, cacheFactory = cacheFactory) MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$private val serializationContextWithObservableContext = RpcClientObservableDeSerializer.createContext(serializationContext, observableContext) - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$producerSession = sessionFactory!!.createSession(rpcUsername, rpcPassword, false, true, true, false, DEFAULT_ACK_BATCH_SIZE) - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$retryInterval = minOf(maxRetryInterval, retryInterval.times(rpcConfiguration.connectionRetryIntervalMultiplier.toLong())) - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$return "{rpcUsername='$rpcUsername', clientAddress=$clientAddress, sessionId=$sessionId, targetLegalIdentity=$targetLegalIdentity}" MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$return cacheFactory.buildNamed(Caffeine.newBuilder().weakValues().removalListener(onObservableRemove).executor(SameThreadExecutor.getExecutor()), "RpcClientProxyHandler_rpcObservable") MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$throw UnsupportedOperationException("Method $calledMethod was added in RPC protocol version $sinceVersion but the server is running $serverProtocolVersion") - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$val observable: UnicastSubject<Notification<*>>? = observableContext.observableMap.getIfPresent(serverToClient.id) - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$val serialisedArguments = (arguments?.toList() ?: emptyList()).serialize(context = serializationContextWithObservableContext) - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler$var reconnectAttempts = rpcConfiguration.maxReconnectAttempts.times(serverLocator.staticTransportConfigurations.size) - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler${ // Deserialize the reply from the server, both the wrapping metadata and the actual body of the return value. val serverToClient: RPCApi.ServerToClient = try { RPCApi.ServerToClient.fromClientMessage(serializationContextWithObservableContext, message) } catch (e: RPCApi.ServerToClient.FailedToDeserializeReply) { // Might happen if something goes wrong during mapping the response to classes, evolution, class synthesis etc. log.error("Failed to deserialize RPC body", e) completeExceptionally(e.id, e, rpcReplyMap.remove(e.id)) return } val deduplicationSequenceNumber = message.getLongProperty(RPCApi.DEDUPLICATION_SEQUENCE_NUMBER_FIELD_NAME) if (deduplicationChecker.checkDuplicateMessageId(serverToClient.deduplicationIdentity, deduplicationSequenceNumber)) { log.info("Message duplication detected, discarding message") return } log.debug { "Got message from RPC server $serverToClient" } when (serverToClient) { is RPCApi.ServerToClient.RpcReply -> { val replyFuture = rpcReplyMap.remove(serverToClient.id) if (replyFuture == null) { log.error("RPC reply arrived to unknown RPC ID ${serverToClient.id}, this indicates an internal RPC error.") } else { val result: Try<Any?> = serverToClient.result when (result) { is Try.Success -> replyFuture.set(result.value) is Try.Failure -> { completeExceptionally(serverToClient.id, result.exception, replyFuture) } } } } is RPCApi.ServerToClient.Observation -> { val observable: UnicastSubject<Notification<*>>? = observableContext.observableMap.getIfPresent(serverToClient.id) if (observable == null) { log.debug("Observation ${serverToClient.content} arrived to unknown Observable with ID ${serverToClient.id}. " + "This may be due to an observation arriving before the server was " + "notified of observable shutdown") } else { // We schedule the onNext() on an executor sticky-pooled based on the Observable ID. observationExecutorPool.run(serverToClient.id) { executor -> executor.submit { val content = serverToClient.content if (content.isOnCompleted || content.isOnError) { observableContext.observableMap.invalidate(serverToClient.id) } // Add call site information on error if (content.isOnError) { val rpcCallSite = callSiteMap?.get(serverToClient.id) if (rpcCallSite != null) addRpcCallSiteToThrowable(content.throwable, rpcCallSite) } observable.onNext(content) } } } } } } - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler${ // Might happen if something goes wrong during mapping the response to classes, evolution, class synthesis etc. log.error("Failed to deserialize RPC body", e) completeExceptionally(e.id, e, rpcReplyMap.remove(e.id)) return } - MaxLineLength:RPCClientProxyHandler.kt$RPCClientProxyHandler${ // This is going to send remote message, see `org.apache.activemq.artemis.core.client.impl.ClientConsumerImpl.doCleanUp()`. sessionFactory?.close() } - MaxLineLength:RPCConcurrencyTests.kt$RPCConcurrencyTests$// We construct a rose tree of immediate Observables and check that parent observations arrive before children. val proxy = testProxy() val treeDepth = 6 val treeBranchingFactor = 3 val remainingLatch = CountDownLatch((intPower(treeBranchingFactor, treeDepth + 1) - 1) / (treeBranchingFactor - 1)) val depthsSeen = Collections.synchronizedSet(HashSet<Int>()) fun ObservableRose<Int>.subscribeToAll() { remainingLatch.countDown() this.branches.subscribe { tree -> (tree.value + 1 until treeDepth).forEach { require(it in depthsSeen) { "Got ${tree.value} before $it" } } depthsSeen.add(tree.value) tree.subscribeToAll() } } proxy.ops.getImmediateObservableTree(treeDepth, treeBranchingFactor).subscribeToAll() remainingLatch.await() - MaxLineLength:RPCConcurrencyTests.kt$RPCConcurrencyTests$val remainingLatch = CountDownLatch((intPower(treeBranchingFactor, treeDepth + 1) - 1) / (treeBranchingFactor - 1)) MaxLineLength:RPCDriver.kt$RPCDriverDSL$val artemisConfig = createRpcServerArtemisConfig(maxFileSize, maxBufferedBytesPerClient, driverDSL.driverDirectory / serverName, hostAndPort) - MaxLineLength:RPCDriver.kt$RPCDriverDSL$val process = ProcessUtilities.startJavaProcess<RandomRpcUser>(listOf(rpcOpsClass.name, rpcAddress.toString(), username, password)) MaxLineLength:RPCDriver.kt$RPCDriverDSL$val rpcSecurityManager = RPCSecurityManagerImpl.fromUserList(users = listOf(InternalUser(rpcUser.username, rpcUser.password, rpcUser.permissions)), id = AuthServiceId("TEST_SECURITY_MANAGER")) - MaxLineLength:RPCDriver.kt$RPCDriverDSL$val session = sessionFactory.createSession(username, password, false, true, true, locator.isPreAcknowledge, DEFAULT_ACK_BATCH_SIZE) MaxLineLength:RPCDriver.kt$RPCDriverDSL.Companion$fun createRpcServerArtemisConfig(maxFileSize: Int, maxBufferedBytesPerClient: Long, baseDirectory: Path, hostAndPort: NetworkHostAndPort): Configuration MaxLineLength:RPCDriver.kt$RandomRpcUser.Companion$private inline fun <reified T> HashMap<Class<*>, Generator<*>>.add(generator: Generator<T>) MaxLineLength:RPCDriver.kt$RandomRpcUser.Companion$val handle = RPCClient<RPCOps>(hostAndPort, null, serializationContext = AMQP_RPC_CLIENT_CONTEXT).start(rpcClass, username, password) MaxLineLength:RPCDriver.kt$SingleUserSecurityManager$override MaxLineLength:RPCDriver.kt$SingleUserSecurityManager$override fun validateUserAndRole(user: String?, password: String?, roles: MutableSet<Role>?, checkType: CheckType?) MaxLineLength:RPCHighThroughputObservableTests.kt$RPCHighThroughputObservableTests$val proxy = testProxy() // This tests that the observations are transmitted correctly, also check that server side doesn't try to serialize the whole lot // till client consumed some of the output produced. val observations = proxy.makeObservable() val observationsList = observations.take(4).toBlocking().toIterable().toList() assertEquals(listOf(1, 2, 3, 4), observationsList) - MaxLineLength:RPCHighThroughputObservableTests.kt$RPCHighThroughputObservableTests.TestOpsImpl$override fun makeObservable(): Observable<Int> - MaxLineLength:RPCOpsWithContext.kt$fun makeRPCOps(getCordaRPCOps: (username: String, credential: String) -> CordaRPCOps, username: String, credential: String): CordaRPCOps - MaxLineLength:RPCOpsWithContext.kt$return Proxy.newProxyInstance(CordaRPCOps::class.java.classLoader, arrayOf(CordaRPCOps::class.java), { _, method, args -> try { method.invoke(cordaRPCOps, *(args ?: arrayOf())) } catch (e: InvocationTargetException) { // Unpack exception. throw e.targetException } }) as CordaRPCOps - MaxLineLength:RPCPerformanceTests.kt$RPCPerformanceTests$Mbps = bigSize.toDouble() * numberOfMessages.toDouble() / elapsed * (1000000.0 / (1024.0 * 1024.0)) - MaxLineLength:RPCSecurityManagerTest.kt$RPCSecurityManagerTest$val userRealms = RPCSecurityManagerImpl(SecurityConfiguration.AuthService.fromUsers(listOf(user)), TestingNamedCacheFactory()) MaxLineLength:RPCSecurityManagerWithAdditionalUser.kt$RPCSecurityManagerWithAdditionalUser : RPCSecurityManager - MaxLineLength:RPCSecurityManagerWithAdditionalUser.kt$RPCSecurityManagerWithAdditionalUser$private - MaxLineLength:RPCServer.kt$// TODO replace this by creating a new CordaRPCImpl for each request, passing the context, after we fix Shell and WebServer @JvmField internal val CURRENT_RPC_CONTEXT: ThreadLocal<RpcAuthContext> = CurrentRpcContext() MaxLineLength:RPCServer.kt$RPCServer$consumerSession = sessionFactory!!.createSession(rpcServerUsername, rpcServerPassword, false, true, true, false, DEFAULT_ACK_BATCH_SIZE) MaxLineLength:RPCServer.kt$RPCServer$private - MaxLineLength:RPCServer.kt$RPCServer$private val deduplicationChecker = DeduplicationChecker(rpcConfiguration.deduplicationCacheExpiry, cacheFactory = cacheFactory) MaxLineLength:RPCServer.kt$RPCServer$producerSession = sessionFactory!!.createSession(rpcServerUsername, rpcServerPassword, false, true, true, false, DEFAULT_ACK_BATCH_SIZE) MaxLineLength:RPCServer.kt$RPCServer$require(notificationType == CoreNotificationType.BINDING_ADDED.name){"Message contained notification type of $notificationType instead of expected ${CoreNotificationType.BINDING_ADDED.name}"} MaxLineLength:RPCServer.kt$RPCServer$require(notificationType == CoreNotificationType.BINDING_REMOVED.name){"Message contained notification type of $notificationType instead of expected ${CoreNotificationType.BINDING_REMOVED.name}"} - MaxLineLength:RPCServer.kt$RPCServer$return Pair(Actor(Id(validatedUser), securityManager.id, targetLegalIdentity), securityManager.buildSubject(validatedUser)) - MaxLineLength:RPCServer.kt$RPCServer$return RpcAuthContext(InvocationContext.rpc(rpcActor.first, trace, externalTrace, impersonatedActor), rpcActor.second) MaxLineLength:RPCServer.kt$RPCServer$return cacheFactory.buildNamed(Caffeine.newBuilder().removalListener(onObservableRemove).executor(SameThreadExecutor.getExecutor()), "RPCServer_observableSubscription") - MaxLineLength:RPCServer.kt$RPCServer$throw RPCException("Received RPC for unknown method $methodName - possible client/server version skew?") - MaxLineLength:RPCServer.kt$RPCServer$val deduplicationSequenceNumber = artemisMessage.getLongProperty(RPCApi.DEDUPLICATION_SEQUENCE_NUMBER_FIELD_NAME) MaxLineLength:RPCServer.kt$RPCServer$val targetLegalIdentity = message.getStringProperty(RPCApi.RPC_TARGET_LEGAL_IDENTITY)?.let(CordaX500Name.Companion::parse) ?: nodeLegalName MaxLineLength:RPCServer.kt$RPCServer$val validatedUser = message.getStringProperty(Message.HDR_VALIDATED_USER) ?: throw IllegalArgumentException("Missing validated user from the Artemis message") - MaxLineLength:RPCServer.kt$RPCServer${ lifeCycle.requireState(State.UNSTARTED) log.info("Starting RPC server with configuration $rpcConfiguration") senderThread = startSenderThread() rpcExecutor = Executors.newScheduledThreadPool( rpcConfiguration.rpcThreadPoolSize, ThreadFactoryBuilder().setNameFormat("rpc-server-handler-pool-%d").build() ) reaperExecutor = Executors.newSingleThreadScheduledExecutor( ThreadFactoryBuilder().setNameFormat("rpc-server-reaper-%d").build() ) reaperScheduledFuture = reaperExecutor!!.scheduleAtFixedRate( this::reapSubscriptions, rpcConfiguration.reapInterval.toMillis(), rpcConfiguration.reapInterval.toMillis(), TimeUnit.MILLISECONDS ) sessionFactory = serverLocator.createSessionFactory() producerSession = sessionFactory!!.createSession(rpcServerUsername, rpcServerPassword, false, true, true, false, DEFAULT_ACK_BATCH_SIZE) createRpcProducer(producerSession!!) consumerSession = sessionFactory!!.createSession(rpcServerUsername, rpcServerPassword, false, true, true, false, DEFAULT_ACK_BATCH_SIZE) createRpcConsumer(consumerSession!!) createNotificationConsumers(consumerSession!!) serverControl = activeMqServerControl deduplicationIdentity = UUID.randomUUID().toString() lifeCycle.transition(State.UNSTARTED, State.STARTED) // We delay the consumer session start because Artemis starts delivering messages immediately, so we need to be // fully initialised. producerSession!!.start() consumerSession!!.start() } - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$RPCClient<RPCOps>(server.broker.hostAndPort!!).start(RPCOps::class.java, rpcTestUser.username, rpcTestUser.password).close() - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$configuration = CordaRPCClientConfiguration.DEFAULT.copy(minimumServerProtocolVersion = 1000) - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$message.putLongProperty(RPCApi.DEDUPLICATION_SEQUENCE_NUMBER_FIELD_NAME, dedupeId.getAndIncrement()) - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$pollUntilTrue("number of times subscribe() has been called") { trackSubscriberOpsImpl.subscriberCount.get() == 0 }.get() - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$pollUntilTrue("number of times subscribe() has been called") { trackSubscriberOpsImpl.subscriberCount.get() >= 100 }.get() - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$private - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$require(threadsBefore.keys.size >= threadsAfter.keys.size) { "threadsBefore: $threadsBefore\nthreadsAfter: $threadsAfter" } - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$serialisedArguments = emptyList<Any>().serialize(context = SerializationDefaults.RPC_SERVER_CONTEXT) - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$serialisedArguments = listOf(10.millis, 123456).serialize(context = SerializationDefaults.RPC_SERVER_CONTEXT) MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$val client = startRpcClient<ServerOps>(listOf(NetworkHostAndPort("localhost", 12345), serverAddress, NetworkHostAndPort("localhost", 54321))).getOrThrow() MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$val client = startRpcClient<ServerOps>(listOf(server1.broker.hostAndPort!!, server2.broker.hostAndPort!!, server3.broker.hostAndPort!!)).getOrThrow() MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$val clientConfiguration = CordaRPCClientConfiguration.DEFAULT.copy(connectionRetryInterval = 1.seconds, maxReconnectAttempts = 5) @@ -8108,105 +4538,42 @@ MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$val connection = RPCClient<RPCOps>(server.broker.hostAndPort!!).start(RPCOps::class.java, rpcTestUser.username, rpcTestUser.password) MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$val connection1 = RPCClient<RPCOps>(server.broker.hostAndPort!!).start(RPCOps::class.java, rpcTestUser.username, rpcTestUser.password) MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$val connection2 = RPCClient<RPCOps>(server.broker.hostAndPort!!).start(RPCOps::class.java, rpcTestUser.username, rpcTestUser.password) - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$val server = startRpcServer(maxBufferedBytesPerClient = 10 * 1024 * 1024, ops = SlowConsumerRPCOpsImpl()).get() - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests$val servers = mutableMapOf("server1" to serverFollower1, "server2" to serverFollower2, "server3" to serverFollower3) - MaxLineLength:RPCStabilityTests.kt$RPCStabilityTests${ // Warm-up so that all the thread pools & co. created block() val threadsBefore = waitUntilNumberOfThreadsStable(executor) repeat(5) { block() } val threadsAfter = waitUntilNumberOfThreadsStable(executor) // This is a less than check because threads from other tests may be shutting down while this test is running. // This is therefore a "best effort" check. When this test is run on its own this should be a strict equality. // In case of failure we output the threads along with their stacktraces to get an idea what was running at a time. require(threadsBefore.keys.size >= threadsAfter.keys.size) { "threadsBefore: $threadsBefore\nthreadsAfter: $threadsAfter" } } - MaxLineLength:RPCStabilityTests.kt$val clientAddresses = server.broker.serverControl.addressNames.filter { it.startsWith(RPCApi.RPC_CLIENT_QUEUE_NAME_PREFIX) } - MaxLineLength:RaftNotaryService.kt$RaftNotaryService$?: MaxLineLength:RaftNotaryServiceTests.kt$RaftNotaryServiceTests$val builder = DummyContract.generateInitial(Random().nextInt(), defaultNotaryIdentity, bankA.services.myInfo.singleIdentity().ref(0)) .setTimeWindow(bankA.services.clock.instant(), 30.seconds) - MaxLineLength:RaftNotaryServiceTests.kt$RaftNotaryServiceTests$val builder = DummyContract.generateInitial(Random().nextInt(), notary, nodeHandle.services.myInfo.singleIdentity().ref(0)) - MaxLineLength:RaftTransactionCommitLog.kt$RaftTransactionCommitLog$fun checkConflict(states: List<StateRef>, type: StateConsumptionDetails.ConsumedStateType) - MaxLineLength:RaftTransactionCommitLog.kt$RaftTransactionCommitLog$log.debug("State machine commit: attempting to store entries with keys (${commitCommand.states.joinToString()})") MaxLineLength:RaftTransactionCommitLog.kt$RaftTransactionCommitLog$private - MaxLineLength:RaftTransactionCommitLog.kt$RaftTransactionCommitLog$val deleteQuery = session.criteriaBuilder.createCriteriaDelete(PersistentUniquenessProvider.Request::class.java) - MaxLineLength:RaftTransactionCommitLog.kt$RaftTransactionCommitLog.Companion.CordaKryoSerializer$private val context = CheckpointSerializationDefaults.CHECKPOINT_CONTEXT.withEncoding(CordaSerializationEncoding.SNAPPY) - MaxLineLength:RaftTransactionCommitLogTests.kt$RaftTransactionCommitLogTests$private MaxLineLength:RaftTransactionCommitLogTests.kt$RaftTransactionCommitLogTests$val commitCommand = RaftTransactionCommitLog.Commands.CommitTransaction(states, txId, requestingPartyName.toString(), requestSignature) MaxLineLength:RaftTransactionCommitLogTests.kt$RaftTransactionCommitLogTests$val commitCommandFirst = RaftTransactionCommitLog.Commands.CommitTransaction(states, txIdFirst, requestingPartyName.toString(), requestSignature) MaxLineLength:RaftTransactionCommitLogTests.kt$RaftTransactionCommitLogTests$val commitCommandSecond = RaftTransactionCommitLog.Commands.CommitTransaction(states, txIdSecond, requestingPartyName.toString(), requestSignature) MaxLineLength:RaftTransactionCommitLogTests.kt$RaftTransactionCommitLogTests$val database = configureDatabase(makeTestDataSourceProperties(), DatabaseConfig(), { null }, { null }, NodeSchemaService(extraSchemas = setOf(RaftNotarySchemaV1))) MaxLineLength:RaftTransactionCommitLogTests.kt$RaftTransactionCommitLogTests$val stateMachineFactory = { RaftTransactionCommitLog(database, Clock.systemUTC(), { RaftUniquenessProvider.createMap(TestingNamedCacheFactory()) }) } - MaxLineLength:RaftUniquenessProvider.kt$RaftUniquenessProvider : UniquenessProviderSingletonSerializeAsToken - MaxLineLength:RaftUniquenessProvider.kt$RaftUniquenessProvider.Companion$fun createMap(cacheFactory: NamedCacheFactory): AppendOnlyPersistentMap<StateRef, Pair<Long, SecureHash>, CommittedState, String> - MaxLineLength:RaftUniquenessProvider.kt$RaftUniquenessProvider.Companion$it.value.deserialize<SecureHash>(context = SerializationDefaults.STORAGE_CONTEXT) - MaxLineLength:Rate.kt$Rate$override fun toString(): String - MaxLineLength:RatesFixFlow.kt$RatesFixFlow$ @Suspendable protected open fun filtering(elem: Any): Boolean MaxLineLength:RatesFixFlow.kt$RatesFixFlow$override val progressTracker: ProgressTracker = RatesFixFlow.tracker(fixOf.name) MaxLineLength:ReactiveArtemisConsumer.kt$MultiplexingReactiveArtemisConsumer$private MaxLineLength:ReactiveArtemisConsumer.kt$ReactiveArtemisConsumer.Companion$fun multiplex(createSession: () -> ClientSession, queueName: String, filter: String? = null, vararg queueNames: String): ReactiveArtemisConsumer - MaxLineLength:ReactiveArtemisConsumer.kt$ReactiveArtemisConsumer.Companion$fun multiplex(queueNames: Set<String>, createSession: () -> ClientSession, filter: String? = null): ReactiveArtemisConsumer - MaxLineLength:ReceiveAllFlowTests.kt$ReceiveMultipleFlowTests$ParallelAlgorithmMap : AlgorithmDefinition - MaxLineLength:ReceiveAllFlowTests.kt$ReceiveMultipleFlowTests$nodes[0].startFlowAndRunNetwork(ParallelAlgorithmList(nodes[1].info.singleIdentity(), nodes[2].info.singleIdentity())) - MaxLineLength:ReceiveAllFlowTests.kt$ReceiveMultipleFlowTests$nodes[0].startFlowAndRunNetwork(ParallelAlgorithmMap(nodes[1].info.singleIdentity(), nodes[2].info.singleIdentity())) - MaxLineLength:ReceiveAllFlowTests.kt$ReceiveMultipleFlowTests.AlgorithmDefinition$@InitiatingFlow abstract - MaxLineLength:ReceiveFinalityFlowTest.kt$ReceiveFinalityFlowTest$bob = mockNet.restartNode(bob, parameters = InternalMockNodeParameters(additionalCordapps = listOf(FINANCE_CONTRACTS_CORDAPP))) - MaxLineLength:ReceiveFinalityFlowTest.kt$ReceiveFinalityFlowTest$private val mockNet = InternalMockNetwork(notarySpecs = listOf(MockNetworkNotarySpec(DUMMY_NOTARY_NAME, validating = false))) - MaxLineLength:ReceiveFinalityFlowTest.kt$ReceiveFinalityFlowTest$val alice = mockNet.createNode(InternalMockNodeParameters(legalName = ALICE_NAME, additionalCordapps = FINANCE_CORDAPPS)) - MaxLineLength:ReceiveFinalityFlowTest.kt$ReceiveFinalityFlowTest$val paymentReceiverFuture = bob.smm.track().updates.filter { it.logic is CashPaymentReceiverFlow }.map { it.logic.runId }.toFuture() MaxLineLength:ReceiveFinalityFlowTest.kt$ReceiveFinalityFlowTest$var bob = mockNet.createNode(InternalMockNodeParameters(legalName = BOB_NAME, additionalCordapps = listOf(FINANCE_WORKFLOWS_CORDAPP))) - MaxLineLength:ReceiveFinalityFlowTest.kt$ReceiveFinalityFlowTest${ val alice = mockNet.createNode(InternalMockNodeParameters(legalName = ALICE_NAME, additionalCordapps = FINANCE_CORDAPPS)) // Bob initially does not have the finance contracts CorDapp so that it can throw an exception in ReceiveFinalityFlow when receiving // the payment from Alice var bob = mockNet.createNode(InternalMockNodeParameters(legalName = BOB_NAME, additionalCordapps = listOf(FINANCE_WORKFLOWS_CORDAPP))) val paymentReceiverFuture = bob.smm.track().updates.filter { it.logic is CashPaymentReceiverFlow }.map { it.logic.runId }.toFuture() alice.services.startFlow(CashIssueAndPaymentFlow( 100.POUNDS, OpaqueBytes.of(0), bob.info.singleIdentity(), false, mockNet.defaultNotaryIdentity )) mockNet.runNetwork() val paymentReceiverId = paymentReceiverFuture.getOrThrow() assertThat(bob.services.vaultService.queryBy<FungibleAsset<*>>().states).isEmpty() bob.assertFlowSentForObservationDueToConstraintError(paymentReceiverId) // Restart Bob with the contracts CorDapp so that it can recover from the error bob = mockNet.restartNode(bob, parameters = InternalMockNodeParameters(additionalCordapps = listOf(FINANCE_CONTRACTS_CORDAPP))) mockNet.runNetwork() assertThat(bob.services.getCashBalance(GBP)).isEqualTo(100.POUNDS) } MaxLineLength:ReceiveTransactionFlow.kt$ReceiveStateAndRefFlow<out T : ContractState> : FlowLogic MaxLineLength:ReceiveTransactionFlow.kt$ReceiveTransactionFlow : FlowLogic - MaxLineLength:ReceiveTransactionFlow.kt$ReceiveTransactionFlow$logger.trace { "Receiving a transaction (but without checking the signatures) from ${otherSideSession.counterparty}" } MaxLineLength:ReceiveTransactionFlow.kt$ReceiveTransactionFlow$private val statesToRecord: StatesToRecord = StatesToRecord.NONE MaxLineLength:ReconnectingCordaRPCOps.kt$CouldNotStartFlowException : RPCException - MaxLineLength:ReconnectingCordaRPCOps.kt$ObserverHandle$internal MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps : AutoCloseableCordaRPCOps MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps$ fun <T> runFlowAndReturnResultWithLogicalRetry(runFlow: (CordaRPCOps) -> FlowHandle<T>, hasFlowCompleted: (CordaRPCOps) -> T?, timeout: Duration = 4.seconds): T MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps$ fun runFlowWithLogicalRetry(runFlow: (CordaRPCOps) -> StateMachineRunId, hasFlowStarted: (CordaRPCOps) -> Boolean, onFlowConfirmed: () -> Unit = {}, timeout: Duration = 4.seconds) - MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.Companion$private - MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.ErrorInterceptingHandler$log.error("Node is being shutdown. Operation ${method.name} rejected. Retrying when node is up...", e) MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.ErrorInterceptingHandler$private - MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.ReconnectingObservableImpl$override MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.ReconnectingObservableImpl$private - MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.ReconnectingObservableImpl$val subscription = initial.updates.let { if (startWithValues != null) it.startWith(startWithValues) else it } .subscribe(onNext, observerHandle::fail, observerHandle::stop) MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.ReconnectingRPCConnection$nodeHostAndPorts - MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingCordaRPCOps.ReconnectingRPCConnection$private tailrec - MaxLineLength:ReconnectingCordaRPCOps.kt$ReconnectingObservable$fun subscribe(onNext: (T) -> Unit, onStop: () -> Unit, onDisconnect: () -> Unit, onReconnect: () -> Unit): ObserverHandle MaxLineLength:ReconnectingCordaRPCOps.kt$fun <T> Observable<T>.asReconnectingWithInitialValues(values: Iterable<T>): ReconnectingObservable<T> - MaxLineLength:ReferenceInputStateTests.kt$ReferenceStateTests$TransactionBuilder(notary = DUMMY_NOTARY).addInputState(stateAndRef).addReferenceState(stateAndRef.referenced()) - MaxLineLength:ReferenceInputStateTests.kt$ReferenceStateTests$networkParameters = testNetworkParameters(minimumPlatformVersion = 4, notaries = listOf(NotaryInfo(DUMMY_NOTARY, true))) MaxLineLength:ReferenceInputStateTests.kt$ReferenceStateTests$output(ExampleContract::class.java.typeName, "UPDATED REF DATA", "REF DATA".output<ExampleState>().copy(data = "NEW STUFF!")) MaxLineLength:ReferenceInputStateTests.kt$ReferenceStateTests$val stateAndRef = StateAndRef(TransactionState(state, CONTRACT_ID, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint), StateRef(SecureHash.zeroHash, 0)) - MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests$UseRefState : FlowLogic MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests$assertEquals(4, nodes[1].services.vaultService.queryBy<LinearState>(QueryCriteria.VaultQueryCriteria(status = Vault.StateStatus.ALL)).states.size) - MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests$val newTx = nodes[0].services.startFlow(UseRefState(nodes[1].info.legalIdentities.first(), newRefState.state.data.linearId)) .resultFuture.getOrThrow() MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests$val newTx = nodes[0].services.startFlow(UseRefState(nodes[1].info.legalIdentities.first(), newRefState.state.data.linearId)).resultFuture.getOrThrow() - MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests$val updatedQuery = QueryCriteria.VaultQueryCriteria(stateRefs = listOf(newRefState.ref), status = Vault.StateStatus.ALL) - MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests$val updatedTx = nodes[0].services.startFlow(UseRefState(nodes[1].info.legalIdentities.first(), newRefState.state.data.linearId)) .resultFuture.getOrThrow() MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests$val useRefTx = nodes[1].services.startFlow(WithReferencedStatesFlow { UseRefState(nodeOneIdentity, newRefState.state.data.linearId) }).resultFuture MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests${ // 1. Create a state to be used as a reference state. Don't share it. val newRefTx = nodes[0].services.startFlow(CreateRefState()).resultFuture.getOrThrow() val newRefState = newRefTx.tx.outRefsOfType<RefState.State>().single() // 2. Use the "newRefState" a transaction involving another party (nodes[1]) which creates a new state. They should store the new state and the reference state. val newTx = nodes[0].services.startFlow(UseRefState(nodes[1].info.legalIdentities.first(), newRefState.state.data.linearId)).resultFuture.getOrThrow() // Wait until node 1 stores the new tx. nodes[1].services.validatedTransactions.updates.filter { it.id == newTx.id }.toFuture().getOrThrow() // Check that nodes[1] has finished recording the transaction (and updating the vault.. hopefully!). // nodes[1] should have two states. The newly created output of type "Regular.State" and the reference state created by nodes[0]. assertEquals(2, nodes[1].services.vaultService.queryBy<LinearState>().states.size) // Now let's find the specific reference state on nodes[1]. val refStateLinearId = newRefState.state.data.linearId val query = QueryCriteria.LinearStateQueryCriteria(linearId = listOf(refStateLinearId)) val theReferencedState = nodes[1].services.vaultService.queryBy<RefState.State>(query) // There should be one result - the reference state. assertEquals(newRefState, theReferencedState.states.single()) println(theReferencedState.statesMetadata.single()) // nodes[0] should also have the same state. val nodeZeroQuery = QueryCriteria.LinearStateQueryCriteria(linearId = listOf(refStateLinearId)) val theReferencedStateOnNodeZero = nodes[0].services.vaultService.queryBy<RefState.State>(nodeZeroQuery) assertEquals(newRefState, theReferencedStateOnNodeZero.states.single()) // nodes[0] sends the tx that created the reference state to nodes[1]. nodes[0].services.startFlow(Initiator(newRefState)).resultFuture.getOrThrow() // Query again. val theReferencedStateAgain = nodes[1].services.vaultService.queryBy<RefState.State>(query) // There should be one result - the reference state. assertEquals(newRefState, theReferencedStateAgain.states.single()) } MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests${ // 1. Create a state to be used as a reference state. Don't share it. val newRefTx = nodes[0].services.startFlow(CreateRefState()).resultFuture.getOrThrow() val newRefState = newRefTx.tx.outRefsOfType<RefState.State>().single() // 2. Use the "newRefState" a transaction involving another party (nodes[1]) which creates a new state. They should store the new state and the reference state. val newTx = nodes[0].services.startFlow(UseRefState(nodes[1].info.legalIdentities.first(), newRefState.state.data.linearId)).resultFuture.getOrThrow() // Wait until node 1 stores the new tx. nodes[1].services.validatedTransactions.updates.filter { it.id == newTx.id }.toFuture().getOrThrow() // Check that nodes[1] has finished recording the transaction (and updating the vault.. hopefully!). val allRefStates = nodes[1].services.vaultService.queryBy<LinearState>() // nodes[1] should have two states. The newly created output and the reference state created by nodes[0]. assertEquals(2, allRefStates.states.size) } MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests${ // 1. Create a state to be used as a reference state. Don't share it. val newRefTx = nodes[0].services.startFlow(CreateRefState()).resultFuture.getOrThrow() val newRefState = newRefTx.tx.outRefsOfType<RefState.State>().single() // 2. Use the "newRefState" in a transaction involving another party (nodes[1]) which creates a new state. They should store the new state and the reference state. val newTx = nodes[0].services.startFlow(UseRefState(nodes[1].info.legalIdentities.first(), newRefState.state.data.linearId)) .resultFuture.getOrThrow() // Wait until node 1 stores the new tx. nodes[1].services.validatedTransactions.updates.filter { it.id == newTx.id }.toFuture().getOrThrow() // Check that nodes[1] has finished recording the transaction (and updating the vault.. hopefully!). // nodes[1] should have two states. The newly created output of type "Regular.State" and the reference state created by nodes[0]. assertEquals(2, nodes[1].services.vaultService.queryBy<LinearState>().states.size) // Now let's find the specific reference state on nodes[1]. val refStateLinearId = newRefState.state.data.linearId val query = QueryCriteria.LinearStateQueryCriteria(linearId = listOf(refStateLinearId)) val theReferencedState = nodes[1].services.vaultService.queryBy<RefState.State>(query) // There should be one result - the reference state. assertEquals(newRefState, theReferencedState.states.single()) // The reference state should not be consumed. assertEquals(Vault.StateStatus.UNCONSUMED, theReferencedState.statesMetadata.single().status) // nodes[0] should also have the same state. val nodeZeroQuery = QueryCriteria.LinearStateQueryCriteria(linearId = listOf(refStateLinearId)) val theReferencedStateOnNodeZero = nodes[0].services.vaultService.queryBy<RefState.State>(nodeZeroQuery) assertEquals(newRefState, theReferencedStateOnNodeZero.states.single()) assertEquals(Vault.StateStatus.UNCONSUMED, theReferencedStateOnNodeZero.statesMetadata.single().status) // 3. Update the reference state but don't share the update. val updatedRefTx = nodes[0].services.startFlow(UpdateRefState(newRefState)).resultFuture.getOrThrow() // 4. Use the evolved state as a reference state. val updatedTx = nodes[0].services.startFlow(UseRefState(nodes[1].info.legalIdentities.first(), newRefState.state.data.linearId)) .resultFuture.getOrThrow() // Wait until node 1 stores the new tx. nodes[1].services.validatedTransactions.updates.filter { it.id == updatedTx.id }.toFuture().getOrThrow() // Check that nodes[1] has finished recording the transaction (and updating the vault.. hopefully!). // nodes[1] should have four states. The originals, plus the newly created output of type "Regular.State" and the reference state created by nodes[0]. assertEquals(4, nodes[1].services.vaultService.queryBy<LinearState>(QueryCriteria.VaultQueryCriteria(status = Vault.StateStatus.ALL)).states.size) // Now let's find the original reference state on nodes[1]. val updatedQuery = QueryCriteria.VaultQueryCriteria(stateRefs = listOf(newRefState.ref), status = Vault.StateStatus.ALL) val theOriginalReferencedState = nodes[1].services.vaultService.queryBy<RefState.State>(updatedQuery) // There should be one result - the original reference state. assertEquals(newRefState, theOriginalReferencedState.states.single()) // The reference state should be consumed. assertEquals(Vault.StateStatus.CONSUMED, theOriginalReferencedState.statesMetadata.single().status) // nodes[0] should also have the same state. val theOriginalReferencedStateOnNodeZero = nodes[0].services.vaultService.queryBy<RefState.State>(updatedQuery) assertEquals(newRefState, theOriginalReferencedStateOnNodeZero.states.single()) assertEquals(Vault.StateStatus.CONSUMED, theOriginalReferencedStateOnNodeZero.statesMetadata.single().status) } MaxLineLength:ReferencedStatesFlowTests.kt$ReferencedStatesFlowTests.RefState.State$data - MaxLineLength:RemoteSerializerFactory.kt$DefaultRemoteSerializerFactory : RemoteSerializerFactory - MaxLineLength:RemoteSerializerFactory.kt$DefaultRemoteSerializerFactory$RemoteAndLocalTypeInformation(remoteInformation, localInformationByIdentifier[remoteInformation.typeIdentifier]!!) - MaxLineLength:RemoteSerializerFactory.kt$DefaultRemoteSerializerFactory$logger.trace("get Serializer descriptor=$typeDescriptor") // Interpret all of the types in the schema into RemoteTypeInformation, and reflect that into LocalTypeInformation. val remoteTypeInformationMap = remoteTypeModel.interpret(schema) val reflected = reflect(remoteTypeInformationMap, context) // Get, and record in the registry, serializers for all of the types contained in the schema. // This will save us having to re-interpret the entire schema on re-entry when deserialising individual property values. val serializers = reflected.mapValues { (descriptor, remoteLocalPair) -> descriptorBasedSerializerRegistry.getOrBuild(descriptor) { getUncached(remoteLocalPair.remoteTypeInformation, remoteLocalPair.localTypeInformation) } } // Return the specific serializer the caller asked for. serializers[typeDescriptor] ?: throw NotSerializableException( "Could not find type matching descriptor $typeDescriptor.") - MaxLineLength:RemoteSerializerFactory.kt$DefaultRemoteSerializerFactory$when { // If descriptors match, we can return the local serializer straight away. localDescriptor == remoteDescriptor -> localSerializer // Can we deserialise without evolution, e.g. going from List<Foo> to List<*>? remoteTypeInformation.isDeserialisableWithoutEvolutionTo(localTypeInformation) -> localSerializer // Are the remote/local types evolvable? If so, ask the evolution serializer factory for a serializer, returning // the local serializer if it returns null (i.e. no evolution required). remoteTypeInformation.isEvolvableTo(localTypeInformation) -> evolutionSerializerFactory.getEvolutionSerializer(remoteTypeInformation, localTypeInformation) ?: localSerializer // Descriptors don't match, and something is probably broken, but we let the framework do what it can with the local // serialiser (BlobInspectorTest uniquely breaks if we throw an exception here, and passes if we just warn and continue). else -> { logger.warn(""" Mismatch between type descriptors, but remote type is not evolvable to local type. Remote type (descriptor: $remoteDescriptor) ${remoteTypeInformation.prettyPrint(false)} Local type (descriptor $localDescriptor): ${localTypeInformation.prettyPrint(false)} """) localSerializer } } - MaxLineLength:RemoteSerializerFactory.kt$RemoteSerializerFactory$ @Throws(NotSerializableException::class, ClassNotFoundException::class) fun get(typeDescriptor: TypeDescriptor, schema: SerializationSchemas, context: SerializationContext): AMQPSerializer<Any> - MaxLineLength:RemoteTypeCarpenter.kt$SchemaBuildingRemoteTypeCarpenter$if (typeInformation.typeIdentifier !is TypeIdentifier.Parameterised) typeInformation.carpentComposable() - MaxLineLength:RemoteTypeInformation.kt$RemoteTypeInformation - MaxLineLength:RemoteTypeInformation.kt$RemoteTypeInformation$ fun prettyPrint(simplifyClassNames: Boolean = true): String MaxLineLength:RemoteTypeInformation.kt$RemoteTypeInformation.AnArray$data MaxLineLength:RemoteTypeInformation.kt$RemoteTypeInformation.AnInterface$data MaxLineLength:RemoteTypeInformation.kt$RemoteTypeInformation.Parameterised$data MaxLineLength:RemoteTypeInformation.kt$RemoteTypeInformation.Unparameterised$data - MaxLineLength:RemoteTypeInformation.kt$RemoteTypeInformationPrettyPrinter$private data - MaxLineLength:ReplayedList.kt$ReplayedList<A> : TransformationList - MaxLineLength:Reporter.kt$ObjectName("$domain:type=$category,${if (component.isNotEmpty()) "component=$component," else ""}name=$subName") - MaxLineLength:ResolveStatePointersTest.kt$ResolveStatePointersTest$networkParameters = testNetworkParameters(minimumPlatformVersion = 4, notaries = listOf(NotaryInfo(notary.party, true))) - MaxLineLength:ResolveStatePointersTest.kt$ResolveStatePointersTest.Foo$@BelongsToContract(DummyContract::class) private data - MaxLineLength:ResolveTransactionsFlow.kt$ResolveTransactionsFlow$/** * Resolves and validates the dependencies of the specified [SignedTransaction]. Fetches the attachments, but does * *not* validate or store the [SignedTransaction] itself. * * @return a list of verified [SignedTransaction] objects, in a depth-first order. */ constructor(signedTransaction: SignedTransaction, otherSide: FlowSession) : this(dependencyIDs(signedTransaction), otherSide) { this.signedTransaction = signedTransaction } - MaxLineLength:ResolveTransactionsFlow.kt$ResolveTransactionsFlow$?: MaxLineLength:ResolveTransactionsFlow.kt$ResolveTransactionsFlow$constructor(signedTransaction: SignedTransaction, otherSide: FlowSession, statesToRecord: StatesToRecord) : this(dependencyIDs(signedTransaction), otherSide, statesToRecord) { this.signedTransaction = signedTransaction } - MaxLineLength:ResolveTransactionsFlow.kt$ResolveTransactionsFlow$is ContractUpgradeWireTransaction -> listOf(tx.legacyContractAttachmentId, tx.upgradedContractAttachmentId) - MaxLineLength:ResolveTransactionsFlow.kt$ResolveTransactionsFlow$val counterpartyPlatformVersion = serviceHub.networkMapCache.getNodeByLegalIdentity(otherSide.counterparty)?.platformVersion ?: throw FlowException("Couldn't retrieve party's ${otherSide.counterparty} platform version from NetworkMapCache") - MaxLineLength:ResolveTransactionsFlow.kt$ResolveTransactionsFlow$val downloads: List<SignedTransaction> = subFlow(FetchTransactionsFlow(notAlreadyFetched, otherSide)).downloaded - MaxLineLength:ResolveTransactionsFlow.kt$ResolveTransactionsFlow$val missingParameters = parameters.filter { !(serviceHub.networkParametersService as NetworkParametersStorage).hasParameters(it) } - MaxLineLength:ResolveTransactionsFlow.kt$ResolveTransactionsFlow$val usedStatesToRecord = if (statesToRecord == StatesToRecord.NONE) StatesToRecord.ONLY_RELEVANT else statesToRecord - MaxLineLength:ResolveTransactionsFlow.kt$ResolveTransactionsFlow${ val page = page(pageNumber, RESOLUTION_PAGE_SIZE) newTxns += downloadDependencies(page) val txsWithMissingAttachments = if (pageNumber == 0) signedTransaction?.let { newTxns + it } ?: newTxns else newTxns fetchMissingAttachments(txsWithMissingAttachments) // Fetch missing parameters flow was added in version 4. This check is needed so we don't end up with node V4 sending parameters // request to node V3 that doesn't know about this protocol. if (counterpartyPlatformVersion >= 4) { fetchMissingParameters(txsWithMissingAttachments) } } - MaxLineLength:ResolveTransactionsFlow.kt$ResolveTransactionsFlow.Companion$private fun dependencyIDs(stx: SignedTransaction) - MaxLineLength:ResolveTransactionsFlowTest.kt$ResolveTransactionsFlowTest$mockNet = MockNetwork(MockNetworkParameters(cordappsForAllNodes = listOf(DUMMY_CONTRACTS_CORDAPP, enclosedCordapp()))) MaxLineLength:ResolveTransactionsFlowTest.kt$ResolveTransactionsFlowTest$private MaxLineLength:ResolveTransactionsFlowTest.kt$ResolveTransactionsFlowTest.TestFlow$@InitiatingFlow open MaxLineLength:ResolveTransactionsFlowTest.kt$ResolveTransactionsFlowTest.TestFlow$constructor(txHashes: Set<SecureHash>, otherSide: Party, txCountLimit: Int? = null) : this(otherSide, { ResolveTransactionsFlow(txHashes, it) }, txCountLimit = txCountLimit) @@ -8214,378 +4581,160 @@ MaxLineLength:ResolveTransactionsFlowTest.kt$ResolveTransactionsFlowTest.TestResponseResolveNoRightsFlow$otherSideSession.sendAndReceive<Any>(FetchDataFlow.Request.Data(NonEmptySet.of(noRightsTx.inputs.first().txhash), FetchDataFlow.DataType.TRANSACTION)).unwrap { it } MaxLineLength:ResolveTransactionsFlowTest.kt$ResolveTransactionsFlowTest.TestResponseResolveTwiceFlow$otherSideSession.sendAndReceive<Any>(FetchDataFlow.Request.Data(NonEmptySet.of(parent1), FetchDataFlow.DataType.TRANSACTION)).unwrap { it } MaxLineLength:RetryFlowMockTest.kt$RetryFlowMockTest${ val messagesSent = Collections.synchronizedList(mutableListOf<Message>()) val partyB = nodeB.info.legalIdentities.first() nodeA.setMessagingServiceSpy(object : MessagingServiceSpy() { override fun send(message: Message, target: MessageRecipients, sequenceKey: Any) { messagesSent.add(message) messagingService.send(message, target) } }) val count = 10000 // Lots of iterations so the flow keeps going long enough nodeA.startFlow(KeepSendingFlow(count, partyB)) eventually(waitBetween = Duration.ofMillis(10)) { assertTrue(messagesSent.isNotEmpty()) assertNotNull(messagesSent.first().senderUUID) } nodeA = mockNet.restartNode(nodeA) // This is a bit racy because restarting the node actually starts it, so we need to make sure there's enough iterations we get here with flow still going. nodeA.setMessagingServiceSpy(object : MessagingServiceSpy() { override fun send(message: Message, target: MessageRecipients, sequenceKey: Any) { messagesSent.add(message) messagingService.send(message, target) } }) // Now short circuit the iterations so the flow finishes soon. KeepSendingFlow.count.set(count - 2) eventually(waitBetween = Duration.ofMillis(10)) { assertTrue(nodeA.smm.allStateMachines.isEmpty()) } assertNull(messagesSent.last().senderUUID) } - MaxLineLength:RetryFlowMockTest.kt$RetryFlowMockTest.<no name provided>$override - MaxLineLength:RewriteClassMethods.kt$RewriteClassMethods$INVOKEVIRTUAL - MaxLineLength:RewriteClassMethods.kt$RewriteClassMethods${ invokeStatic( owner = "sandbox/java/lang/DJVM", name = "isEnum", descriptor = "(Ljava/lang/Class;)Z" ) preventDefault() } - MaxLineLength:RigorousMock.kt$ fun <T> participant(clazz: Class<out T>) - MaxLineLength:RigorousMock.kt$ fun <T> rigorousMock(clazz: Class<out T>) - MaxLineLength:RigorousMock.kt$ fun <T> spectator(clazz: Class<out T>) MaxLineLength:RigorousMock.kt$ParticipantDefaultAnswer$"Please specify what should happen when '${invocation.method}' is called, or don't call it. Args: ${Arrays.toString(invocation.arguments)}" MaxLineLength:RigorousMock.kt$RigorousMockDefaultAnswer$return if (Modifier.isAbstract(invocation.method.modifiers)) ParticipantDefaultAnswer.answerImpl(invocation) else invocation.callRealMethod() MaxLineLength:RigorousMock.kt$SpectatorDefaultAnswer.MethodInfo$private fun newSpectator(invocation: InvocationOnMock) - MaxLineLength:RigorousMock.kt$SpectatorDefaultAnswer.MethodInfo$return context.actualTypeArguments[clazz.typeParameters.indexOf(resolveType(clazz.genericSuperclass, type))] - MaxLineLength:RigorousMock.kt$UndefinedMockBehaviorException : RuntimeException - MaxLineLength:RigorousMockTest.kt$RigorousMockTest$assertSame<Any>(UndefinedMockBehaviorException::class.java, catchThrowable { collaborator.noClearDefault() }.javaClass) - MaxLineLength:RigorousMockTest.kt$RigorousMockTest$assertSame<Any>(UndefinedMockBehaviorException::class.java, catchThrowable { m.a }.javaClass) MaxLineLength:RigorousMockTest.kt$RigorousMockTest$assertSame<Any>(UndefinedMockBehaviorException::class.java, catchThrowable { m.kotlinDefaultFun() }.javaClass) MaxLineLength:RolesAdderOnLogin.kt$RolesAdderOnLogin$internal - MaxLineLength:RoundTripObservableSerializerTests.kt$RoundTripObservableSerializerTests$return Caffeine.newBuilder().weakValues().removalListener(onObservableRemove).executor(SameThreadExecutor.getExecutor()).build() MaxLineLength:RoundTripObservableSerializerTests.kt$RoundTripObservableSerializerTests$serializationContext - MaxLineLength:RoundTripObservableSerializerTests.kt$RoundTripObservableSerializerTests$val subMap: Cache<Trace.InvocationId, ObservableSubscription> = Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.MINUTES) .maximumSize(100) .build() - MaxLineLength:RpcBrokerConfiguration.kt$RpcBrokerConfiguration$deleteNonDurableQueue: Boolean = false MaxLineLength:RpcBrokerConfiguration.kt$RpcBrokerConfiguration$internal MaxLineLength:RpcBrokerConfiguration.kt$RpcBrokerConfiguration$journalBufferSize_AIO = maxMessageSize MaxLineLength:RpcBrokerConfiguration.kt$RpcBrokerConfiguration$journalBufferSize_NIO = maxMessageSize - MaxLineLength:RpcBrokerConfiguration.kt$RpcBrokerConfiguration$private MaxLineLength:RpcBrokerConfiguration.kt$RpcBrokerConfiguration$return Role(name, send, consume, createDurableQueue, deleteDurableQueue, createNonDurableQueue, deleteNonDurableQueue, manage, browse, createDurableQueue || createNonDurableQueue, deleteDurableQueue || deleteNonDurableQueue) - MaxLineLength:RpcBrokerConfiguration.kt$RpcBrokerConfiguration$securityRoles[RPCApi.RPC_SERVER_QUEUE_NAME] = setOf(nodeInternalRole, restrictedRole(BrokerJaasLoginModule.RPC_ROLE, send = true)) - MaxLineLength:RpcBrokerConfiguration.kt$RpcBrokerConfiguration$val addRPCRoleToUsers = if (shouldStartLocalShell) listOf(ArtemisMessagingComponent.INTERNAL_SHELL_USER) else emptyList() - MaxLineLength:RpcBrokerConfiguration.kt$RpcBrokerConfiguration$val nodeInternalRole = Role(BrokerJaasLoginModule.NODE_RPC_ROLE, true, true, true, true, true, true, true, true, true, true) - MaxLineLength:RpcClientCordaFutureSerializer.kt$RpcClientCordaFutureSerializer$throw NotSerializableException("Failed to deserialize Future from proxy Observable - ${e.message}\n").apply { initCause(e.cause) } - MaxLineLength:RpcClientObservableDeSerializer.kt$RpcClientObservableDeSerializer : Implements - MaxLineLength:RpcClientObservableDeSerializer.kt$RpcClientObservableDeSerializer$private - MaxLineLength:RpcClientObservableDeSerializer.kt$RpcClientObservableDeSerializer$val observableId: Trace.InvocationId = Trace.InvocationId((obj[0] as String), Instant.ofEpochMilli((obj[1] as Long))) - MaxLineLength:RpcExceptionHandlingTest.kt$RpcExceptionHandlingTest$assertThatThrownBy { devModeNode.throwExceptionFromFlow() } - MaxLineLength:RpcExceptionHandlingTest.kt$RpcExceptionHandlingTest$assertThatThrownBy { node.throwExceptionFromFlow() } - MaxLineLength:RpcExceptionHandlingTest.kt$RpcExceptionHandlingTest$assertThatThrownBy { scenario(false) } - MaxLineLength:RpcExceptionHandlingTest.kt$RpcExceptionHandlingTest$assertThatThrownBy { scenario(true) } - MaxLineLength:RpcExceptions.kt$DuplicateAttachmentException : FileAlreadyExistsExceptionClientRelevantError MaxLineLength:RpcExceptions.kt$DuplicateContractClassException$Exception("Contract $contractClassName version '$version' already present in the attachments $attachmentHashes"), ClientRelevantError MaxLineLength:RpcExceptions.kt$InternalNodeException : CordaRuntimeExceptionClientRelevantErrorIdentifiableException - MaxLineLength:RpcExceptions.kt$NonRpcFlowException : IllegalArgumentExceptionClientRelevantError MaxLineLength:RpcExceptions.kt$OutdatedNetworkParameterHashException : CordaRuntimeExceptionClientRelevantError MaxLineLength:RpcExceptions.kt$OutdatedNetworkParameterHashException.Companion$private const val TEMPLATE = "Refused to accept parameters with hash %s because network map advertises update with hash %s. Please check newest version" - MaxLineLength:RpcFlowsDrainingModeTest.kt$RpcFlowsDrainingModeTest$driver - MaxLineLength:RpcHelpers.kt$return Observable.interval(interval, unit).map { isWaitingForShutdown() }.takeFirst { waiting -> waiting == false }.map { Unit } - MaxLineLength:RpcReconnectTests.kt$RpcReconnectTests$assertTrue(missingProgressEvents.isEmpty(), "The flow progress tracker is missing events: $missingProgressEvents") MaxLineLength:RpcReconnectTests.kt$RpcReconnectTests$assertTrue(stateMachineEvents.count { it is StateMachineUpdate.Added } > nrOfFlowsToRun / 2, "Too many Added state machine events lost.") MaxLineLength:RpcReconnectTests.kt$RpcReconnectTests$assertTrue(stateMachineEvents.count { it is StateMachineUpdate.Removed } > nrOfFlowsToRun / 2, "Too many Removed state machine events lost.") MaxLineLength:RpcReconnectTests.kt$RpcReconnectTests$bankAReconnectingRpc .vaultQueryByWithPagingSpec(Cash.State::class.java, QueryCriteria.VaultQueryCriteria(status = Vault.StateStatus.CONSUMED), PageSpecification(1, 10000)) - MaxLineLength:RpcReconnectTests.kt$RpcReconnectTests$driver MaxLineLength:RpcReconnectTests.kt$RpcReconnectTests$fun startBankA() - MaxLineLength:RpcReconnectTests.kt$RpcReconnectTests$log.info("vault update produced ${update.produced.map { it.state.data.amount }} consumed ${update.consumed.map { it.ref }}") MaxLineLength:RpcReconnectTests.kt$RpcReconnectTests$val criteria = QueryCriteria.VaultCustomQueryCriteria(builder { CashSchemaV1.PersistentCashState::pennies.equal(amount.toLong() * 100) }, status = Vault.StateStatus.ALL) - MaxLineLength:RpcReconnectTests.kt$RpcReconnectTests$val stateMachineObserverHandle = bankAReconnectingRpc.stateMachinesFeed().updates.asReconnecting().subscribe { update -> log.info(update.toString()) stateMachineEvents.add(update) } - MaxLineLength:RpcServerObservableSerializer.kt$RpcServerObservableSerializer.<no name provided>$observableContext.clientAddressToObservables - MaxLineLength:RpcServerObservableSerializerTests.kt$RpcServerObservableSerializerTests$val subMap: Cache<Trace.InvocationId, ObservableSubscription> = Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.MINUTES) .maximumSize(100) .build() - MaxLineLength:RpcSslTest.kt$RpcSslTest$val connection = CordaRPCClient(node.rpcAddress, sslConfiguration = clientSslOptions).start(user.username, user.password) - MaxLineLength:RpcSslTest.kt$RpcSslTest$val connection2 = CordaRPCClient(node.rpcAddress, sslConfiguration = clientSslOptions).start(user.username, "wrong") - MaxLineLength:RpcSslTest.kt$RpcSslTest$val node = startNode(rpcUsers = listOf(user), customOverrides = brokerSslOptions.useSslRpcOverrides()).getOrThrow() - MaxLineLength:SSLHelper.kt$// As per Javadoc in: https://docs.oracle.com/javase/8/docs/api/javax/net/ssl/KeyManagerFactory.html `init` method // 2nd parameter `password` - the password for recovering keys in the KeyStore fun KeyManagerFactory.init(keyStore: CertificateStore) - MaxLineLength:SSLHelper.kt$LoggingTrustManagerWrapper$AuthorityKeyIdentifier.getInstance(bcCert.getExtension(Extension.authorityKeyIdentifier).parsedValue).keyIdentifier.toHex() - MaxLineLength:SSLHelper.kt$LoggingTrustManagerWrapper$SubjectKeyIdentifier.getInstance(bcCert.getExtension(Extension.subjectKeyIdentifier).parsedValue).keyIdentifier.toHex() - MaxLineLength:SSLHelper.kt$internal - MaxLineLength:SSLHelper.kt$private const val DEFAULT_SSL_TIMEOUT = 20000 // Aligned with sun.security.provider.certpath.URICertStore.DEFAULT_CRL_CONNECT_TIMEOUT - MaxLineLength:SSLHelper.kt$sslHandler.handshakeTimeoutMillis = Integer.getInteger(SSL_HANDSHAKE_TIMEOUT_PROP_NAME, DEFAULT_SSL_TIMEOUT).toLong() MaxLineLength:SSLHelper.kt$val trustManagers = trustManagerFactory.trustManagers.filterIsInstance(X509ExtendedTrustManager::class.java).map { LoggingTrustManagerWrapper(it) }.toTypedArray() - MaxLineLength:SSLHelper.kt${ val secureHash = SecureHash.sha256(x500Name.toString()) // RFC 1035 specifies a limit 255 bytes for hostnames with each label being 63 bytes or less. Due to this, the string // representation of the SHA256 hash is truncated to 32 characters. return String.format(HOSTNAME_FORMAT, secureHash.toString().take(32).toLowerCase()) } - MaxLineLength:SSLHelperTest.kt$SSLHelperTest$assertEquals("$legalNameHash.corda.net", (sslHandler.engine().sslParameters.serverNames.first() as SNIHostName).asciiName) - MaxLineLength:SSLHelperTest.kt$SSLHelperTest$keyManagerFactory.init(CertificateStore.fromFile(keyStore.path, keyStore.storePassword, keyStore.entryPassword, false)) MaxLineLength:SSLHelperTest.kt$SSLHelperTest$trustManagerFactory.init(initialiseTrustStoreAndEnableCrlChecking(CertificateStore.fromFile(trustStore.path, trustStore.storePassword, trustStore.entryPassword, false), false)) MaxLineLength:SSLHelperTest.kt$SSLHelperTest$val sslHandler = createClientSslHelper(NetworkHostAndPort("localhost", 1234), setOf(legalName), keyManagerFactory, trustManagerFactory) MaxLineLength:SampleCashSchemaV1.kt$SampleCashSchemaV1 : MappedSchema MaxLineLength:SampleCashSchemaV1.kt$SampleCashSchemaV1.PersistentCashState$@Table(name = "contract_cash_states_v1", indexes = [Index(name = "ccy_code_idx1", columnList = "ccy_code"), Index(name = "pennies_idx1", columnList = "pennies")]) MaxLineLength:SampleCashSchemaV2.kt$SampleCashSchemaV2.PersistentCashState$@CollectionTable(name = "cash_states_v2_participants", joinColumns = [JoinColumn(name = "output_index", referencedColumnName = "output_index"), JoinColumn(name = "transaction_id", referencedColumnName = "transaction_id")]) - MaxLineLength:SandboxClassLoader.kt$SandboxClassLoader$if (throwableClass.isAssignableFrom(clazz.type) && !analysisConfiguration.isJvmException(source.internalClassName)) { logger.debug("Generating synthetic throwable for ${source.qualifiedClassName}") loadWrapperFor(clazz.type) } - MaxLineLength:SandboxClassLoadingException.kt$SandboxClassLoadingException : RuntimeException - MaxLineLength:SandboxClassRemapper.kt$SandboxClassRemapper.MethodRemapperWithPinning$override - MaxLineLength:SandboxClassRemapper.kt$SandboxClassRemapper.MethodRemapperWithPinning$return if (configuration.isPinnedClass(element.owner) || configuration.isTemplateClass(element.owner) || isUnmapped(element)) { nonmapper } else { mv } - MaxLineLength:SandboxExecutor.kt$SandboxExecutor${ // 1. We first do a breath first traversal of the class hierarchy, starting from the requested class. // The branching is defined by class references from referencesFromLocation. // 2. For each class we run validation against defined rules. // 3. Since this is hitting the class loader, we are also remapping and rewriting the classes using the provided // emitters and definition providers. // 4. While traversing and validating, we build up another queue of references inside the reference validator. // 5. We drain this queue by validating class references and member references; this means validating the // existence of these referenced classes and members, and making sure that rule validation has been run on // all reachable code. // 6. For execution, we then load the top-level class, implementing the SandboxedRunnable interface, again and // and consequently hit the cache. Once loaded, we can execute the code on the spawned thread, i.e., in an // isolated environment. logger.debug("Executing {} with input {}...", runnableClass, input) // TODO Class sources can be analyzed in parallel, although this require making the analysis context thread-safe // To do so, one could start by batching the first X classes from the class sources and analyse each one in // parallel, caching any intermediate state and subsequently process enqueued sources in parallel batches as well. // Note that this would require some rework of the [IsolatedTask] and the class loader to bypass the limitation // of caching and state preserved in thread-local contexts. val classSources = listOf(runnableClass) val context = AnalysisContext.fromConfiguration(configuration.analysisConfiguration) val result = IsolatedTask(runnableClass.qualifiedClassName, configuration).run { validate(context, classLoader, classSources) // Load the "entry-point" task class into the sandbox. This task will marshall // the input and outputs between Java types and sandbox wrapper types. val taskClass = classLoader.loadClass("sandbox.Task") // Create the user's task object inside the sandbox. val runnable = classLoader.loadClassForSandbox(runnableClass).newInstance() // Fetch this sandbox's instance of Class<Function> so we can retrieve Task(Function) // and then instantiate the Task. val functionClass = classLoader.loadClass("sandbox.java.util.function.Function") val task = taskClass.getDeclaredConstructor(functionClass).newInstance(runnable) // Execute the task... val method = taskClass.getMethod("apply", Any::class.java) try { @Suppress("UNCHECKED_CAST") method.invoke(task, input) as? TOutput } catch (ex: InvocationTargetException) { throw ex.targetException } } logger.trace("Execution of {} with input {} resulted in {}", runnableClass, input, result) when (result.exception) { null -> return ExecutionSummaryWithResult(result.output, result.costs) else -> throw SandboxException( Message.getMessageFromException(result.exception), result.identifier, runnableClass, ExecutionSummary(result.costs), result.exception ) } } MaxLineLength:SandboxExecutorTest.kt$SandboxExecutorTest$assertThat(result) .isEqualTo("SANDBOX: Boolean=true, Char='X', Integer=1234, Long=99999, Short=3200, Byte=101, String='Hello Sandbox!', Float=123.456, Double=987.6543") MaxLineLength:ScheduledActivityObserver.kt$ScheduledActivityObserver - MaxLineLength:ScheduledActivityObserver.kt$ScheduledActivityObserver$val scheduledAt = sandbox { producedState.nextScheduledActivity(produced.ref, FlowLogicRefFactory)?.scheduledAt } ?: return - MaxLineLength:ScheduledActivityObserver.kt$ScheduledActivityObserver.Companion$@JvmStatic fun install(vaultService: VaultService, schedulerService: SchedulerService, flowLogicRefFactory: FlowLogicRefFactory) - MaxLineLength:ScheduledActivityObserver.kt$ScheduledActivityObserver.Companion$consumed.forEach { if (it.state.data is SchedulableState) schedulerService.unscheduleStateActivity(it.ref) } - MaxLineLength:ScheduledFlowIntegrationTests.kt$ScheduledFlowIntegrationTests$cordappsForAllNodes = listOf(DUMMY_CONTRACTS_CORDAPP, cordappWithPackages("net.corda.testMessage"), enclosedCordapp()) MaxLineLength:ScheduledFlowIntegrationTests.kt$ScheduledFlowIntegrationTests$val (alice, bob) = listOf(ALICE_NAME, BOB_NAME).map { startNode(providedName = it, rpcUsers = listOf(rpcUser)) }.transpose().getOrThrow() MaxLineLength:ScheduledFlowIntegrationTests.kt$ScheduledFlowIntegrationTests$val N = 23 val rpcUser = User("admin", "admin", setOf("ALL")) val (alice, bob) = listOf(ALICE_NAME, BOB_NAME).map { startNode(providedName = it, rpcUsers = listOf(rpcUser)) }.transpose().getOrThrow() val aliceClient = CordaRPCClient(alice.rpcAddress).start(rpcUser.username, rpcUser.password) val bobClient = CordaRPCClient(bob.rpcAddress).start(rpcUser.username, rpcUser.password) val scheduledFor = Instant.now().plusSeconds(10) val initialiseFutures = mutableListOf<CordaFuture<*>>() for (i in 0 until N) { initialiseFutures.add(aliceClient.proxy.startFlow( ::InsertInitialStateFlow, bob.nodeInfo.legalIdentities.first(), defaultNotaryIdentity, i, scheduledFor ).returnValue) initialiseFutures.add(bobClient.proxy.startFlow( ::InsertInitialStateFlow, alice.nodeInfo.legalIdentities.first(), defaultNotaryIdentity, i + 100, scheduledFor ).returnValue) } initialiseFutures.getOrThrowAll() val spendAttemptFutures = mutableListOf<CordaFuture<*>>() for (i in (0 until N).reversed()) { spendAttemptFutures.add(aliceClient.proxy.startFlow(::AnotherFlow, (i).toString()).returnValue) spendAttemptFutures.add(bobClient.proxy.startFlow(::AnotherFlow, (i + 100).toString()).returnValue) } spendAttemptFutures.getOrThrowAll() // TODO: the queries below are not atomic so we need to allow enough time for the scheduler to finish. Would be better to query scheduler. Thread.sleep(20.seconds.toMillis()) val aliceStates = aliceClient.proxy.vaultQuery(ScheduledState::class.java).states.filter { it.state.data.processed } val aliceSpentStates = aliceClient.proxy.vaultQuery(SpentState::class.java).states val bobStates = bobClient.proxy.vaultQuery(ScheduledState::class.java).states.filter { it.state.data.processed } val bobSpentStates = bobClient.proxy.vaultQuery(SpentState::class.java).states assertEquals(aliceStates.count() + aliceSpentStates.count(), N * 2) assertEquals(bobStates.count() + bobSpentStates.count(), N * 2) assertEquals(aliceSpentStates.count(), bobSpentStates.count()) - MaxLineLength:ScheduledFlowIntegrationTests.kt$ScheduledFlowIntegrationTests$val aliceStates = aliceClient.proxy.vaultQuery(ScheduledState::class.java).states.filter { it.state.data.processed } - MaxLineLength:ScheduledFlowIntegrationTests.kt$ScheduledFlowIntegrationTests$val bobStates = bobClient.proxy.vaultQuery(ScheduledState::class.java).states.filter { it.state.data.processed } MaxLineLength:ScheduledFlowIntegrationTests.kt$ScheduledFlowIntegrationTests.AnotherFlow$val results = serviceHub.vaultService.queryBy<ScheduledState>(QueryCriteria.LinearStateQueryCriteria(externalId = ImmutableList.of(identity))) - MaxLineLength:ScheduledFlowTests.kt$ScheduledFlowTests$mockNet = InternalMockNetwork(cordappsForAllNodes = listOf(DUMMY_CONTRACTS_CORDAPP, enclosedCordapp()), threadPerNode = true) - MaxLineLength:ScheduledFlowTests.kt$ScheduledFlowTests.Companion$val SORTING = Sort(listOf(Sort.SortColumn(SortAttribute.Standard(Sort.CommonStateAttribute.STATE_REF_TXN_ID), Sort.Direction.DESC))) - MaxLineLength:ScheduledFlowTests.kt$ScheduledFlowTests.ScheduledState$override - MaxLineLength:ScheduledFlowTests.kt$ScheduledFlowTests.ScheduledState$override val linearId: UniqueIdentifier = UniqueIdentifier() - MaxLineLength:ScheduledFlowsDrainingModeTest.kt$ScheduledFlowsDrainingModeTest.ScheduledState$override - MaxLineLength:ScheduledFlowsDrainingModeTest.kt$ScheduledFlowsDrainingModeTest.ScheduledState$override val linearId: UniqueIdentifier = UniqueIdentifier() - MaxLineLength:ScheduledState.kt$ScheduledState$override MaxLineLength:ScheduledState.kt$ScheduledState$override val linearId: UniqueIdentifier = UniqueIdentifier(externalId = identity) - MaxLineLength:Schema.kt$ClassSchema$superclass: Schema? = null MaxLineLength:Schema.kt$CompositeType.Companion$return CompositeType(list[0] as String, list[1] as? String, uncheckedCast(list[2]), list[3] as Descriptor, uncheckedCast(list[4])) - MaxLineLength:Schema.kt$CompositeType.Companion$return newInstance(listOf(list[0], list[1], list[2], Descriptor.get(list[3]!!), (list[4] as List<*>).map { Field.get(it!!) })) MaxLineLength:Schema.kt$Field.Companion$return Field(list[0] as String, list[1] as String, uncheckedCast(list[2]), list[3] as? String, list[4] as? String, list[5] as Boolean, list[6] as Boolean) MaxLineLength:Schema.kt$RestrictedType.Companion$return RestrictedType(list[0] as String, list[1] as? String, uncheckedCast(list[2]), list[3] as String, list[4] as Descriptor, uncheckedCast(list[5])) MaxLineLength:Schema.kt$RestrictedType.Companion$return newInstance(listOf(list[0], list[1], list[2], list[3], Descriptor.get(list[4]!!), (list[5] as List<*>).map { Choice.get(it!!) })) MaxLineLength:Schema.kt$Schema$internal MaxLineLength:Schema.kt$Schema$return properties.asSequence().map { it.key to it.describe(configuration, serialiseValue) }.filter { it.second != null }.fold(configObject()) { config, (key, value) -> config.withValue(key, value) } - MaxLineLength:Schema.kt$Schema$throw IllegalArgumentException("More than one property was found for keys ${invalid.keys.joinToString(", ", "[", "]")}.") MaxLineLength:Schema.kt$Schema$val invalid = properties.groupBy(Configuration.Property.Definition<*>::key).mapValues { entry -> entry.value.size }.filterValues { propertiesForKey -> propertiesForKey > 1 } MaxLineLength:Schema.kt$Schema$val nestedProperties = (properties + properties.flatMap { it.schema?.properties ?: emptySet() }).asSequence().distinctBy(Configuration.Property.Definition<*>::schema) MaxLineLength:Schema.kt$Schema$val root = properties.asSequence().map { it.key to ConfigValueFactory.fromAnyRef(it.typeName) }.fold(configObject()) { config, (key, value) -> config.withValue(key, value) } - MaxLineLength:SchemaMigration.kt$CheckpointsException : DatabaseMigrationException - MaxLineLength:SchemaMigration.kt$CheckpointsException$"This is dangerous because the node might not be able to restore the flows correctly and could consequently fail. " MaxLineLength:SchemaMigration.kt$DatabaseIncompatibleException : DatabaseMigrationException MaxLineLength:SchemaMigration.kt$DatabaseIncompatibleException.Companion$fun errorMessageFor(reason: String): String MaxLineLength:SchemaMigration.kt$MissingMigrationException : DatabaseMigrationException MaxLineLength:SchemaMigration.kt$MissingMigrationException.Companion$fun errorMessageFor(mappedSchema: MappedSchema): String MaxLineLength:SchemaMigration.kt$OutstandingDatabaseChangesException : DatabaseMigrationException - MaxLineLength:SchemaMigration.kt$SchemaMigration MaxLineLength:SchemaMigration.kt$SchemaMigration$ private fun migrateOlderDatabaseToUseLiquibase(existingCheckpoints: Boolean): Boolean MaxLineLength:SchemaMigration.kt$SchemaMigration$(mappedSchema::class.qualifiedName == "net.corda.finance.schemas.CashSchemaV1" || mappedSchema::class.qualifiedName == "net.corda.finance.schemas.CommercialPaperSchemaV1") && mappedSchema.migrationResource == null -> null MaxLineLength:SchemaMigration.kt$SchemaMigration$(run && !check) && (unRunChanges.isNotEmpty() && existingCheckpoints!!) -> throw CheckpointsException() MaxLineLength:SchemaMigration.kt$SchemaMigration$// Collect all changelog file referenced in the included schemas. // For backward compatibility reasons, when failOnMigrationMissing=false, we don't manage CorDapps via Liquibase but use the hibernate hbm2ddl=update. val changelogList = schemas.mapNotNull { mappedSchema -> val resource = getMigrationResource(mappedSchema, classLoader) when { resource != null -> resource // Corda OS FinanceApp in v3 has no Liquibase script, so no error is raised (mappedSchema::class.qualifiedName == "net.corda.finance.schemas.CashSchemaV1" || mappedSchema::class.qualifiedName == "net.corda.finance.schemas.CommercialPaperSchemaV1") && mappedSchema.migrationResource == null -> null else -> throw MissingMigrationException(mappedSchema) } } val path = currentDirectory?.toString() if (path != null) { System.setProperty(NODE_BASE_DIR_KEY, path) // base dir for any custom change set which may need to load a file (currently AttachmentVersionNumberMigration) } System.setProperty(NODE_X500_NAME, ourName.toString()) val customResourceAccessor = CustomResourceAccessor(dynamicInclude, changelogList, classLoader) checkResourcesInClassPath(changelogList) // current version of Liquibase appears to be non-threadsafe // this is apparent when multiple in-process nodes are all running migrations simultaneously mutex.withLock { val liquibase = Liquibase(dynamicInclude, customResourceAccessor, getLiquibaseDatabase(JdbcConnection(connection))) val unRunChanges = liquibase.listUnrunChangeSets(Contexts(), LabelExpression()) when { (run && !check) && (unRunChanges.isNotEmpty() && existingCheckpoints!!) -> throw CheckpointsException() // Do not allow database migration when there are checkpoints run && !check -> liquibase.update(Contexts()) check && !run && unRunChanges.isNotEmpty() -> throw OutstandingDatabaseChangesException(unRunChanges.size) check && !run -> { } // Do nothing will be interpreted as "check succeeded" else -> throw IllegalStateException("Invalid usage.") } } MaxLineLength:SchemaMigration.kt$SchemaMigration$System.setProperty(NODE_BASE_DIR_KEY, path) - MaxLineLength:SchemaMigration.kt$SchemaMigration$check && !run && unRunChanges.isNotEmpty() -> throw OutstandingDatabaseChangesException(unRunChanges.size) MaxLineLength:SchemaMigration.kt$SchemaMigration$it.execute("SELECT COUNT(*) FROM DATABASECHANGELOG WHERE FILENAME IN ('migration/cash.changelog-init.xml','migration/commercial-paper.changelog-init.xml')") MaxLineLength:SchemaMigration.kt$SchemaMigration$private MaxLineLength:SchemaMigration.kt$SchemaMigration$throw DatabaseMigrationException("Could not find Liquibase database migration script $resource. Please ensure the jar file containing it is deployed in the cordapps directory.") - MaxLineLength:SchemaMigration.kt$SchemaMigration$val dynamicInclude = "master.changelog.json" // Virtual file name of the changelog that includes all schemas. MaxLineLength:SchemaMigration.kt$SchemaMigration$val isFinanceAppWithLiquibaseNotMigrated = isFinanceAppWithLiquibase // If Finance App is pre v4.0 then no need to migrate it so no need to check. && existingDatabase && (!hasLiquibase // Migrate as other tables. || (hasLiquibase && it.createStatement().use { noLiquibaseEntryLogForFinanceApp(it) })) // If Liquibase is already in the database check if Finance App schema log is missing. - MaxLineLength:SchemaMigration.kt$SchemaMigration$val liquibase = Liquibase(dynamicInclude, customResourceAccessor, getLiquibaseDatabase(JdbcConnection(connection))) MaxLineLength:SchemaMigration.kt$SchemaMigration$|| MaxLineLength:SchemaMigration.kt$SchemaMigration.CustomResourceAccessor$private MaxLineLength:SchemaMigration.kt$SchemaMigration.CustomResourceAccessor$val includeAllFiles = mapOf("databaseChangeLog" to changelogList.filter { it != null }.map { file -> mapOf("include" to mapOf("file" to file)) }) - MaxLineLength:SchemaTest.kt$SchemaTest$assertThat(descriptionObj.getAnyRef("prop3.prop5")).isEqualTo(Configuration.Property.Definition.SENSITIVE_DATA_PLACEHOLDER) - MaxLineLength:SchemaTest.kt$SchemaTest$assertThat(obj.toConfig().getString("prop5")).isEqualTo(Configuration.Property.Definition.SENSITIVE_DATA_PLACEHOLDER) MaxLineLength:SchemaTest.kt$SchemaTest$val barConfigSchema = Configuration.Schema.withProperties { setOf(string(prop1), long(prop2), nestedObject("prop3", fooConfigSchema)) } MaxLineLength:SchemaTest.kt$SchemaTest$val barConfigSchema = Configuration.Schema.withProperties(name = "Bar") { setOf(string(prop1), long(prop2), nestedObject("prop3", fooConfigSchema)) } MaxLineLength:SchemaTest.kt$SchemaTest$val barConfigSchema = Configuration.Schema.withProperties(name = "Bar") { setOf(string(prop1), long(prop2), nestedObject("prop3", fooConfigSchema).list()) } - MaxLineLength:SchemaTest.kt$SchemaTest$val configuration = configObject(prop1 to prop1Value, prop2 to prop2Value, prop3 to prop3Value, "prop4" to "value4").toConfig() - MaxLineLength:SchemaTest.kt$SchemaTest$val fooConfigSchema = Configuration.Schema.withProperties(name = "Foo") { setOf(boolean("prop4"), double("prop5")) } MaxLineLength:SchemaTest.kt$SchemaTest$val fooConfigSchema = Configuration.Schema.withProperties(name = "Foo") { setOf(boolean("prop4"), string("prop5", sensitive = true)) } MaxLineLength:SchemaTest.kt$SchemaTest$val prop3Value = ConfigValueFactory.fromIterable(listOf(configObject(prop4 to prop4Value, prop5 to prop5Value), configObject(prop4 to prop4Value, prop5 to prop5Value))) - MaxLineLength:SchemaTest.kt$SchemaTest$val strictErrors = barConfigSchema.validate(configuration, Configuration.Validation.Options(strict = true)).errors - MaxLineLength:SearchField.kt$SearchField<T> : UIComponent - MaxLineLength:SecureArtemisConfiguration.kt$SecureArtemisConfiguration${ // Artemis allows multiple servers to be grouped together into a cluster for load balancing purposes. The cluster // user is used for connecting the nodes together. It has super-user privileges and so it's imperative that its // password be changed from the default (as warned in the docs). Since we don't need this feature we turn it off // by having its password be an unknown securely random 128-bit value. clusterPassword = BigInteger(128, newSecureRandom()).toString(16) } MaxLineLength:SecureHash.kt$SecureHash.Companion$ @JvmStatic fun parse(str: String?): SHA256 - MaxLineLength:SecureHash.kt$SecureHash.Companion$else -> throw IllegalArgumentException("Provided string is ${it.size} bytes not 32 bytes in hex: $str") MaxLineLength:SelfIssueTest.kt$diffString += "${node.propertyPath}: simulated[${node.canonicalGet(previousState.vaultsSelfIssued)}], actual[${node.canonicalGet(selfIssueVaults)}]\n" MaxLineLength:SellerFlow.kt$SellerFlow$serviceHub.vaultService.queryBy(CommercialPaper.State::class.java) .states - MaxLineLength:SellerFlow.kt$SellerFlow.Companion$SELF_ISSUING : Step MaxLineLength:SendTransactionFlow.kt$DataVendingFlow$@Suspendable protected open - MaxLineLength:SendTransactionFlow.kt$DataVendingFlow$getInputTransactions(serviceHub.validatedTransactions.getTransaction(stateAndRef.ref.txhash)!!) + stateAndRef.ref.txhash - MaxLineLength:SendTransactionFlow.kt$DataVendingFlow$is NotarisationPayload -> TransactionAuthorisationFilter().addAuthorised(getInputTransactions(payload.signedTransaction)) MaxLineLength:SendTransactionFlow.kt$DataVendingFlow${ // The first payload will be the transaction data, subsequent payload will be the transaction/attachment/network parameters data. var payload = payload // Depending on who called this flow, the type of the initial payload is different. // The authorisation logic is to maintain a dynamic list of transactions that the caller is authorised to make based on the transactions that were made already. // Each time an authorised transaction is requested, the input transactions are added to the list. // Once a transaction has been requested, it will be removed from the authorised list. This means that it is a protocol violation to request a transaction twice. val authorisedTransactions = when (payload) { is NotarisationPayload -> TransactionAuthorisationFilter().addAuthorised(getInputTransactions(payload.signedTransaction)) is SignedTransaction -> TransactionAuthorisationFilter().addAuthorised(getInputTransactions(payload)) is RetrieveAnyTransactionPayload -> TransactionAuthorisationFilter(acceptAll = true) is List<*> -> TransactionAuthorisationFilter().addAuthorised(payload.flatMap { stateAndRef -> if (stateAndRef is StateAndRef<*>) { getInputTransactions(serviceHub.validatedTransactions.getTransaction(stateAndRef.ref.txhash)!!) + stateAndRef.ref.txhash } else { throw Exception("Unknown payload type: ${stateAndRef!!::class.java} ?") } }.toSet()) else -> throw Exception("Unknown payload type: ${payload::class.java} ?") } // This loop will receive [FetchDataFlow.Request] continuously until the `otherSideSession` has all the data they need // to resolve the transaction, a [FetchDataFlow.EndRequest] will be sent from the `otherSideSession` to indicate end of // data request. while (true) { val dataRequest = sendPayloadAndReceiveDataRequest(otherSideSession, payload).unwrap { request -> when (request) { is FetchDataFlow.Request.Data -> { // Security TODO: Check for abnormally large or malformed data requests verifyDataRequest(request) request } FetchDataFlow.Request.End -> return null } } payload = when (dataRequest.dataType) { FetchDataFlow.DataType.TRANSACTION -> dataRequest.hashes.map { txId -> if (!authorisedTransactions.isAuthorised(txId)) { throw FetchDataFlow.IllegalTransactionRequest(txId) } val tx = serviceHub.validatedTransactions.getTransaction(txId) ?: throw FetchDataFlow.HashNotFound(txId) authorisedTransactions.removeAuthorised(tx.id) authorisedTransactions.addAuthorised(getInputTransactions(tx)) tx } FetchDataFlow.DataType.ATTACHMENT -> dataRequest.hashes.map { serviceHub.attachments.openAttachment(it)?.open()?.readFully() ?: throw FetchDataFlow.HashNotFound(it) } FetchDataFlow.DataType.PARAMETERS -> dataRequest.hashes.map { (serviceHub.networkParametersService as NetworkParametersStorage).lookupSigned(it) ?: throw FetchDataFlow.MissingNetworkParameters(it) } } } } MaxLineLength:SendTransactionFlow.kt$DataVendingFlow.TransactionAuthorisationFilter$private - MaxLineLength:SendTransactionFlow.kt$SendStateAndRefFlow : DataVendingFlow MaxLineLength:SendTransactionFlow.kt$SendStateAndRefFlow$open - MaxLineLength:SendTransactionFlow.kt$SendTransactionFlow : DataVendingFlow MaxLineLength:SerDeserCarpentryTest.kt$SerDeserCarpentryTest$val data = readTestResource().deserialize<AInterface>(context = SerializationFactory.defaultFactory.defaultContext.withLenientCarpenter()) - MaxLineLength:SerializationAPI.kt$@DeleteForDJVM inline - MaxLineLength:SerializationAPI.kt$SerializationContext$ fun withPreferredSerializationVersion(magic: SerializationMagic): SerializationContext - MaxLineLength:SerializationAPI.kt$SerializationContext$/** * A whitelist that determines (mostly for security purposes) whether a particular encoding may be used when deserializing. */ val encodingWhitelist: EncodingWhitelist - MaxLineLength:SerializationAPI.kt$SerializationContext$/** * If true the carpenter will happily synthesis classes that implement interfaces containing methods that are not * getters for any AMQP fields. Invoking these methods will throw an [AbstractMethodError]. If false then an exception * will be thrown during deserialization instead. * * The default is false. */ val lenientCarpenterEnabled: Boolean - MaxLineLength:SerializationAPI.kt$SerializationContext$/** * If true the serialization evolver will fail if the binary to be deserialized contains more fields then the current object from * the classpath. * * The default is false. */ val preventDataLoss: Boolean - MaxLineLength:SerializationAPI.kt$SerializationFactory$ abstract fun <T : Any> serialize(obj: T, context: SerializationContext): SerializedBytes<T> - MaxLineLength:SerializationAPI.kt$SerializationFactory$ fun <T> asCurrent(block: SerializationFactory.() -> T): T - MaxLineLength:SerializationAPI.kt$SerializationFactory$/** * A context to use as a default if you do not require a specially configured context. It will be the current context * if the use is somehow nested (see [currentContext]). */ val defaultContext: SerializationContext get() = currentContext ?: effectiveSerializationEnv.p2pContext - MaxLineLength:SerializationAPI.kt$SerializationFactory$/** * If there is a need to nest serialization/deserialization with a modified context during serialization or deserialization, * this will return the current context used to start serialization/deserialization. */ val currentContext: SerializationContext? get() = _currentContext.get() MaxLineLength:SerializationAPI.kt$SerializationFactory$abstract - MaxLineLength:SerializationAPI.kt$SerializationFactory.Companion$/** * A default factory for serialization/deserialization, taking into account the [currentFactory] if set. */ val defaultFactory: SerializationFactory get() = currentFactory ?: effectiveSerializationEnv.serializationFactory - MaxLineLength:SerializationAPI.kt$SerializationFactory.Companion$/** * If there is a need to nest serialization/deserialization with a modified context during serialization or deserialization, * this will return the current factory used to start serialization/deserialization. */ val currentFactory: SerializationFactory? get() = _currentFactory.get() MaxLineLength:SerializationAPI.kt$context: SerializationContext = serializationFactory.defaultContext MaxLineLength:SerializationAPI.kt$inline - MaxLineLength:SerializationAnnotations.kt$CordaSerializable - MaxLineLength:SerializationCompatibilityTests.kt$SerializationCompatibilityTests$assertThat(factory.get(Exception::class.java).typeDescriptor.toString()).isEqualTo("net.corda:ApZ2a/36VVskaoDZMbiZ8A==") MaxLineLength:SerializationEnvironment.kt$"Expected exactly 1 of {${serializationEnvFields.joinToString(", ") { it.name }}} but got: {${it.joinToString(", ") { it.first }}}" - MaxLineLength:SerializationEnvironment.kt$(e.className == "java.util.concurrent.ForkJoinPool\$DefaultForkJoinWorkerThreadFactory" && e.methodName == "newThread") MaxLineLength:SerializationEnvironment.kt$private val serializationEnvFields = listOf(_nodeSerializationEnv, _driverSerializationEnv, _contextSerializationEnv, _inheritableContextSerializationEnv) MaxLineLength:SerializationEnvironment.kt$val _inheritableContextSerializationEnv = InheritableThreadLocalToggleField<SerializationEnvironment>("inheritableContextSerializationEnv") { stack -> stack.fold(false) { isAGlobalThreadBeingCreated, e -> isAGlobalThreadBeingCreated || (e.className == "io.netty.util.concurrent.GlobalEventExecutor" && e.methodName == "startThread") || (e.className == "java.util.concurrent.ForkJoinPool\$DefaultForkJoinWorkerThreadFactory" && e.methodName == "newThread") } } - MaxLineLength:SerializationEnvironmentRule.kt$SerializationEnvironmentRule.Companion$Executors.newCachedThreadPool(testThreadFactory(true)) // Close enough to what InVMConnector makes normally. - MaxLineLength:SerializationEnvironmentRule.kt$SerializationEnvironmentRule.Companion$InVMConnector::class.staticField<ExecutorService>("threadPoolExecutor").value - MaxLineLength:SerializationFactory.kt$SerializationFactory$ abstract fun <T : Any> serialize(obj: T, context: SerializationContext): SerializedBytes<T> - MaxLineLength:SerializationFactory.kt$SerializationFactory$ fun <T> asCurrent(block: SerializationFactory.() -> T): T - MaxLineLength:SerializationFactory.kt$SerializationFactory$/** * A context to use as a default if you do not require a specially configured context. It will be the current context * if the use is somehow nested (see [currentContext]). */ val defaultContext: SerializationContext get() = currentContext ?: effectiveSerializationEnv.p2pContext - MaxLineLength:SerializationFactory.kt$SerializationFactory$/** * If there is a need to nest serialization/deserialization with a modified context during serialization or deserialization, * this will return the current context used to start serialization/deserialization. */ val currentContext: SerializationContext? get() = _currentContext MaxLineLength:SerializationFactory.kt$SerializationFactory$abstract - MaxLineLength:SerializationFactory.kt$SerializationFactory.Companion$/** * A default factory for serialization/deserialization, taking into account the [currentFactory] if set. */ val defaultFactory: SerializationFactory get() = currentFactory ?: effectiveSerializationEnv.serializationFactory - MaxLineLength:SerializationFactory.kt$SerializationFactory.Companion$/** * If there is a need to nest serialization/deserialization with a modified context during serialization or deserialization, * this will return the current factory used to start serialization/deserialization. */ val currentFactory: SerializationFactory? get() = _currentFactory - MaxLineLength:SerializationFormat.kt$FlushAverseOutputStream : OutputStream - MaxLineLength:SerializationFormat.kt$SectionId$DATA_AND_STOP - MaxLineLength:SerializationFormat.kt$SectionId$ENCODING - MaxLineLength:SerializationHelper.kt$CommonPropertyNames - MaxLineLength:SerializationOutput.kt$SerializationOutput$ @Throws(NotSerializableException::class) fun <T : Any> serialize(obj: T, context: SerializationContext): SerializedBytes<T> - MaxLineLength:SerializationOutput.kt$SerializationOutput$writeObject(obj, data, if (type == TypeIdentifier.UnknownType.getLocalType()) obj.javaClass else type, context, debugIndent) - MaxLineLength:SerializationOutput.kt$SerializationOutput${ serializer.writeObject(obj, data, type, this, context, debugIndent) // Important to do it after serialization such that dependent object will have preceding reference numbers // assigned to them first as they will be first read from the stream on receiving end. // Skip for primitive types as they are too small and overhead of referencing them will be much higher than their content if (suitableForObjectReference(obj.javaClass)) { objectHistory[obj] = objectHistory.size } } MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$assertArrayEquals(data, DeserializationInput(factory).deserialize(compressed, testSerializationContext.withEncodingWhitelist(encodingWhitelist))) MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$assertThat(des.deserialize(OpaqueBytes(copy), NonZeroByte::class.java, testSerializationContext.withEncodingWhitelist(encodingWhitelist)).value).isEqualTo(3) - MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$catchThrowable { input.deserialize(compressed, testSerializationContext.withEncodingWhitelist(encodingWhitelist)) } - MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$des.deserialize(OpaqueBytes(copy), NonZeroByte::class.java, testSerializationContext.withEncodingWhitelist(encodingWhitelist)) MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$private MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$return SerializationFactory.defaultFactory.asCurrent { withCurrentContext(newContext) { serdes(t, factory, factory2, expectedEqual) } } - MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$t.suppressed.zip(desThrowable.suppressed).forEach { (before, after) -> assertSerializedThrowableEquivalent(before, after) } MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$val crlHolder = builder.build(ContentSignerBuilder.build(Crypto.RSA_SHA256, Crypto.generateKeyPair(Crypto.RSA_SHA256).private, provider)) - MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$val desObj2 = des2.deserialize(ser2.serialize(obj, compression), testSerializationContext.withEncodingWhitelist(encodingWhitelist)) - MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$val newContext = SerializationFactory.defaultFactory.defaultContext.withProperty(CommonPropertyNames.IncludeInternalInfo, true) - MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests$val obj = WrapFooListArray(arrayOf(listOf(Foo("Fred", 1), Foo("Ginger", 2)), listOf(Foo("Rogers", 3), Foo("Hammerstein", 4)))) - MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests${ val ser = SerializationOutput(SerializerFactoryBuilder.build(AllWhitelist, ClassCarpenterImpl(AllWhitelist, ClassLoader.getSystemClassLoader()) )) val obj = ByteArray(20000) val uncompressedSize = ser.serialize(obj).bytes.size val compressedSize = ser.serialize(obj, CordaSerializationEncoding.SNAPPY).bytes.size // Ordinarily this might be considered high maintenance, but we promised wire compatibility, so they'd better not change! assertEquals(20059, uncompressedSize) assertEquals(1018, compressedSize) } MaxLineLength:SerializationOutputTests.kt$SerializationOutputTests.GenericSubclass$override fun equals(other: Any?): Boolean - MaxLineLength:SerializationScheme.kt$SerializationContextImpl$@KeepForDJVM data - MaxLineLength:SerializationScheme.kt$SerializationContextImpl$override - MaxLineLength:SerializationScheme.kt$SerializationContextImpl$override fun withEncodingWhitelist(encodingWhitelist: EncodingWhitelist) - MaxLineLength:SerializationScheme.kt$SerializationContextImpl$override fun withPreferredSerializationVersion(magic: SerializationMagic) MaxLineLength:SerializationScheme.kt$SerializationContextImpl$override val customSerializers: Set<SerializationCustomSerializer<*, *>> = emptySet() - MaxLineLength:SerializationScheme.kt$SerializationContextImpl$override val encodingWhitelist: EncodingWhitelist = NullEncodingWhitelist MaxLineLength:SerializationScheme.kt$SerializationFactoryImpl$@Throws(NotSerializableException::class) override MaxLineLength:SerializationScheme.kt$SerializationFactoryImpl$private - MaxLineLength:SerializationScheme.kt$SerializationFactoryImpl$private val registeredSchemes: MutableCollection<SerializationScheme> = Collections.synchronizedCollection(mutableListOf()) - MaxLineLength:SerializationScheme.kt$SerializationFactoryImpl$private val schemes: MutableMap<Pair<CordaSerializationMagic, SerializationContext.UseCase>, SerializationScheme> - MaxLineLength:SerializationScheme.kt$SerializationFactoryImpl$registeredSchemes.filter { it.canDeserializeVersion(magic, target) }.forEach { return@computeIfAbsent it } MaxLineLength:SerializationScheme.kt$SerializationFactoryImpl$return asCurrent { withCurrentContext(context) { schemeFor(byteSequence, context.useCase).first.deserialize(byteSequence, clazz, context) } } MaxLineLength:SerializationScheme.kt$SerializationFactoryImpl$return asCurrent { withCurrentContext(context) { schemeFor(context.preferredSerializationVersion, context.useCase).first.serialize(obj, context) } } MaxLineLength:SerializationToken.kt$SingletonSerializationToken$fun registerWithContext(context: SerializeAsTokenContext, toBeTokenized: SerializeAsToken) - MaxLineLength:SerializationToken.kt$SingletonSerializationToken.Companion$fun <T : SerializeAsToken> singletonSerializationToken(toBeTokenized: Class<T>) - MaxLineLength:SerializationToken.kt$SingletonSerializeAsToken : SerializeAsToken - MaxLineLength:SerializationTokenTest.kt$SerializationTokenTest$context = testCheckpointSerialization.checkpointSerializationContext.withWhitelisted(SingletonSerializationToken::class.java) MaxLineLength:SerializationTokenTest.kt$SerializationTokenTest$private fun serializeAsTokenContext(toBeTokenized: Any) - MaxLineLength:SerializationTokenTest.kt$SerializationTokenTest$val serializedBytes = tokenizableBefore.toToken(serializeAsTokenContext(emptyList<Any>())).checkpointSerialize(testContext) - MaxLineLength:SerializationWhitelist.kt$SerializationWhitelist$/** * Optionally whitelist types for use in object serialization, as we lock down the types that can be serialized. * * For example, if you add a new [net.corda.core.contracts.ContractState] it needs to be whitelisted. You can do that * either by adding the [net.corda.core.serialization.CordaSerializable] annotation or via this method. */ val whitelist: List<Class<*>> MaxLineLength:SerializeAsTokenContextImpl.kt$CheckpointSerializeAsTokenContextImpl : SerializeAsTokenContext MaxLineLength:SerializeAsTokenContextImpl.kt$CheckpointSerializeAsTokenContextImpl$constructor(toBeTokenized: Any, serializer: CheckpointSerializer, context: CheckpointSerializationContext, serviceHub: ServiceHub) : this(serviceHub, { serializer.serialize(toBeTokenized, context.withTokenContext(this)) }) MaxLineLength:SerializeAsTokenContextImpl.kt$CheckpointSerializeAsTokenContextImpl$throw UnsupportedOperationException("Attempt to write token for lazy registered $className. All tokens should be registered during context construction.") - MaxLineLength:SerializeAsTokenContextImpl.kt$SerializeAsTokenContextImpl : SerializeAsTokenContext MaxLineLength:SerializeAsTokenContextImpl.kt$SerializeAsTokenContextImpl$constructor(toBeTokenized: Any, serializationFactory: SerializationFactory, context: SerializationContext, serviceHub: ServiceHub) : this(serviceHub, { serializationFactory.serialize(toBeTokenized, context.withTokenContext(this)) }) MaxLineLength:SerializeAsTokenContextImpl.kt$SerializeAsTokenContextImpl$throw UnsupportedOperationException("Attempt to write token for lazy registered $className. All tokens should be registered during context construction.") MaxLineLength:SerializeAsTokenContextImpl.kt$fun CheckpointSerializationContext.withTokenContext(serializationContext: SerializeAsTokenContext): CheckpointSerializationContext MaxLineLength:SerializeAsTokenContextImpl.kt$fun SerializationContext.withTokenContext(serializationContext: SerializeAsTokenContext): SerializationContext MaxLineLength:SerializeAsTokenSerializer.kt$SerializeAsTokenSerializer$?: MaxLineLength:SerializerFactoryBuilder.kt$NoEvolutionSerializerFactory$override - MaxLineLength:ServiceHub.kt$ServiceHub$ fun addSignature(signedTransaction: SignedTransaction): SignedTransaction - MaxLineLength:ServiceHub.kt$ServiceHub$ fun addSignature(signedTransaction: SignedTransaction, publicKey: PublicKey): SignedTransaction - MaxLineLength:ServiceHub.kt$ServiceHub$ fun createSignature(filteredTransaction: FilteredTransaction): TransactionSignature - MaxLineLength:ServiceHub.kt$ServiceHub$ fun createSignature(filteredTransaction: FilteredTransaction, publicKey: PublicKey) - MaxLineLength:ServiceHub.kt$ServiceHub$ fun createSignature(signedTransaction: SignedTransaction, publicKey: PublicKey) - MaxLineLength:ServiceHub.kt$ServiceHub$ fun signInitialTransaction(builder: TransactionBuilder): SignedTransaction - MaxLineLength:ServiceHub.kt$ServiceHub$ fun signInitialTransaction(builder: TransactionBuilder, publicKey: PublicKey) - MaxLineLength:ServiceHub.kt$ServiceHub$/** * A network map contains lists of nodes on the network along with information about their identity keys, services * they provide and host names or IP addresses where they can be connected to. The cache wraps around a map fetched * from an authoritative service, and adds easy lookup of the data stored within it. Generally it would be initialised * with a specified network map service, which it fetches data from and then subscribes to updates of. */ val networkMapCache: NetworkMapCache MaxLineLength:ServiceHub.kt$ServiceHub$createSignature(filteredTransaction, publicKey, SignatureMetadata(myInfo.platformVersion, Crypto.findSignatureScheme(publicKey).schemeNumberID)) MaxLineLength:ServiceHub.kt$ServiceHub$createSignature(signedTransaction, publicKey, SignatureMetadata(myInfo.platformVersion, Crypto.findSignatureScheme(publicKey).schemeNumberID)) MaxLineLength:ServiceHub.kt$ServiceHub$private MaxLineLength:ServiceHub.kt$ServiceHub$signInitialTransaction(builder, publicKey, SignatureMetadata(myInfo.platformVersion, Crypto.findSignatureScheme(publicKey).schemeNumberID)) - MaxLineLength:ServiceHub.kt$ServiceHub$val stx = validatedTransactions.getTransaction(stateRef.txhash) ?: throw TransactionResolutionException(stateRef.txhash) - MaxLineLength:ServiceHub.kt$ServicesForResolution$ // TODO: future implementation to use a Vault state ref -> contract state BLOB table and perform single query bulk load // as the existing transaction store will become encrypted at some point @Throws(TransactionResolutionException::class) fun loadStates(stateRefs: Set<StateRef>): Set<StateAndRef<ContractState>> - MaxLineLength:ServiceHub.kt$StatesToRecord$ONLY_RELEVANT - MaxLineLength:ServiceHubInternal.kt$ServiceHubInternal$recordTransactions(statesToRecord, txs, validatedTransactions, stateMachineRecordedTransactionMapping, vaultService, database) - MaxLineLength:ServiceHubInternal.kt$ServiceHubInternal.Companion$require(txs.any()) { "No transactions passed in for recording" } val recordedTransactions = txs.filter { validatedTransactions.addTransaction(it) } val stateMachineRunId = FlowStateMachineImpl.currentStateMachine()?.id if (stateMachineRunId != null) { recordedTransactions.forEach { stateMachineRecordedTransactionMapping.addMapping(stateMachineRunId, it.id) } } else { log.warn("Transactions recorded from outside of a state machine") } // When the user has requested StatesToRecord.ALL we may end up recording and relationally mapping states // that do not involve us and that we cannot sign for. This will break coin selection and thus a warning // is present in the documentation for this feature (see the "Observer nodes" tutorial on docs.corda.net). // // The reason for this is three-fold: // // 1) We are putting in place the observer mode feature relatively quickly to meet specific customer // launch target dates. // // 2) The right design for vaults which mix observations and relevant states isn't entirely clear yet. // // 3) If we get the design wrong it could create security problems and business confusions. // // Back in the bitcoinj days I did add support for "watching addresses" to the wallet code, which is the // Bitcoin equivalent of observer nodes: // // https://bitcoinj.github.io/working-with-the-wallet#watching-wallets // // The ability to have a wallet containing both irrelevant and relevant states complicated everything quite // dramatically, even methods as basic as the getBalance() API which required additional modes to let you // query "balance I can spend" vs "balance I am observing". In the end it might have been better to just // require the user to create an entirely separate wallet for observing with. // // In Corda we don't support a single node having multiple vaults (at the time of writing), and it's not // clear that's the right way to go: perhaps adding an "origin" column to the VAULT_STATES table is a better // solution. Then you could select subsets of states depending on where the report came from. // // The risk of doing this is that apps/developers may use 'canned SQL queries' not written by us that forget // to add a WHERE clause for the origin column. Those queries will seem to work most of the time until // they're run on an observer node and mix in irrelevant data. In the worst case this may result in // erroneous data being reported to the user, which could cause security problems. // // Because the primary use case for recording irrelevant states is observer/regulator nodes, who are unlikely // to make writes to the ledger very often or at all, we choose to punt this issue for the time being. vaultService.notifyAll(statesToRecord, recordedTransactions.map { it.coreTransaction }) MaxLineLength:ServicesForResolutionImpl.kt$ServicesForResolutionImpl$else -> throw UnsupportedOperationException("Attempting to resolve attachment for index ${stateRef.index} of a ${ctx.javaClass} transaction. This is not supported.") MaxLineLength:ServicesForResolutionImpl.kt$ServicesForResolutionImpl$if (attachment is ContractAttachment && (forContractClassName ?: transactionState.contract) in attachment.allContracts) { return attachment } - MaxLineLength:ServicesForResolutionImpl.kt$ServicesForResolutionImpl$override MaxLineLength:ServicesForResolutionImpl.kt$ServicesForResolutionImpl$return attachments.openAttachment(ctx.upgradedContractAttachmentId) ?: throw AttachmentResolutionException(stateRef.txhash) MaxLineLength:ServicesForResolutionImpl.kt$ServicesForResolutionImpl$return ctx.inputs.map { inner(it, transactionState.contract) }.firstOrNull() ?: throw AttachmentResolutionException(stateRef.txhash) - MaxLineLength:ServicesForResolutionImpl.kt$ServicesForResolutionImpl$val stx = validatedTransactions.getTransaction(stateRef.txhash) ?: throw TransactionResolutionException(stateRef.txhash) MaxLineLength:ServicesForResolutionImpl.kt$ServicesForResolutionImpl$val transactionState = SerializedStateAndRef(resolveStateRefBinaryComponent(stateRef, this)!!, stateRef).toStateAndRef().state - MaxLineLength:SessionMessage.kt$ErrorSessionMessage : ExistingSessionMessagePayload MaxLineLength:SessionRejectException.kt$SessionRejectException$NotRegistered : SessionRejectException - MaxLineLength:SessionRejectException.kt$SessionRejectException$UnknownClass : SessionRejectException - MaxLineLength:SetsSerializationTest.kt$net.corda.serialization.internal.SetsSerializationTest.kt - MaxLineLength:Settings.kt$Settings$clientPane.disableProperty() .map { if (!it) FontAwesomeIconView(FontAwesomeIcon.TIMES) else FontAwesomeIconView(FontAwesomeIcon.EDIT) } - MaxLineLength:ShellCmdLineOptions.kt$ShellCmdLineOptions$description = ["The path to the directory containing CorDapp JARs, CorDapps are required when starting flows."] - MaxLineLength:ShellCmdLineOptions.kt$ShellCmdLineOptions$description = ["The path to the shell configuration file, used instead of providing the rest of command line options."] MaxLineLength:ShellCmdLineOptions.kt$ShellConfigurationFile.ShellConfigFile$sshHostKeyDirectory = extensions?.sshd?.let { if (it.enabled && it.hostkeypath != null) Paths.get(it.hostkeypath) else null } - MaxLineLength:ShutdownManager.kt$ShutdownManager${ isShutdown = true val result = ArrayList(registeredShutdowns) // It is important to clear `registeredShutdowns` that has been actioned upon as more than 1 driver can be created per test. // Given that `ShutdownManager` is reachable from `ApplicationShutdownHooks`, everything that was scheduled for shutdown // during 1st driver launch will not be eligible for GC during second driver launch therefore retained in memory. registeredShutdowns.clear() result } - MaxLineLength:SignableData.kt$SignableData - MaxLineLength:SignatureConstraintVersioningTests.kt$ConsumeMessage : FlowLogic - MaxLineLength:SignatureConstraintVersioningTests.kt$ConsumeMessage$val messageState = MessageState(Message(oldMessageState.message.value + "A"), ourIdentity, stateRef.state.data.linearId) MaxLineLength:SignatureConstraintVersioningTests.kt$ConsumeMessage$val txBuilder = TransactionBuilder(notary).withItems(StateAndContract(messageState, TEST_MESSAGE_CONTRACT_PROGRAM_ID), txCommand, stateRef) - MaxLineLength:SignatureConstraintVersioningTests.kt$CreateMessage$val txBuilder = TransactionBuilder(notary).withItems(StateAndContract(messageState, TEST_MESSAGE_CONTRACT_PROGRAM_ID), txCommand) - MaxLineLength:SignatureConstraintVersioningTests.kt$SignatureConstraintVersioningTests$private val base = cordappWithPackages(MessageState::class.packageName, DummyMessageContract::class.packageName).signed() - MaxLineLength:SignatureConstraintVersioningTests.kt$SignatureConstraintVersioningTests$private val user = User("mark", "dadada", setOf(startFlow<CreateMessage>(), startFlow<ConsumeMessage>(), invokeRpc("vaultQuery"))) MaxLineLength:SignatureConstraintVersioningTests.kt$SignatureConstraintVersioningTests$val nodeHandle = startNode(NodeParameters(providedName = nodeName, rpcUsers = listOf(user), additionalCordapps = listOf(newCordapp))).getOrThrow() - MaxLineLength:SignatureConstraintVersioningTests.kt$SignatureConstraintVersioningTests$val nodeHandle = startNode(NodeParameters(rpcUsers = listOf(user), additionalCordapps = listOf(oldCordapp))).getOrThrow() - MaxLineLength:SignatureConstraintVersioningTests.kt$SignatureConstraintVersioningTests$var result: StateAndRef<MessageState>? = CordaRPCClient(nodeHandle.rpcAddress).start(user.username, user.password).use { val page = it.proxy.vaultQuery(MessageState::class.java) page.states.singleOrNull() } - MaxLineLength:SignatureMetadata.kt$SignatureMetadata - MaxLineLength:SignatureScheme.kt$SignatureScheme MaxLineLength:SignedNodeInfo.kt$NodeInfoAndSigned$constructor(nodeInfo: NodeInfo, signer: (PublicKey, SerializedBytes<NodeInfo>) -> DigitalSignature) : this(nodeInfo, nodeInfo.sign(signer)) - MaxLineLength:SignedNodeInfoTest.kt$SignedNodeInfoTest$private MaxLineLength:SignedTransaction.kt$SignedTransaction : TransactionWithSignatures - MaxLineLength:SignedTransaction.kt$SignedTransaction$ @DeleteForDJVM fun resolveNotaryChangeTransaction(services: ServiceHub) - MaxLineLength:SignedTransaction.kt$SignedTransaction$ @DeleteForDJVM private fun verifyContractUpgradeTransaction(services: ServicesForResolution, checkSufficientSignatures: Boolean) - MaxLineLength:SignedTransaction.kt$SignedTransaction$ @DeleteForDJVM private fun verifyNotaryChangeTransaction(services: ServiceHub, checkSufficientSignatures: Boolean) - MaxLineLength:SignedTransaction.kt$SignedTransaction$ private fun copyWithCache(sigList: Iterable<TransactionSignature>): SignedTransaction MaxLineLength:SignedTransaction.kt$SignedTransaction$ |If you wish to verify this transaction, please contact the originator of the transaction and install the provided missing JAR. MaxLineLength:SignedTransaction.kt$SignedTransaction$"""Transaction $ltx is incorrectly formed. Most likely it was created during version 3 of Corda when the verification logic was more lenient. |Attempted to find local dependency for class: $missingClass, but could not find one. |If you wish to verify this transaction, please contact the originator of the transaction and install the provided missing JAR. |You can install it using the RPC command: `uploadAttachment` without restarting the node. |""" - MaxLineLength:SignedTransaction.kt$SignedTransaction$(services.transactionVerifierService as TransactionVerifierServiceInternal).verify(ltx, listOf(attachment)).getOrThrow() - MaxLineLength:SignedTransaction.kt$SignedTransaction$/** Cache the deserialized form of the transaction. This is useful when building a transaction or collecting signatures. */ @Volatile @Transient private var cachedTransaction: CoreTransaction? = null - MaxLineLength:SignedTransaction.kt$SignedTransaction$/** Returns the contained [WireTransaction], or throws if this is a notary change or contract upgrade transaction. */ val tx: WireTransaction get() = coreTransaction as WireTransaction MaxLineLength:SignedTransaction.kt$SignedTransaction$?: MaxLineLength:SignedTransaction.kt$SignedTransaction$@Throws(SignatureException::class, AttachmentResolutionException::class, TransactionResolutionException::class, TransactionVerificationException::class) MaxLineLength:SignedTransaction.kt$SignedTransaction$SignaturesMissingException : NamedByHashSignatureExceptionCordaThrowable - MaxLineLength:SignedTransaction.kt$SignedTransaction$if (e.cause is NotSerializableException && e.cause.cause is ClassNotFoundException && e.cause.cause!!.message != null) { verifyWithExtraDependency(e.cause.cause!!.message!!.replace(".", "/"), ltx, services, e) } else { throw e } - MaxLineLength:SignedTransaction.kt$SignedTransaction$is FilteredTransaction -> throw IllegalStateException("Persistence of filtered transactions is not supported.") - MaxLineLength:SignedTransaction.kt$SignedTransaction$private - MaxLineLength:SignedTransaction.kt$SignedTransaction$require(sigs.isNotEmpty()) { "Tried to instantiate a ${SignedTransaction::class.java.simpleName} without any signatures " } MaxLineLength:SignedTransaction.kt$SignedTransaction$throw TransactionVerificationException.TransactionNetworkParameterOrderingException(id, entry.value.first(), txNetworkParameters, params) - MaxLineLength:SignedTransaction.kt$SignedTransaction${ // If that transaction was created with and after Corda 4 then just fail. // The lenient dependency verification is only supported for Corda 3 transactions. // To detect if the transaction was created before Corda 4 we check if the transaction has the NetworkParameters component group. if (this.networkParametersHash != null) { throw exception } val attachment = requireNotNull(services.attachments.internalFindTrustedAttachmentForClass(missingClass)) { """Transaction $ltx is incorrectly formed. Most likely it was created during version 3 of Corda when the verification logic was more lenient. |Attempted to find local dependency for class: $missingClass, but could not find one. |If you wish to verify this transaction, please contact the originator of the transaction and install the provided missing JAR. |You can install it using the RPC command: `uploadAttachment` without restarting the node. |""".trimMargin() } log.warn("""Detected that transaction ${this.id} does not contain all cordapp dependencies. |This may be the result of a bug in a previous version of Corda. |Attempting to verify using the additional trusted dependency: $attachment for class $missingClass. |Please check with the originator that this is a valid transaction.""".trimMargin()) (services.transactionVerifierService as TransactionVerifierServiceInternal).verify(ltx, listOf(attachment)).getOrThrow() } MaxLineLength:SimmFlow.kt$SimmFlow.Receiver$ @Suspendable private fun agreeValuation(portfolio: Portfolio, asOf: LocalDate, valuer: Party): PortfolioValuation MaxLineLength:SimmFlow.kt$SimmFlow.Receiver$val PVs = OGTrades.map { it.info.id.get().value to pricer.presentValue(it.product, combinedRatesProvider).toCordaCompatible() }.toMap() - MaxLineLength:SimmFlow.kt$SimmFlow.Receiver$val calculatorTotal = RwamBimmNotProductClassesCalculator(fxRateProvider, Currency.EUR, IsdaConfiguration.INSTANCE) - MaxLineLength:SimmFlow.kt$SimmFlow.Receiver$val imBatch = analyticsEngine.calculateMarginBatch(sensBatch, combinedRatesProvider, fxRateProvider, cordaMargin) MaxLineLength:SimmFlow.kt$SimmFlow.Receiver$val margin = BimmAnalysisUtils.computeMargin(combinedRatesProvider, normalizer, calculatorTotal, sensitivities.first, sensitivities.second) MaxLineLength:SimmFlow.kt$SimmFlow.Receiver$val portfolio = serviceHub.vaultService.queryBy<IRSState>(VaultQueryCriteria(stateRefs = stateRef.state.data.portfolio)).states.toPortfolio() MaxLineLength:SimmFlow.kt$SimmFlow.Receiver$val valuer = serviceHub.identityService.wellKnownPartyFromAnonymous(stateRef.state.data.valuer) ?: throw IllegalStateException("Unknown valuer party ${stateRef.state.data.valuer}") MaxLineLength:SimmFlow.kt$SimmFlow.Requester$notary = serviceHub.networkMapCache.notaryIdentities.first() - MaxLineLength:SimmFlow.kt$SimmFlow.Requester$otherPartySession.sendAndReceive<Ack>(OfferMessage(notary, stateAndRef.state.data, existing?.ref, valuationDate)) MaxLineLength:SimmFlow.kt$SimmFlow.Requester$val PVs = OGTrades.map { it.info.id.get().value to pricer.presentValue(it.product, combinedRatesProvider).toCordaCompatible() }.toMap() - MaxLineLength:SimmFlow.kt$SimmFlow.Requester$val calculatorTotal = RwamBimmNotProductClassesCalculator(fxRateProvider, Currency.EUR, IsdaConfiguration.INSTANCE) - MaxLineLength:SimmFlow.kt$SimmFlow.Requester$val imBatch = analyticsEngine.calculateMarginBatch(sensBatch, combinedRatesProvider, fxRateProvider, cordaMargin) MaxLineLength:SimmFlow.kt$SimmFlow.Requester$val margin = BimmAnalysisUtils.computeMargin(combinedRatesProvider, normalizer, calculatorTotal, sensitivities.first, sensitivities.second) - MaxLineLength:SimmFlow.kt$SimmFlow.Requester$val portfolio = serviceHub.vaultService.queryBy<IRSState>(VaultQueryCriteria(stateRefs = state.portfolio)).states.toPortfolio() MaxLineLength:SimmFlow.kt$SimmFlow.Requester.StateRevisionFlowRequester$private MaxLineLength:SimmRevaluation.kt$SimmRevaluation.Initiator$val stateAndRef = serviceHub.vaultService.queryBy<PortfolioState>(VaultQueryCriteria(stateRefs = listOf(curStateRef))).states.single() MaxLineLength:SimmValuationTest.kt$SimmValuationTest$cordappsForAllNodes = listOf(findCordapp("net.corda.vega.flows"), findCordapp("net.corda.vega.contracts"), findCordapp("net.corda.confidential")) + FINANCE_CORDAPPS - MaxLineLength:SimmValuationTest.kt$SimmValuationTest$partyApi.postJson("${counterparty.id}/portfolio/valuations/calculate", PortfolioApi.ValuationCreationParams(valuationDate)) MaxLineLength:SimmValuationTest.kt$SimmValuationTest$startNodesInProcess = false - MaxLineLength:SimmValuationTest.kt$SimmValuationTest$val logConfigFile = projectRootDir / "samples" / "simm-valuation-demo" / "src" / "main" / "resources" / "log4j2.xml" - MaxLineLength:SimmValuationTest.kt$SimmValuationTest$val nodeAApi = HttpApi.fromHostAndPort(nodeAWebServerFuture.getOrThrow().listenAddress, "api/simmvaluationdemo") - MaxLineLength:SimmValuationTest.kt$SimmValuationTest$val nodeBApi = HttpApi.fromHostAndPort(nodeBWebServerFuture.getOrThrow().listenAddress, "api/simmvaluationdemo") - MaxLineLength:SimmValuationTest.kt$SimmValuationTest$valuationDate - MaxLineLength:SimpleMQClient.kt$SimpleMQClient$session = sessionFactory.createSession(username, password, false, true, true, locator.isPreAcknowledge, locator.ackBatchSize) MaxLineLength:SimpleNotaryService.kt$SimpleNotaryService : SinglePartyNotaryService - MaxLineLength:SimpleNotaryService.kt$SimpleNotaryService$?: - MaxLineLength:SimpleNotaryService.kt$SimpleNotaryService$override val uniquenessProvider = PersistentUniquenessProvider(services.clock, services.database, services.cacheFactory) MaxLineLength:SinglePartyNotaryService.kt$SinglePartyNotaryService$val signableData = SignableData(txId, SignatureMetadata(services.myInfo.platformVersion, Crypto.findSignatureScheme(notaryIdentityKey).schemeNumberID)) MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$ #See https://docs.corda.net/head/testing.html#running-tests-in-intellij - 'Fiber classes not instrumented' for more details. - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$ override fun stop(allowedUnsuspendedFiberCount: Int) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$"""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/head/testing.html#running-tests-in-intellij - 'Fiber classes not instrumented' for more details.""" MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$CheckpointSerializeAsTokenContextImpl(tokenizableServices, CheckpointSerializationDefaults.CHECKPOINT_SERIALIZER, CheckpointSerializationDefaults.CHECKPOINT_CONTEXT, serviceHub) MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$DataFeed(flows.values.map { it.fiber.logic }, changesPublisher.bufferUntilSubscribed().wrapWithDatabaseTransaction(database)) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$changesPublisher.onNext(StateMachineManager.Change.Removed(lastState.flowLogic, Try.Failure<Nothing>(exception))) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$changesPublisher.onNext(StateMachineManager.Change.Removed(lastState.flowLogic, Try.Success(removalReason.flowReturnValue))) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$check(!foundUnrestorableFibers) { "Unrestorable checkpoints were created, please check the logs for details." } MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$errorAndTerminate("Caught unrecoverable error from flow. Forcibly terminating the JVM, this might leave resources open, and most likely will.", throwable) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$is ExistingSessionMessage -> onExistingSessionMessage(sessionMessage, event.deduplicationHandler, sender) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$is InitiatedFlowFactory.CorDapp -> FlowInfo(initiatedFlowFactory.flowVersion, initiatedFlowFactory.appName) MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$logger.debug { "Ignoring request to set time-out on timed flow $flowId to $timeoutSeconds seconds which is shorter than default of ${serviceHub.configuration.flowTimeout.timeout.seconds} seconds." } - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$logger.debug("Unable to kill a flow unknown to physical node. Might be processed by another physical node.") MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$logger.error("Unable to deserialize database checkpoint for flow $flowId. Something is very wrong. The flow will not retry.") - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$logger.error("Unable to find database checkpoint for flow $flowId. Something is very wrong. The flow will not retry.") MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$private - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$private val fiberDeserializationChecker = if (serviceHub.configuration.shouldCheckCheckpoints()) FiberDeserializationChecker() else null MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$require(lastState.pendingDeduplicationHandlers.isEmpty()) { "Flow cannot be removed until all pending deduplications have completed" } - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$return serviceHub.getFlowFactory(initiatorFlowClass) ?: throw SessionRejectException.NotRegistered(initiatorFlowClass) MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$startInitiatedFlow(flowLogic, event.deduplicationHandler, senderSession, initiatedSessionId, sessionMessage, senderCoreFlowVersion, initiatedFlowInfo) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$val externalEvents = currentState.pendingDeduplicationHandlers.map { it.externalCause } + unprocessedExternalEvents MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$val flowCorDappVersion = createSubFlowVersion(serviceHub.cordappProvider.getCordappForFlow(flowLogic), serviceHub.myInfo.platformVersion) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$val flowStart = FlowStart.Initiated(peerSession, initiatedSessionId, initiatingMessage, senderCoreFlowVersion, initiatedFlowInfo) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$val frozenFlowLogic = (flowLogic as FlowLogic<*>).checkpointSerialize(context = checkpointSerializationContext!!) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$val future = startFlow(event.flowLogic, event.context, ourIdentity = null, deduplicationHandler = event.deduplicationHandler) - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager$val timeoutDelaySeconds = timeout.seconds * Math.pow(backoffBase, min(retryCount, maxRestartCount).toDouble()).toLong() - MaxLineLength:SingleThreadedStateMachineManager.kt$SingleThreadedStateMachineManager${ val flowId = StateMachineRunId.createRandom() // 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) val flowStateMachineImpl = FlowStateMachineImpl(flowId, flowLogic, scheduler) val resultFuture = openFuture<Any?>() flowStateMachineImpl.transientValues = TransientReference(createTransientValues(flowId, resultFuture)) flowLogic.stateMachine = flowStateMachineImpl val frozenFlowLogic = (flowLogic as FlowLogic<*>).checkpointSerialize(context = checkpointSerializationContext!!) val flowCorDappVersion = createSubFlowVersion(serviceHub.cordappProvider.getCordappForFlow(flowLogic), serviceHub.myInfo.platformVersion) val initialCheckpoint = Checkpoint.create( invocationContext, flowStart, flowLogic.javaClass, frozenFlowLogic, ourIdentity, flowCorDappVersion, flowLogic.isEnabledTimedFlow() ).getOrThrow() val startedFuture = openFuture<Unit>() val initialState = StateMachineState( checkpoint = initialCheckpoint, pendingDeduplicationHandlers = deduplicationHandler?.let { listOf(it) } ?: emptyList(), isFlowResumed = false, isTransactionTracked = false, isAnyCheckpointPersisted = false, isStartIdempotent = isStartIdempotent, isRemoved = false, flowLogic = flowLogic, senderUUID = ourSenderUUID ) flowStateMachineImpl.transientState = TransientReference(initialState) mutex.locked { startedFutures[flowId] = startedFuture } totalStartedFlows.inc() addAndStartFlow(flowId, Flow(flowStateMachineImpl, resultFuture)) return startedFuture.map { flowStateMachineImpl as FlowStateMachine<A> } } - MaxLineLength:SingletonSerializer.kt$SingletonSerializer : AMQPSerializer MaxLineLength:SingletonSerializer.kt$SingletonSerializer$internal val typeNotation: TypeNotation = RestrictedType(type.typeName, "Singleton", generateProvides(), "boolean", Descriptor(typeDescriptor), emptyList()) - MaxLineLength:SingletonSerializer.kt$SingletonSerializer$override MaxLineLength:Specification.kt$ListPropertyDelegateImpl$override fun <MAPPED> mapValid(mappedTypeName: String, convert: (List<TYPE>) -> Valid<MAPPED>): PropertyDelegate.Required<MAPPED> MaxLineLength:Specification.kt$ListPropertyDelegateImpl$override fun optional(): PropertyDelegate.Optional<List<TYPE>> MaxLineLength:Specification.kt$ListPropertyDelegateImpl$override operator MaxLineLength:Specification.kt$ListPropertyDelegateImpl$private - MaxLineLength:Specification.kt$ListPropertyDelegateImpl.<no name provided>$override fun getValue(thisRef: Any?, property: KProperty<*>): Configuration.Property.Definition.RequiredList<TYPE> MaxLineLength:Specification.kt$OptionalPropertyDelegateImpl$override fun withDefaultValue(defaultValue: TYPE): PropertyDelegate<TYPE> MaxLineLength:Specification.kt$OptionalPropertyDelegateImpl$override operator MaxLineLength:Specification.kt$OptionalPropertyDelegateImpl$private - MaxLineLength:Specification.kt$OptionalPropertyDelegateImpl.<no name provided>$override fun getValue(thisRef: Any?, property: KProperty<*>): Configuration.Property.Definition.Optional<TYPE> MaxLineLength:Specification.kt$OptionalWithDefaultPropertyDelegateImpl$override operator MaxLineLength:Specification.kt$OptionalWithDefaultPropertyDelegateImpl$private - MaxLineLength:Specification.kt$PropertyDelegate$operator fun provideDelegate(thisRef: Any?, property: KProperty<*>): ReadOnlyProperty<Any?, Configuration.Property.Definition<TYPE>> MaxLineLength:Specification.kt$PropertyDelegate.Companion$internal fun <ENUM : Enum<ENUM>> enum(key: String?, prefix: String?, enumClass: KClass<ENUM>, sensitive: Boolean, addProperty: (Configuration.Property.Definition<*>) -> Unit): Standard<ENUM> MaxLineLength:Specification.kt$PropertyDelegate.Companion$internal fun boolean(key: String?, prefix: String?, sensitive: Boolean, addProperty: (Configuration.Property.Definition<*>) -> Unit): Standard<Boolean> MaxLineLength:Specification.kt$PropertyDelegate.Companion$internal fun double(key: String?, prefix: String?, sensitive: Boolean, addProperty: (Configuration.Property.Definition<*>) -> Unit): Standard<Double> @@ -8607,280 +4756,108 @@ MaxLineLength:Specification.kt$PropertyDelegateImpl$override fun optional(): PropertyDelegate.Optional<TYPE> MaxLineLength:Specification.kt$PropertyDelegateImpl$override operator MaxLineLength:Specification.kt$PropertyDelegateImpl$private - MaxLineLength:Specification.kt$PropertyDelegateImpl.<no name provided>$override fun getValue(thisRef: Any?, property: KProperty<*>): Configuration.Property.Definition.Standard<TYPE> MaxLineLength:Specification.kt$RequiredPropertyDelegateImpl$override fun optional(): PropertyDelegate.Optional<TYPE> MaxLineLength:Specification.kt$RequiredPropertyDelegateImpl$override operator MaxLineLength:Specification.kt$RequiredPropertyDelegateImpl$private - MaxLineLength:Specification.kt$RequiredPropertyDelegateImpl.<no name provided>$override fun getValue(thisRef: Any?, property: KProperty<*>): Configuration.Property.Definition.Required<TYPE> - MaxLineLength:SpecificationTest.kt$SpecificationTest$assertThat(result.errors.first()) - MaxLineLength:SpecificationTest.kt$SpecificationTest$assertThat(rpcSettings.errors.first()) MaxLineLength:SpecificationTest.kt$SpecificationTest$val addressesValue = configObject("principal" to "${principalAddressValue.host}:${principalAddressValue.port}", "admin" to "${adminAddressValue.host}:${adminAddressValue.port}") MaxLineLength:SpecificationTest.kt$SpecificationTest$val addressesValue = configObject("principal" to "${principalAddressValue.host}:-10", "admin" to "${adminAddressValue.host}:${adminAddressValue.port}") MaxLineLength:SpecificationTest.kt$SpecificationTest.RpcSettingsSpec$override fun parseValid(configuration: Config) - MaxLineLength:SpecificationTest.kt$SpecificationTest.RpcSettingsSpec.AddressesSpec$override fun parseValid(configuration: Config) - MaxLineLength:SpecificationTest.kt$SpecificationTest.RpcSettingsSpec.AddressesSpec$return Address.validFromRawValue(rawValue) { error -> Configuration.Validation.Error.BadValue.of(error) } - MaxLineLength:SpringDriver.kt$SpringBootDriverDSL$ fun startSpringBootWebapp(clazz: Class<*>, handle: NodeHandle, checkUrl: String): CordaFuture<WebserverHandle> - MaxLineLength:SpringDriver.kt$SpringBootDriverDSL$val client = OkHttpClient.Builder().connectTimeout(5, TimeUnit.SECONDS).readTimeout(10, TimeUnit.SECONDS).build() - MaxLineLength:SpringDriver.kt$SpringBootDriverDSL$val webReadyFuture = addressMustBeBoundFuture(driverDSL.executorService, (handle as NodeHandleInternal).webAddress, process) MaxLineLength:SslConfiguration.kt$MutualSslOptions : MutualSslConfiguration - MaxLineLength:SslConfiguration.kt$SslConfiguration.Companion$fun mutual(keyStore: FileBasedCertificateStoreSupplier, trustStore: FileBasedCertificateStoreSupplier): MutualSslConfiguration MaxLineLength:StabilityTest.kt$StabilityTest$SelfIssueCommand(IssueAndPaymentRequest(Amount(100000, USD), OpaqueBytes.of(0), issuer.mainIdentity, notaryIdentity, anonymous = true), issuer) - MaxLineLength:StabilityTest.kt$StabilityTest$is IssueAndPaymentRequest -> command.node.proxy.startFlow(::CashIssueAndPaymentFlow, request).returnValue MaxLineLength:StabilityTest.kt$StabilityTest$simpleNodes.flatMap { payer -> simpleNodes.map { payer to it } } .filter { it.first != it.second } .map { (payer, payee) -> CrossCashCommand(PaymentRequest(Amount(1, USD), payee.mainIdentity, anonymous = true), payer) } - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$ fun dropSessionInit(id: UUID): Boolean MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$ fun sessionInitErrored(sessionMessage: InitialSessionMessage, sender: Party, event: ExternalEvent.ExternalMessageEvent, error: Throwable) - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$"the UUID $id (from the node shell you can run 'flow kill $id'). BE VERY CAUTIOUS OF THIS SECOND APPROACH AS THE " MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$flowMessaging.sendSessionMessage(sender, replyError, SenderDeduplicationId(DeduplicationId.createRandom(secureRandom), ourSenderUUID)) MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$log MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$log.info("Flow error discharged from hospital (delay ${backOff.seconds}s) by ${report.by} (error was ${report.error.message})") - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$log.info("Flow error kept for overnight observation by ${report.by} (error was ${report.error.message})") MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$private MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$val diagnoses: Map<Diagnosis, List<Staff>> = staff.groupBy { it.consult(flowFiber, currentState, error, medicalHistory) } - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$val record = MedicalRecord.Flow(time, flowFiber.id, currentState.checkpoint.numberOfSuspends, errors, report.by, outcome) MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$val record = sessionMessage.run { MedicalRecord.SessionInit(id, time, outcome, initiatorFlowClassName, flowVersion, appName, sender, error) } MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital$val snapshot = (flowPatients.values.flatMap { it.records } + treatableSessionInits.values.map { it.publicRecord }).sortedBy { it.time } - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital${ log.info("Flow error kept for overnight observation by ${report.by} (error was ${report.error.message})") // We don't schedule a next event for the flow - it will automatically retry from its checkpoint on node restart Triple(Outcome.OVERNIGHT_OBSERVATION, null, 0.seconds) } - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital${ private companion object { private val log = contextLogger() private val staff = listOf(DeadlockNurse, DuplicateInsertSpecialist, DoctorTimeout, FinalityDoctor) } private val mutex = ThreadBox(object { val flowPatients = HashMap<StateMachineRunId, FlowMedicalHistory>() val treatableSessionInits = HashMap<UUID, InternalSessionInitRecord>() val recordsPublisher = PublishSubject.create<MedicalRecord>() }) private val secureRandom = newSecureRandom() private val delayedDischargeTimer = Timer("FlowHospitalDelayedDischargeTimer", true) /** * The node was unable to initiate the [InitialSessionMessage] from [sender]. */ fun sessionInitErrored(sessionMessage: InitialSessionMessage, sender: Party, event: ExternalEvent.ExternalMessageEvent, error: Throwable) { val time = Instant.now() val id = UUID.randomUUID() val outcome = if (error is SessionRejectException.UnknownClass) { // We probably don't have the CorDapp installed so let's pause the message in the hopes that the CorDapp is // installed on restart, at which point the message will be able proceed as normal. If not then it will need // to be dropped manually. Outcome.OVERNIGHT_OBSERVATION } else { Outcome.UNTREATABLE } val record = sessionMessage.run { MedicalRecord.SessionInit(id, time, outcome, initiatorFlowClassName, flowVersion, appName, sender, error) } mutex.locked { if (outcome != Outcome.UNTREATABLE) { treatableSessionInits[id] = InternalSessionInitRecord(sessionMessage, event, record) log.warn("$sender has sent a flow request for an unknown flow ${sessionMessage.initiatorFlowClassName}. Install the missing " + "CorDapp this flow belongs to and restart.") log.warn("If you know it's safe to ignore this flow request then it can be deleted permanently using the killFlow RPC and " + "the UUID $id (from the node shell you can run 'flow kill $id'). BE VERY CAUTIOUS OF THIS SECOND APPROACH AS THE " + "REQUEST MAY CONTAIN A NOTARISED TRANSACTION THAT NEEDS TO BE RECORDED IN YOUR VAULT.") } recordsPublisher.onNext(record) } if (outcome == Outcome.UNTREATABLE) { sendBackError(error, sessionMessage, sender, event) } } private fun sendBackError(error: Throwable, sessionMessage: InitialSessionMessage, sender: Party, event: ExternalEvent.ExternalMessageEvent) { val message = (error as? SessionRejectException)?.message ?: "Unable to establish session" val payload = RejectSessionMessage(message, secureRandom.nextLong()) val replyError = ExistingSessionMessage(sessionMessage.initiatorSessionId, payload) flowMessaging.sendSessionMessage(sender, replyError, SenderDeduplicationId(DeduplicationId.createRandom(secureRandom), ourSenderUUID)) event.deduplicationHandler.afterDatabaseTransaction() } /** * Drop the errored session-init message with the given ID ([MedicalRecord.SessionInit.id]). This will cause the node * to send back the relevant session error to the initiator party and acknowledge its receipt from the message broker * so that it never gets redelivered. */ fun dropSessionInit(id: UUID): Boolean { val (sessionMessage, event, publicRecord) = mutex.locked { treatableSessionInits.remove(id) ?: return false } log.info("Errored session-init permanently dropped: $publicRecord") sendBackError(publicRecord.error, sessionMessage, publicRecord.sender, event) return true } /** * The flow running in [flowFiber] has errored. */ fun flowErrored(flowFiber: FlowFiber, currentState: StateMachineState, errors: List<Throwable>) { val time = Instant.now() log.info("Flow ${flowFiber.id} admitted to hospital in state $currentState") val (event, backOffForChronicCondition) = mutex.locked { val medicalHistory = flowPatients.computeIfAbsent(flowFiber.id) { FlowMedicalHistory() } val report = consultStaff(flowFiber, currentState, errors, medicalHistory) val (outcome, event, backOffForChronicCondition) = when (report.diagnosis) { Diagnosis.DISCHARGE -> { val backOff = calculateBackOffForChronicCondition(report, medicalHistory, currentState) log.info("Flow error discharged from hospital (delay ${backOff.seconds}s) by ${report.by} (error was ${report.error.message})") Triple(Outcome.DISCHARGE, Event.RetryFlowFromSafePoint, backOff) } Diagnosis.OVERNIGHT_OBSERVATION -> { log.info("Flow error kept for overnight observation by ${report.by} (error was ${report.error.message})") // We don't schedule a next event for the flow - it will automatically retry from its checkpoint on node restart Triple(Outcome.OVERNIGHT_OBSERVATION, null, 0.seconds) } Diagnosis.NOT_MY_SPECIALTY -> { // None of the staff care for these errors so we let them propagate log.info("Flow error allowed to propagate", report.error) Triple(Outcome.UNTREATABLE, Event.StartErrorPropagation, 0.seconds) } } val record = MedicalRecord.Flow(time, flowFiber.id, currentState.checkpoint.numberOfSuspends, errors, report.by, outcome) medicalHistory.records += record recordsPublisher.onNext(record) Pair(event, backOffForChronicCondition) } if (event != null) { if (backOffForChronicCondition.isZero) { flowFiber.scheduleEvent(event) } else { delayedDischargeTimer.schedule(object : TimerTask() { override fun run() { flowFiber.scheduleEvent(event) } }, backOffForChronicCondition.toMillis()) } } } private fun calculateBackOffForChronicCondition(report: ConsultationReport, medicalHistory: FlowMedicalHistory, currentState: StateMachineState): Duration { return report.by.firstOrNull { it is Chronic }?.let { chronicStaff -> return medicalHistory.timesDischargedForTheSameThing(chronicStaff, currentState).let { if (it == 0) { 0.seconds } else { maxOf(10, (10 + (Math.random()) * (10 * 1.5.pow(it)) / 2).toInt()).seconds } } } ?: 0.seconds } private fun consultStaff(flowFiber: FlowFiber, currentState: StateMachineState, errors: List<Throwable>, medicalHistory: FlowMedicalHistory): ConsultationReport { return errors .asSequence() .mapIndexed { index, error -> // Rely on the logging context to print details of the flow ID. log.info("Error ${index + 1} of ${errors.size}:", error) val diagnoses: Map<Diagnosis, List<Staff>> = staff.groupBy { it.consult(flowFiber, currentState, error, medicalHistory) } // We're only interested in the highest priority diagnosis for the error val (diagnosis, by) = diagnoses.entries.minBy { it.key }!! ConsultationReport(error, diagnosis, by) } // And we're only interested in the error with the highest priority diagnosis .minBy { it.diagnosis }!! } private data class ConsultationReport(val error: Throwable, val diagnosis: Diagnosis, val by: List<Staff>) /** * The flow has been removed from the state machine. */ fun flowRemoved(flowId: StateMachineRunId) { mutex.locked { flowPatients.remove(flowId) } } // TODO MedicalRecord subtypes can expose the Staff class, something which we probably don't want when wiring this method to RPC /** Returns a stream of medical records as flows pass through the hospital. */ fun track(): DataFeed<List<MedicalRecord>, MedicalRecord> { return mutex.locked { val snapshot = (flowPatients.values.flatMap { it.records } + treatableSessionInits.values.map { it.publicRecord }).sortedBy { it.time } DataFeed(snapshot, recordsPublisher.bufferUntilSubscribed()) } } operator fun contains(flowId: StateMachineRunId) = mutex.locked { flowId in flowPatients } class FlowMedicalHistory { internal val records: MutableList<MedicalRecord.Flow> = mutableListOf() fun notDischargedForTheSameThingMoreThan(max: Int, by: Staff, currentState: StateMachineState): Boolean { return timesDischargedForTheSameThing(by, currentState) <= max } fun timesDischargedForTheSameThing(by: Staff, currentState: StateMachineState): Int { val lastAdmittanceSuspendCount = currentState.checkpoint.numberOfSuspends return records.count { it.outcome == Outcome.DISCHARGE && by in it.by && it.suspendCount == lastAdmittanceSuspendCount } } override fun toString(): String = "${this.javaClass.simpleName}(records = $records)" } private data class InternalSessionInitRecord(val sessionMessage: InitialSessionMessage, val event: ExternalEvent.ExternalMessageEvent, val publicRecord: MedicalRecord.SessionInit) sealed class MedicalRecord { abstract val time: Instant abstract val outcome: Outcome abstract val errors: List<Throwable> /** Medical record for a flow that has errored. */ data class Flow(override val time: Instant, val flowId: StateMachineRunId, val suspendCount: Int, override val errors: List<Throwable>, val by: List<Staff>, override val outcome: Outcome) : MedicalRecord() /** Medical record for a session initiation that was unsuccessful. */ data class SessionInit(val id: UUID, override val time: Instant, override val outcome: Outcome, val initiatorFlowClassName: String, val flowVersion: Int, val appName: String, val sender: Party, val error: Throwable) : MedicalRecord() { override val errors: List<Throwable> get() = listOf(error) } } enum class Outcome { DISCHARGE, OVERNIGHT_OBSERVATION, UNTREATABLE } /** The order of the enum values are in priority order. */ enum class Diagnosis { /** Retry from last safe point. */ DISCHARGE, /** Park and await intervention. */ OVERNIGHT_OBSERVATION, /** Please try another member of staff. */ NOT_MY_SPECIALTY } interface Staff { fun consult(flowFiber: FlowFiber, currentState: StateMachineState, newError: Throwable, history: FlowMedicalHistory): Diagnosis } interface Chronic /** * SQL Deadlock detection. */ object DeadlockNurse : Staff, Chronic { override fun consult(flowFiber: FlowFiber, currentState: StateMachineState, newError: Throwable, history: FlowMedicalHistory): Diagnosis { return if (mentionsDeadlock(newError)) { Diagnosis.DISCHARGE } else { Diagnosis.NOT_MY_SPECIALTY } } private fun mentionsDeadlock(exception: Throwable?): Boolean { return exception != null && (exception is SQLException && ((exception.message?.toLowerCase()?.contains("deadlock") ?: false)) || mentionsDeadlock(exception.cause)) } } /** * Primary key violation detection for duplicate inserts. Will detect other constraint violations too. */ object DuplicateInsertSpecialist : Staff { override fun consult(flowFiber: FlowFiber, currentState: StateMachineState, newError: Throwable, history: FlowMedicalHistory): Diagnosis { return if (mentionsConstraintViolation(newError) && history.notDischargedForTheSameThingMoreThan(3, this, currentState)) { Diagnosis.DISCHARGE } else { Diagnosis.NOT_MY_SPECIALTY } } private fun mentionsConstraintViolation(exception: Throwable?): Boolean { return exception != null && (exception is ConstraintViolationException || mentionsConstraintViolation(exception.cause)) } } /** * Restarts [TimedFlow], keeping track of the number of retries and making sure it does not * exceed the limit specified by the [FlowTimeoutException]. */ object DoctorTimeout : Staff { override fun consult(flowFiber: FlowFiber, currentState: StateMachineState, newError: Throwable, history: FlowMedicalHistory): Diagnosis { if (newError is FlowTimeoutException) { return Diagnosis.DISCHARGE } return Diagnosis.NOT_MY_SPECIALTY } } object FinalityDoctor : Staff { override fun consult(flowFiber: FlowFiber, currentState: StateMachineState, newError: Throwable, history: FlowMedicalHistory): Diagnosis { return if (currentState.flowLogic is FinalityHandler || isFromReceiveFinalityFlow(newError)) { log.warn("Flow ${flowFiber.id} failed to be finalised. Manual intervention may be required before retrying " + "the flow by re-starting the node. State machine state: $currentState", newError) Diagnosis.OVERNIGHT_OBSERVATION } else { Diagnosis.NOT_MY_SPECIALTY } } private fun isFromReceiveFinalityFlow(throwable: Throwable): Boolean { return throwable.stackTrace.any { it.className == ReceiveFinalityFlow::class.java.name } } } } MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital.DeadlockNurse$override - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital.DeadlockNurse$return exception != null && (exception is SQLException && ((exception.message?.toLowerCase()?.contains("deadlock") ?: false)) || mentionsDeadlock(exception.cause)) MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital.DoctorTimeout$override MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital.DuplicateInsertSpecialist$override - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital.DuplicateInsertSpecialist$return exception != null && (exception is ConstraintViolationException || mentionsConstraintViolation(exception.cause)) - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital.DuplicateInsertSpecialist$return if (mentionsConstraintViolation(newError) && history.notDischargedForTheSameThingMoreThan(3, this, currentState)) { Diagnosis.DISCHARGE } else { Diagnosis.NOT_MY_SPECIALTY } - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital.FinalityDoctor$log MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital.FinalityDoctor$override - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital.FlowMedicalHistory$return records.count { it.outcome == Outcome.DISCHARGE && by in it.by && it.suspendCount == lastAdmittanceSuspendCount } - MaxLineLength:StaffedFlowHospital.kt$StaffedFlowHospital.Staff$fun consult(flowFiber: FlowFiber, currentState: StateMachineState, newError: Throwable, history: FlowMedicalHistory): Diagnosis - MaxLineLength:StandaloneCordaRPClientTest.kt$StandaloneCordaRPClientTest$rpcProxy.startFlow(::CashPaymentFlow, 100.POUNDS, notaryNodeIdentity, true, notaryNodeIdentity).returnValue.getOrThrow() - MaxLineLength:StandaloneCordaRPClientTest.kt$StandaloneCordaRPClientTest$val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.RECORDED_TIME), Sort.Direction.DESC))) MaxLineLength:StandaloneShell.kt$StandaloneShell$Ansi.ansi().fgBrightRed().a( """ ______ __""").newline().a( """ / ____/ _________/ /___ _""").newline().a( """ / / __ / ___/ __ / __ `/ """).newline().fgBrightRed().a( """/ /___ /_/ / / / /_/ / /_/ /""").newline().fgBrightRed().a( """\____/ /_/ \__,_/\__,_/""").reset().fgBrightDefault().bold() .newline() - MaxLineLength:StandaloneShell.kt$StandaloneShell$if (System.console() != null) System.console().readPassword(format, *args) else this.readLine(format, *args).toCharArray() - MaxLineLength:StandaloneShell.kt$StandaloneShell$it.filter { it.isRegularFile() && it.toString().endsWith(".jar") }.map { it.toUri().toURL() }.toList() MaxLineLength:StandardConfigValueParsers.kt$internal fun <RESULT> badValue(message: String) - MaxLineLength:StandardConfigValueParsers.kt$internal fun toCordaX500Name(rawValue: String) MaxLineLength:StandardConfigValueParsers.kt$internal fun toNetworkHostAndPort(rawValue: String) - MaxLineLength:StandardConfigValueParsers.kt$internal fun toPrincipal(rawValue: String) MaxLineLength:StandardConfigValueParsers.kt$internal inline fun <reified RESULT, reified ERROR : Exception> attempt(action: () -> RESULT) MaxLineLength:StandardConfigValueParsers.kt$private fun Config.toProperties() - MaxLineLength:StandardConfigValueParsers.kt$private inline MaxLineLength:StartedFlowTransition.kt$StartedFlowTransition$actions.add(Action.SendExisting(existingSessionState.peerParty, existingMessage, SenderDeduplicationId(deduplicationId, startingState.senderUUID))) MaxLineLength:StartedFlowTransition.kt$StartedFlowTransition$actions.add(Action.SendInitial(existingSessionState.party, initialMessage, SenderDeduplicationId(deduplicationId, startingState.senderUUID))) MaxLineLength:StartedFlowTransition.kt$StartedFlowTransition$actions.add(Action.SendInitial(sessionState.party, initialMessage, SenderDeduplicationId(deduplicationId, startingState.senderUUID))) - MaxLineLength:StartedFlowTransition.kt$StartedFlowTransition$collectErroredSessionErrors(sessionIds, checkpoint) + collectEndedEmptySessionErrors(sessionIds, checkpoint) - MaxLineLength:StartedFlowTransition.kt$StartedFlowTransition$newSessionMessages[sessionId] = sessionState.copy(receivedMessages = messages.subList(1, messages.size).toList()) MaxLineLength:StartedFlowTransition.kt$StartedFlowTransition$private - MaxLineLength:StartedFlowTransition.kt$StartedFlowTransition$return freshErrorTransition(IllegalStateException("Tried to send to ended session $sourceSessionId")) MaxLineLength:StartedFlowTransition.kt$StartedFlowTransition$val initialMessage = createInitialSessionMessage(existingSessionState.initiatingSubFlow, sourceSessionId, existingSessionState.additionalEntropy, message) MaxLineLength:StartedFlowTransition.kt$StartedFlowTransition$val initialMessage = createInitialSessionMessage(sessionState.initiatingSubFlow, sourceSessionId, sessionState.additionalEntropy, null) - MaxLineLength:StartedFlowTransition.kt$StartedFlowTransition$val newBufferedMessages = existingSessionState.bufferedMessages + Pair(deduplicationId, sessionMessage) - MaxLineLength:Startup.kt$Startup$val cordaApp = node(nodeName).config.cordapps.apps.find { it.contains(cordapp) } ?: fail("Unable to locate CorDapp: $cordapp") - MaxLineLength:StartupSteps.kt$StartupSteps$Then - MaxLineLength:StateMachineManager.kt$StateMachineManager - MaxLineLength:StateMachineManager.kt$StateMachineManager$ fun deliverExternalEvent(event: ExternalEvent) - MaxLineLength:StateMachineManager.kt$StateMachineManager$ fun killFlow(id: StateMachineRunId): Boolean - MaxLineLength:StateMachineManagerUtils.kt$ //TODO: instead of replacing the progress tracker after constructing the flow logic, we should inject it during fiber deserialization fun StateMachineManagerInternal.injectOldProgressTracker(oldTracker: ProgressTracker?, newFlowLogic: FlowLogic<*>) MaxLineLength:StateMachineState.kt$StateMachineState - MaxLineLength:StateMachineState.kt$SubFlowVersion$CorDappFlow : SubFlowVersion - MaxLineLength:StatePointer.kt$LinearPointer$// Here either one of two things has happened: // 1. The pointed-to state has not been seen by the resolver node. It is unlikely that this is the case. // The state can probably be obtained via subscribing to the data distribution group which created and // and maintains this data. // 2. Uh oh... The pointed-to state has been exited from the ledger! // It is unlikely this would ever happen as most reference data states will be created such that they cannot // be exited from the ledger. At this point there are two options; use an old consumed version of the state, // or don't use it at all. "The LinearState with ID ${pointer.id} is unknown to this node or it has been exited from the ledger." - MaxLineLength:StatePointer.kt$LinearPointer<T : LinearState> : StatePointer - MaxLineLength:StatePointer.kt$StaticPointer<T : ContractState> : StatePointer - MaxLineLength:StateRevisionFlow.kt$StateRevisionFlow.Receiver$open MaxLineLength:StateRevisionFlow.kt$StateRevisionFlow.Requester$updatedData: T MaxLineLength:StateSummingUtilities.kt$ fun <P : Any> Iterable<ContractState>.sumObligations(): Amount<Issued<Obligation.Terms<P>>> MaxLineLength:StateSummingUtilities.kt$ fun <P : Any> Iterable<ContractState>.sumObligationsOrNull(): Amount<Issued<Obligation.Terms<P>>>? MaxLineLength:StateSummingUtilities.kt$ fun <P : Any> Iterable<ContractState>.sumObligationsOrZero(issuanceDef: Issued<Obligation.Terms<P>>): Amount<Issued<Obligation.Terms<P>>> - MaxLineLength:StateSummingUtilities.kt$ fun Iterable<ContractState>.sumCash(): Amount<Issued<Currency>> MaxLineLength:StateSummingUtilities.kt$ fun Iterable<ContractState>.sumCashBy(owner: AbstractParty): Amount<Issued<Currency>> - MaxLineLength:StateSummingUtilities.kt$ fun Iterable<ContractState>.sumCashOrNull(): Amount<Issued<Currency>>? - MaxLineLength:StaticConstantRemover.kt$StaticConstantRemover$isConstantField(member) -> member.copy(body = listOf(StringFieldInitializer(member)::writeInitializer), value = null) - MaxLineLength:StaticConstantRemover.kt$StaticConstantRemover$private fun isConstantField(member: Member): Boolean - MaxLineLength:StaticConstantRemover.kt$StaticConstantRemover.StringFieldInitializer$invokeStatic("sandbox/java/lang/String", "toDJVM", "(Ljava/lang/String;)Lsandbox/java/lang/String;", false) - MaxLineLength:StaticInitialisationOfSerializedObjectTest.kt$StaticInitialisationOfSerializedObjectTest$val url = EvolvabilityTests::class.java.getResource("StaticInitialisationOfSerializedObjectTest.deserializeTest") - MaxLineLength:StaticInitialisationOfSerializedObjectTest.kt$StaticInitialisationOfSerializedObjectTest$val url = EvolvabilityTests::class.java.getResource("StaticInitialisationOfSerializedObjectTest.deserializeTest2") - MaxLineLength:StatusTransitions.kt$StatusTransitions$?: - MaxLineLength:StatusTransitions.kt$StatusTransitions$if (options.isEmpty()) throw IllegalStateException("Transition [$input -(${command.javaClass.simpleName})-> $output] not allowed") - MaxLineLength:StatusTransitions.kt$StatusTransitions$private vararg val ts: TransitionDef<S, R> - MaxLineLength:StatusTransitions.kt$StatusTransitions$require(relevantCmds.isNotEmpty()) { "Transaction must have at least one Command relevant to its defined transitions" } - MaxLineLength:StatusTransitions.kt$StatusTransitions${ // which state determines who is the signer? by default the input, unless it's the initial transition val state = (inp ?: outp)!! val signerParty = state.roleToParty(signer) if (!cmd.signers.contains(signerParty.owningKey)) throw IllegalStateException("Command ${cmd.value.javaClass} must be signed by $signer") } - MaxLineLength:StatusTransitions.kt$StatusTransitions<out S, in R, T : StatusTrackingContractState<S, R>> - MaxLineLength:StatusTransitions.kt$TransitionDef<out S, out R> - MaxLineLength:StepsContainer.kt$StepsContainer.Companion$ClassGraph() .addClassLoader(this::class.java.classLoader) .enableAllInfo() .pooledScan() .use { it.getClassesImplementing(StepsProvider::class.java.name).loadClasses(StepsProvider::class.java) } - MaxLineLength:StringConstantWrapper.kt$StringConstantWrapper$invokeStatic("sandbox/java/lang/String", "toDJVM", "(Ljava/lang/String;)Lsandbox/java/lang/String;", false) - MaxLineLength:StringToMethodCallParser.kt$StringToMethodCallParser$/** A map of method name to parameter names for the target type. */ val methodParamNames: Map<String, List<String>> = targetType.declaredMethods.filterNot(Method::isSynthetic).mapNotNull { try { it.name to paramNamesFromMethod(it) } catch (e: KotlinReflectionInternalError) { // Kotlin reflection doesn't support every method that can exist on an object (in particular, reified // inline methods) so we just ignore those here. null } }.toMap() - MaxLineLength:StringToMethodCallParser.kt$StringToMethodCallParser$kf != null -> kf.parameters[index + 1].name ?: throw UnparseableCallException.ReflectionDataMissing(method.name, index) - MaxLineLength:StringToMethodCallParser.kt$StringToMethodCallParser$kf != null -> kf.parameters[index].name ?: throw UnparseableCallException.ReflectionDataMissing("<init>", index) - MaxLineLength:StringToMethodCallParser.kt$StringToMethodCallParser$when { param.isNamePresent -> param.name // index + 1 because the first Kotlin reflection param is 'this', but that doesn't match Java reflection. kf != null -> kf.parameters[index + 1].name ?: throw UnparseableCallException.ReflectionDataMissing(method.name, index) else -> throw UnparseableCallException.ReflectionDataMissing(method.name, index) } - MaxLineLength:StringToMethodCallParser.kt$StringToMethodCallParser.Companion$for ((key, value) in clazz.methods.filterNot { it.isSynthetic && it.name !in ignoredNames }.map { it.name to it }) { result.put(key, value) } MaxLineLength:StringToMethodCallParser.kt$StringToMethodCallParser.UnparseableCallException$MissingParameter : UnparseableCallException MaxLineLength:StringToMethodCallParser.kt$StringToMethodCallParser.UnparseableCallException$ReflectionDataMissing : UnparseableCallException MaxLineLength:StringToMethodCallParser.kt$StringToMethodCallParser.UnparseableCallException$TooManyParameters : UnparseableCallException MaxLineLength:StringToMethodCallParser.kt$StringToMethodCallParser.UnparseableCallException$open - MaxLineLength:StringToMethodCallParser.kt$StringToMethodCallParser<in T : Any> MaxLineLength:StringToMethodCallParserTest.kt$StringToMethodCallParserTest$"twoStrings a: Some words, b: ' and some words, like, Kirk, would, speak'" to "Some words and some words, like, Kirk, would, speak" - MaxLineLength:StringToMethodCallParserTest.kt$StringToMethodCallParserTest$val args: Array<Any?> = parser.parseArguments(clazz.name, names.zip(ctor.parameterTypes), "alternativeWord: Foo bar!") MaxLineLength:StringToMethodCallParserTest.kt$StringToMethodCallParserTest$val args: Array<Any?> = parser.parseArguments(clazz.name, names.zip(ctor.parameterTypes), "someWord: Blah blah blah, aDifferentThing: 12") - MaxLineLength:Structures.kt$Command$private fun commandDataToString() MaxLineLength:Structures.kt$CommandWithParties$@Deprecated("Should not be used in contract verification code as it is non-deterministic, will be disabled for some future target platform version onwards and will take effect only for CorDapps targeting those versions.") - MaxLineLength:Structures.kt$Contract - MaxLineLength:Structures.kt$Issued$require(issuer.reference.size <= MAX_ISSUER_REF_SIZE) { "Maximum issuer reference size is $MAX_ISSUER_REF_SIZE." } - MaxLineLength:Structures.kt$OwnableState$ fun withNewOwner(newOwner: AbstractParty): CommandAndState - MaxLineLength:Structures.kt$PrivacySalt : OpaqueBytes - MaxLineLength:Structures.kt$SchedulableState$ @DeleteForDJVM fun nextScheduledActivity(thisStateRef: StateRef, flowLogicRefFactory: FlowLogicRefFactory): ScheduledActivity? - MaxLineLength:Structures.kt$UpgradedContract<in OldState : ContractState, out NewState : ContractState> : Contract MaxLineLength:Structures.kt$UpgradedContractWithLegacyConstraint<in OldState : ContractState, out NewState : ContractState> : UpgradedContract MaxLineLength:Structures.kt$return mapNotNull { if (it.state.data is T) StateAndRef(TransactionState(it.state.data, it.state.contract, it.state.notary), it.ref) else null } - MaxLineLength:StubOutNativeMethods.kt$StubOutNativeMethods$private fun isForStubbing(member: Member): Boolean - MaxLineLength:StubOutReflectionMethods.kt$StubOutReflectionMethods$private - MaxLineLength:SubFlow.kt$SubFlow.Companion$Try.Success(Initiating(flowClass, initiatingAnnotation.first, flowContext, subFlowVersion, isEnabledTimedFlow)) - MaxLineLength:SubFlow.kt$SubFlow.Companion$fun create(flowClass: Class<FlowLogic<*>>, subFlowVersion: SubFlowVersion, isEnabledTimedFlow: Boolean): Try<SubFlow> - MaxLineLength:SubFlow.kt$SubFlow.Companion$private MaxLineLength:SubFlow.kt$SubFlow.Inlined$data - MaxLineLength:SupportedTransforms.kt$SupportedTransform MaxLineLength:SwapData.kt$FixedLeg$data MaxLineLength:SwapData.kt$FloatingLeg$data MaxLineLength:SwapData.kt$SwapData$return getSwapConvention(convention).createTrade(startDate, Tenor.TENOR_4Y, buySell, notional.toDouble(), fixedRate.toDouble(), ReferenceData.standard()) .toBuilder() .info(tradeInfo) .build() MaxLineLength:SwapDataModel.kt$SwapDataModel$Pair("swap", id) - MaxLineLength:SwapExample.kt$SwapExample$val resolvedTrades = trades.stream().map({ trade -> trade.resolve(ReferenceData.standard()) }).collect(toList<ResolvedSwapTrade>()) - MaxLineLength:SwapExample.kt$SwapExample$val resolvedTrades = trades1.stream().map({ trade -> trade.resolve(ReferenceData.standard()) }).collect(toList<ResolvedSwapTrade>()) - MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesException : FlowException - MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesFlow : FlowLogic - MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesFlow$@Deprecated("It is unsafe to use this constructor as it requires nodes to automatically vend anonymous identities without first " + "checking if they should. Instead, use the constructor that takes in an existing FlowSession.") - MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesFlow$@Deprecated("It is unsafe to use this constructor as it requires nodes to automatically vend anonymous identities without first " + "checking if they should. Instead, use the constructor that takes in an existing FlowSession.") constructor(otherParty: Party, revocationEnabled: Boolean, progressTracker: ProgressTracker) : this(null, otherParty, progressTracker) - MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesFlow$@JvmOverloads constructor(otherSideSession: FlowSession, progressTracker: ProgressTracker = tracker()) : this(otherSideSession, null, progressTracker) - MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesFlow$logger - MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesFlow$val theirAnonymousIdentity = session.sendAndReceive<IdentityWithSignature>(ourIdentWithSig).unwrap { theirIdentWithSig -> progressTracker.currentStep = VERIFYING_IDENTITY validateAndRegisterIdentity(serviceHub, session.counterparty, theirIdentWithSig.identity.deserialize(), theirIdentWithSig.signature) } MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesFlow$validateAndRegisterIdentity(serviceHub, session.counterparty, theirIdentWithSig.identity.deserialize(), theirIdentWithSig.signature) - MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesFlow.Companion$@JvmStatic fun tracker(): ProgressTracker - MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesFlow.Companion${ if (theirAnonymousIdentity.name != otherSide.name) { throw SwapIdentitiesException("Certificate subject must match counterparty's well known identity.") } try { theirAnonymousIdentity.owningKey.verify(buildDataToSign(theirAnonymousIdentity), signature) } catch (ex: SignatureException) { throw SwapIdentitiesException("Signature does not match the expected identity ownership assertion.", ex) } // Validate then store their identity so that we can prove the key in the transaction is owned by the counterparty. serviceHub.identityService.verifyAndRegisterIdentity(theirAnonymousIdentity) return theirAnonymousIdentity } - MaxLineLength:SwapIdentitiesFlow.kt$SwapIdentitiesFlow.IdentityWithSignature$@CordaSerializable data - MaxLineLength:SwapIdentitiesFlowTests.kt$SwapIdentitiesFlowTests$private - MaxLineLength:SwapIdentitiesFlowTests.kt$SwapIdentitiesFlowTests.<no name provided>$ is resolved by - MaxLineLength:SwapIdentitiesFlowTests.kt$SwapIdentitiesFlowTests.HoldsOwningKeyMatcher$private data - MaxLineLength:SwapIdentitiesHandler.kt$SwapIdentitiesHandler : FlowLogic MaxLineLength:SwapIdentitiesHandler.kt$SwapIdentitiesHandler$logger.warnOnce("Insecure API to swap anonymous identities was used by ${otherSide.counterparty} (${otherSide.getCounterpartyFlowInfo()})") - MaxLineLength:Swaption.kt$Swaption$val floating = interest(notional, "act/365", fix("LIBOR", start, Tenor("3M")), start, end) - MaxLineLength:TLSAuthenticationTests.kt$TLSAuthenticationTests - MaxLineLength:TLSAuthenticationTests.kt$TLSAuthenticationTests$arrayOf("TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256") - MaxLineLength:TLSAuthenticationTests.kt$TLSAuthenticationTests$arrayOf("TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256") - MaxLineLength:TLSAuthenticationTests.kt$TLSAuthenticationTests$clientParams.endpointIdentificationAlgorithm = null - MaxLineLength:TLSAuthenticationTests.kt$TLSAuthenticationTests$private - MaxLineLength:TLSAuthenticationTests.kt$TLSAuthenticationTests$serverParams.endpointIdentificationAlgorithm = null MaxLineLength:TLSAuthenticationTests.kt$TLSAuthenticationTests$serverParams.needClientAuth = true - MaxLineLength:TLSAuthenticationTests.kt$TLSAuthenticationTests$testConnect(serverSocket, clientSocket, "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256") - MaxLineLength:TLSAuthenticationTests.kt$TLSAuthenticationTests$testConnect(serverSocket, clientSocket, "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256") - MaxLineLength:TLSAuthenticationTests.kt$TLSAuthenticationTests$val serverSocket = serverSocketFactory.createServerSocket(serverPort) as SSLServerSocket // use 0 to get first free socket. - MaxLineLength:TenorDateParameterMetadataSerializer.kt$TenorDateParameterMetadataSerializer$override fun fromProxy(proxy: Proxy): TenorDateParameterMetadata - MaxLineLength:TestBase.kt$TestBase.Companion$System.getProperty("deterministic-rt.path") ?: throw AssertionError("deterministic-rt.path property not set") - MaxLineLength:TestClock.kt$TestClock$ @Synchronized fun setTo(newInstant: Instant) MaxLineLength:TestCommonUtils.kt$inline fun <reified TYPE : Throwable> AbstractThrowableAssert<*, *>.isInstanceOf(): AbstractThrowableAssert<*, *> - MaxLineLength:TestCommsFlow.kt$TestCommsFlowInitiator$tx.addOutputState(CommsTestState(responses, serviceHub.myInfo.legalIdentities.first()), CommsTestContract::class.java.name) MaxLineLength:TestConstants.kt$ fun dummyCommand(vararg signers: PublicKey = arrayOf(generateKeyPair().public)) - MaxLineLength:TestCordapp.kt$TestCordapp - MaxLineLength:TestCordapp.kt$TestCordapp.Companion$ @JvmStatic fun findCordapp(scanPackage: String): TestCordapp MaxLineLength:TestCordappImpl.kt$TestCordappImpl : TestCordappInternal MaxLineLength:TestCordappImpl.kt$TestCordappImpl$0 MaxLineLength:TestCordappImpl.kt$TestCordappImpl$else -> throw IllegalArgumentException("There is more than one CorDapp containing the package $scanPackage on the classpath " + "$jars. Specify a package name which is unique to the CorDapp.") - MaxLineLength:TestCordappImpl.kt$TestCordappImpl.Companion$val jars = libs.list { it.filter { it.toString().endsWith(".jar") }.toList() }.sortedBy { it.attributes().creationTime() } MaxLineLength:TestCordappInternal.kt$TestCordappInternal : TestCordapp - MaxLineLength:TestCordappInternal.kt$TestCordappInternal.Companion$cordappsWithoutMeta.forEach { require(it.value.size == 1) { "Conflicting CorDapps specified: ${it.value}" } } - MaxLineLength:TestCordappInternal.kt$TestCordappInternal.Companion$val allCordapps = nodeSpecificCordapps + generalCordapps.filter { it.withOnlyJarContents() !in nodeSpecificCordappsWithoutMeta } - MaxLineLength:TestCordappInternal.kt$TestCordappInternal.Companion${ // Ignore if the node already has the same CorDapp jar. This can happen if the node is being restarted. } - MaxLineLength:TestDSL.kt$AttachmentResolutionException : FlowException - MaxLineLength:TestDSL.kt$DoubleSpentInputs : FlowException - MaxLineLength:TestDSL.kt$TestLedgerDSLInterpreter$( transactionLabel: String?, transactionBuilder: TransactionBuilder, dsl: TestTransactionDSLInterpreter.() -> Unit ) - MaxLineLength:TestDSL.kt$TestLedgerDSLInterpreter$throw IllegalStateException("A transaction-DSL block that is part of a test ledger must return a valid transaction.", e) - MaxLineLength:TestDSL.kt$TestLedgerDSLInterpreter$val transactionsUnverified: List<WireTransaction> get() = nonVerifiedTransactionWithLocations.values.map { it.transaction } MaxLineLength:TestDSL.kt$TestTransactionDSLInterpreter$attachment((services.cordappProvider as MockCordappProvider).addMockCordapp(contractClassName, services.attachments as MockAttachmentStorage)) MaxLineLength:TestDSL.kt$TestTransactionDSLInterpreter$attachment((services.cordappProvider as MockCordappProvider).addMockCordapp(contractClassName, services.attachments as MockAttachmentStorage, attachmentId, signers)) MaxLineLength:TestDSL.kt$TestTransactionDSLInterpreter$attachment((services.cordappProvider as MockCordappProvider).addMockCordapp(contractClassName, services.attachments as MockAttachmentStorage, attachmentId, signers, jarManifestAttributes)) MaxLineLength:TestDSL.kt$TestTransactionDSLInterpreter$override - MaxLineLength:TestDSL.kt$net.corda.testing.dsl.TestDSL.kt - MaxLineLength:TestNoSecurityDataVendingFlow.kt$TestNoSecurityDataVendingFlow : DataVendingFlow - MaxLineLength:TestNoSecurityDataVendingFlow.kt$TestNoSecurityDataVendingFlow$@Suspendable override MaxLineLength:TestNodeInfoBuilder.kt$TestNodeInfoBuilder MaxLineLength:TestNodeInfoBuilder.kt$TestNodeInfoBuilder$fun addServiceIdentity(name: CordaX500Name, nodeKeyPair: KeyPair = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME)): Pair<PartyAndCertificate, PrivateKey> - MaxLineLength:TestNodeInfoBuilder.kt$TestNodeInfoBuilder$listOf(NetworkHostAndPort("my.${identitiesAndPrivateKeys[0].first.party.name.organisation.replace(' ', '-')}.com", 1234)) - MaxLineLength:TestNodeInfoBuilder.kt$fun createNodeInfoAndSigned(vararg names: CordaX500Name, serial: Long = 1, platformVersion: Int = 1): NodeInfoAndSigned - MaxLineLength:TestNotaryFlow.kt$TestNotaryFlow$issueBuilder.addOutputState(NotaryTestState(notary.name.toString(), myIdentity), NotaryTestContract::class.java.name) - MaxLineLength:TestResponseFlowInIsolation.kt$TestResponseFlowInIsolation$private val network: MockNetwork = MockNetwork(MockNetworkParameters(cordappsForAllNodes = cordappsForPackages("com.template"))) - MaxLineLength:TestResponseFlowInIsolation.kt$TestResponseFlowInIsolation$val initiatedResponderFlowFuture = b.registerInitiatedFlow(BadInitiator::class.java, Responder::class.java).toFuture() - MaxLineLength:TestUtils.kt$@Deprecated("Returned port is not guaranteed to be free when used, which can result in flaky tests. Instead use a port " + "range that's unlikely to be used by the rest of the system, such as PortAllocation.Incremental(10000).") - MaxLineLength:TestUtils.kt$TestIdentity$@JvmOverloads - MaxLineLength:TestUtils.kt$TestIdentity.Companion$ @JvmStatic @JvmOverloads fun fresh(organisation: String, signatureScheme: SignatureScheme = Crypto.DEFAULT_SIGNATURE_SCHEME): TestIdentity - MaxLineLength:TestUtils.kt$internal fun <VALUE> extractValueWithErrors(errors: Set<Configuration.Validation.Error>) - MaxLineLength:TestUtils.kt$net.corda.testing.core.TestUtils.kt MaxLineLength:TestingNamedCacheFactory.kt$TestingNamedCacheFactory : BindableNamedCacheFactorySingletonSerializeAsToken - MaxLineLength:TestingNamedCacheFactory.kt$TestingNamedCacheFactory$override MaxLineLength:TestingNamedCacheFactory.kt$TestingNamedCacheFactory$override fun bindWithConfig(nodeConfiguration: NodeConfiguration): BindableNamedCacheFactory MaxLineLength:TestingNamedCacheFactory.kt$TestingNamedCacheFactory$override fun bindWithMetrics(metricRegistry: MetricRegistry): BindableNamedCacheFactory MaxLineLength:ThreadContextAdjustingRpcOpsProxy.kt$ThreadContextAdjustingRpcOpsProxy : CordaRPCOps MaxLineLength:ThreadContextAdjustingRpcOpsProxy.kt$ThreadContextAdjustingRpcOpsProxy$internal - MaxLineLength:ThreadContextAdjustingRpcOpsProxy.kt$ThreadContextAdjustingRpcOpsProxy.Companion$return Proxy.newProxyInstance(delegate::class.java.classLoader, arrayOf(CordaRPCOps::class.java), handler) as CordaRPCOps - MaxLineLength:ThreadContextAdjustingRpcOpsProxy.kt$ThreadContextAdjustingRpcOpsProxy.Companion$val handler = ThreadContextAdjustingRpcOpsProxy.ThreadContextAdjustingInvocationHandler(delegate, classLoader) MaxLineLength:ThreadContextAdjustingRpcOpsProxy.kt$ThreadContextAdjustingRpcOpsProxy.ThreadContextAdjustingInvocationHandler$private - MaxLineLength:ThrowExceptionWrapper.kt$ThrowExceptionWrapper$invokeStatic("sandbox/java/lang/DJVM", "fromDJVM", "(Lsandbox/java/lang/Throwable;)Ljava/lang/Throwable;") MaxLineLength:ThrowableSerializer.kt$StackTraceElementSerializer : Proxy MaxLineLength:ThrowableSerializer.kt$StackTraceElementSerializer$override fun fromProxy(proxy: StackTraceElementProxy): StackTraceElement MaxLineLength:ThrowableSerializer.kt$StackTraceElementSerializer$override fun toProxy(obj: StackTraceElement): StackTraceElementProxy - MaxLineLength:ThrowableSerializer.kt$StackTraceElementSerializer.StackTraceElementProxy$@KeepForDJVM data MaxLineLength:ThrowableSerializer.kt$ThrowableSerializer : Proxy - MaxLineLength:ThrowableSerializer.kt$ThrowableSerializer$if (this.javaClass.name != proxy.exceptionClass) this.originalExceptionClassName = proxy.exceptionClass - MaxLineLength:ThrowableSerializer.kt$ThrowableSerializer$logger.warn("Unexpected exception de-serializing throwable: ${proxy.exceptionClass}. Converting to CordaRuntimeException.", e) - MaxLineLength:ThrowableSerializer.kt$ThrowableSerializer$override val additionalSerializers: Iterable<CustomSerializer<out Any>> = listOf(StackTraceElementSerializer(factory)) - MaxLineLength:ThrowableSerializer.kt$ThrowableSerializer$return ThrowableProxy(obj.javaClass.name, message, stackTraceToInclude, obj.cause, obj.suppressed, extraProperties) MaxLineLength:ThrowableSerializer.kt$ThrowableSerializer${ try { // TODO: This will need reworking when we have multiple class loaders val clazz = Class.forName(proxy.exceptionClass, false, factory.classloader) // If it is CordaException or CordaRuntimeException, we can seek any constructor and then set the properties // Otherwise we just make a CordaRuntimeException if (CordaThrowable::class.java.isAssignableFrom(clazz) && Throwable::class.java.isAssignableFrom(clazz)) { val typeInformation = factory.getTypeInformation(clazz) val constructor = typeInformation.constructor val params = constructor.parameters.map { parameter -> proxy.additionalProperties[parameter.name] ?: proxy.additionalProperties[parameter.name.capitalize()] } val throwable = constructor.observedMethod.newInstance(*params.toTypedArray()) (throwable as CordaThrowable).apply { if (this.javaClass.name != proxy.exceptionClass) this.originalExceptionClassName = proxy.exceptionClass this.setMessage(proxy.message) this.setCause(proxy.cause) this.addSuppressed(proxy.suppressed) } return (throwable as Throwable).apply { this.stackTrace = proxy.stackTrace } } } catch (e: Exception) { logger.warn("Unexpected exception de-serializing throwable: ${proxy.exceptionClass}. Converting to CordaRuntimeException.", e) } // If the criteria are not met or we experience an exception constructing the exception, we fall back to our own unchecked exception. return CordaRuntimeException(proxy.exceptionClass, null, null).apply { this.setMessage(proxy.message) this.setCause(proxy.cause) this.stackTrace = proxy.stackTrace this.addSuppressed(proxy.suppressed) } } - MaxLineLength:TimeWindow.kt$TimeWindow.Companion$ @JvmStatic fun fromOnly(fromTime: Instant): TimeWindow - MaxLineLength:TimeWindow.kt$TimeWindow.Companion$ @JvmStatic fun fromStartAndDuration(fromTime: Instant, duration: Duration): TimeWindow - MaxLineLength:TimeWindow.kt$TimeWindow.Companion$ @JvmStatic fun untilOnly(untilTime: Instant): TimeWindow - MaxLineLength:TimedFlowTests.kt$TimedFlowTests$TestNotaryService : SinglePartyNotaryService MaxLineLength:TimedFlowTests.kt$TimedFlowTests$addOutputState(DummyContract.SingleOwnerState(owner = info.singleIdentity()), DummyContract.PROGRAM_ID, AlwaysAcceptAttachmentConstraint) - MaxLineLength:TimedFlowTests.kt$TimedFlowTests$private - MaxLineLength:TimedFlowTests.kt$TimedFlowTests.Companion$/** The notary nodes don't run any consensus protocol, so 2 nodes are sufficient for the purpose of this test. */ private const val CLUSTER_SIZE = 2 MaxLineLength:TimedFlowTests.kt$TimedFlowTests.Companion$defaultParameters = MockNetworkParameters().withServicePeerAllocationStrategy(InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin()) - MaxLineLength:TimedFlowTests.kt$TimedFlowTests.Companion$val networkParameters = NetworkParametersCopier(testNetworkParameters(listOf(NotaryInfo(notaryIdentity, false)))) - MaxLineLength:TimedFlowTests.kt$TimedFlowTests.Companion${ val replicaIds = (0 until CLUSTER_SIZE) val serviceLegalName = CordaX500Name("Custom Notary", "Zurich", "CH") val notaryIdentity = DevIdentityGenerator.generateDistributedNotaryCompositeIdentity( replicaIds.map { mockNet.baseDirectory(mockNet.nextNodeId + it) }, serviceLegalName) val networkParameters = NetworkParametersCopier(testNetworkParameters(listOf(NotaryInfo(notaryIdentity, false)))) val notaryConfig = mock<NotaryConfig> { whenever(it.serviceLegalName).thenReturn(serviceLegalName) whenever(it.validating).thenReturn(false) whenever(it.className).thenReturn(TestNotaryService::class.java.name) } val notaryNodes = (0 until CLUSTER_SIZE).map { mockNet.createUnstartedNode(InternalMockNodeParameters(configOverrides = { doReturn(notaryConfig).whenever(it).notary })) } val aliceNode = mockNet.createUnstartedNode( InternalMockNodeParameters( legalName = CordaX500Name("Alice", "AliceCorp", "GB"), configOverrides = { conf: NodeConfiguration -> val retryConfig = FlowTimeoutConfiguration(1.seconds, 3, 1.0) doReturn(retryConfig).whenever(conf).flowTimeout } ) ) val patientNode = mockNet.createUnstartedNode( InternalMockNodeParameters( legalName = CordaX500Name("Bob", "BobCorp", "GB"), configOverrides = { conf: NodeConfiguration -> val retryConfig = FlowTimeoutConfiguration(10.seconds, 3, 1.0) doReturn(retryConfig).whenever(conf).flowTimeout } ) ) // MockNetwork doesn't support notary clusters, so we create all the nodes we need unstarted, and then install the // network-parameters in their directories before they're started. val nodes = (notaryNodes + aliceNode + patientNode).map { node -> networkParameters.install(mockNet.baseDirectory(node.id)) node.start() } return Triple(notaryIdentity, nodes[nodes.lastIndex - 1], nodes.last()) } MaxLineLength:TimedFlowTests.kt$TimedFlowTests.TestNotaryService$@Suspendable override MaxLineLength:TimedFlowTests.kt$TimedFlowTests.TestNotaryService$override fun createServiceFlow(otherPartySession: FlowSession): FlowLogic<Void?> MaxLineLength:TimedFlowTests.kt$TimedFlowTests.TestNotaryService$private MaxLineLength:TimedFlowTests.kt$TimedFlowTests.TestNotaryService.<no name provided>$override - MaxLineLength:TimedFlowUtils.kt$ internal fun FlowLogic<*>.isEnabledTimedFlow(): Boolean MaxLineLength:ToggleField.kt$InheritableThreadLocalToggleField$private val isAGlobalThreadBeingCreated: (Array<StackTraceElement>) -> Boolean - MaxLineLength:ToggleField.kt$InheritableThreadLocalToggleField.<no name provided>$override MaxLineLength:ToggleField.kt$ThreadLeakException : RuntimeException - MaxLineLength:ToggleFieldTest.kt$ToggleFieldTest$// If ThreadLeakException is seen in practice, these warnings form a trail of where the holder has been: verify(log).warn(argThat { contains(leakedThreadName) && contains("hello") }) val newThreadName = fork { Thread.currentThread().name }.getOrThrow() val future = fork(field::get) assertThatThrownBy { future.getOrThrow() } .isInstanceOf(ThreadLeakException::class.java) .hasMessageContaining(newThreadName) .hasMessageContaining("hello") fork { verifyNoMoreInteractions(log) withSingleThreadExecutor { verify(log).warn(argThat { contains(newThreadName) && contains("hello") }) } }.getOrThrow() - MaxLineLength:ToggleFieldTest.kt$ToggleFieldTest$isAGlobalThreadBeingCreated || (e.className == companionName && e.methodName == "globalThreadCreationMethod") MaxLineLength:ToggleFieldTest.kt$ToggleFieldTest$listOf(SimpleToggleField<String>("simple"), ThreadLocalToggleField<String>("local"), inheritableThreadLocalToggleField()) - MaxLineLength:ToggleFieldTest.kt$ToggleFieldTest$private - MaxLineLength:TopLevelTransition.kt$TopLevelTransition$Action.PersistCheckpoint(context.id, newCheckpoint, isCheckpointUpdate = currentState.isAnyCheckpointPersisted) - MaxLineLength:TopLevelTransition.kt$TopLevelTransition$Action.RemoveFlow(context.id, FlowRemovalReason.OrderlyFinish(event.returnValue), currentState) - MaxLineLength:TopLevelTransition.kt$TopLevelTransition$Action.SendExisting(state.peerParty, message, SenderDeduplicationId(deduplicationId, currentState.senderUUID)) MaxLineLength:TopLevelTransition.kt$TopLevelTransition$freshErrorTransition(IllegalStateException("Tried to initiate in a flow not annotated with @${InitiatingFlow::class.java.simpleName}")) - MaxLineLength:TopLevelTransition.kt$TopLevelTransition$is Event.DeliverSessionMessage -> DeliverSessionMessageTransition(context, startingState, event).transition() MaxLineLength:TopLevelTransition.kt$TopLevelTransition$val newSessions = checkpoint.sessions + (sourceSessionId to SessionState.Uninitiated(event.party, initiatingSubFlow, sourceSessionId, context.secureRandom.nextLong())) - MaxLineLength:TopologicalSort.kt$ fun Observable<SignedTransaction>.topologicalSort(initialUnspentRefs: Collection<StateRef>): Observable<SignedTransaction> MaxLineLength:TopologicalSortTest.kt$TopologicalSortTest$val backGraph = forwardGraph.flatMap { it.second.map { output -> it.first to output } }.fold(HashMap<SecureHash, HashSet<SecureHash>>()) { backGraph, edge -> backGraph.getOrPut(edge.second) { HashSet() }.add(edge.first) backGraph } MaxLineLength:TopologicalSortTest.kt$TopologicalSortTest$val sig = TransactionSignature(testIdentity.keyPair.private.sign(bits).bytes, testIdentity.publicKey, SignatureMetadata(0, 0)) MaxLineLength:Trace.kt$Trace.Companion$ @DeleteForDJVM @JvmStatic fun newInstance(invocationId: InvocationId = InvocationId.newInstance(), sessionId: SessionId = SessionId(invocationId.value, invocationId.timestamp)) MaxLineLength:Trace.kt$Trace.InvocationId.Companion$ @DeleteForDJVM @JvmStatic fun newInstance(value: String = UuidGenerator.next().toString(), timestamp: Instant = Instant.now()) MaxLineLength:Trace.kt$Trace.SessionId.Companion$ @DeleteForDJVM @JvmStatic fun newInstance(value: String = UuidGenerator.next().toString(), timestamp: Instant = Instant.now()) - MaxLineLength:TrackedDelegate.kt$TrackedDelegate$EventSinkDelegate<M : Any, T> : TrackedDelegate - MaxLineLength:TrackedDelegate.kt$TrackedDelegate$EventStreamDelegate<M : Any, T> : TrackedDelegate MaxLineLength:TrackedDelegate.kt$TrackedDelegate$ObjectPropertyDelegate<M : Any, T> : TrackedDelegate - MaxLineLength:TrackedDelegate.kt$TrackedDelegate$ObservableDelegate<M : Any, T> : TrackedDelegate MaxLineLength:TrackedDelegate.kt$TrackedDelegate$ObservableListDelegate<M : Any, T> : TrackedDelegate MaxLineLength:TrackedDelegate.kt$TrackedDelegate$ObservableListReadOnlyDelegate<M : Any, out T> : TrackedDelegate MaxLineLength:TrackedDelegate.kt$TrackedDelegate$ObservableValueDelegate<M : Any, T> : TrackedDelegate - MaxLineLength:TrackedDelegate.kt$TrackedDelegate$ObserverDelegate<M : Any, T> : TrackedDelegate - MaxLineLength:TrackedDelegate.kt$TrackedDelegate$SubjectDelegate<M : Any, T> : TrackedDelegate MaxLineLength:TrackedDelegate.kt$TrackedDelegate$WritableValueDelegate<M : Any, T> : TrackedDelegate - MaxLineLength:TraderDemoClientApi.kt$TraderDemoClientApi$println("Sale completed - we have a happy customer!\n\nFinal transaction is:\n\n${Emoji.renderIfSupported(stx.tx)}") - MaxLineLength:TraderDemoClientApi.kt$TraderDemoClientApi$val otherParty = rpc.wellKnownPartyFromX500Name(buyerName) ?: throw IllegalStateException("Don't know $buyerName") - MaxLineLength:TraderDemoTest.kt$TraderDemoTest$TraderDemoClientApi(bank.rpc).runIssuer(amount = 100.DOLLARS, buyerName = DUMMY_BANK_A_NAME, sellerName = DUMMY_BANK_B_NAME) MaxLineLength:TraderDemoTest.kt$TraderDemoTest$clientBank.runIssuer(amount = 100.DOLLARS, buyerName = nodeA.services.myInfo.singleIdentity().name, sellerName = nodeB.services.myInfo.singleIdentity().name) MaxLineLength:TraderDemoTest.kt$TraderDemoTest$val buyer2 = startNode(providedName = DUMMY_BANK_A_NAME, customOverrides = mapOf("p2pAddress" to buyer.p2pAddress.toString())).getOrThrow() MaxLineLength:TransactionBuilder.kt$TransactionBuilder$ @Throws(MissingContractAttachments::class) fun toWireTransaction(services: ServicesForResolution): WireTransaction - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$ Please contact the developer of the CorDapp and install the latest version, as this approach might be insecure. - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$ fun setTimeWindow(time: Instant, timeTolerance: Duration) MaxLineLength:TransactionBuilder.kt$TransactionBuilder$ private fun attachmentConstraintsTransition(constraints: Set<AttachmentConstraint>, attachmentToUse: ContractAttachment): AttachmentConstraint MaxLineLength:TransactionBuilder.kt$TransactionBuilder$ private fun handleContract( contractClassName: ContractClassName, inputStates: List<TransactionState<ContractState>>?, inputStateRefs: Set<StateRef>?, outputStates: List<TransactionState<ContractState>>?, explicitContractAttachment: AttachmentId?, services: ServicesForResolution ): Pair<AttachmentId, List<TransactionState<ContractState>>?> MaxLineLength:TransactionBuilder.kt$TransactionBuilder$ private fun selectAttachmentConstraint( contractClassName: ContractClassName, inputStates: List<TransactionState<ContractState>>?, attachmentToUse: ContractAttachment, services: ServicesForResolution): AttachmentConstraint @@ -8888,20 +4865,12 @@ MaxLineLength:TransactionBuilder.kt$TransactionBuilder$"An attachment has been explicitly set for contract $contractClassName in the transaction builder which conflicts with the HashConstraint of a state." MaxLineLength:TransactionBuilder.kt$TransactionBuilder$"Transaction was built with $contractClassName states with multiple HashConstraints. This is illegal, because it makes it impossible to validate with a single version of the contract code." MaxLineLength:TransactionBuilder.kt$TransactionBuilder$(allContractAttachments + attachments).toSortedSet().toList() - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$?: - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$@BelongsToContract, and does not have an enclosing class which implements Contract. Either annotate MaxLineLength:TransactionBuilder.kt$TransactionBuilder$@CordaInternal internal - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$@Throws(AttachmentResolutionException::class, TransactionResolutionException::class, TransactionVerificationException::class) MaxLineLength:TransactionBuilder.kt$TransactionBuilder$attachmentToUse.signerKeys.isEmpty() -> throw IllegalArgumentException("Cannot mix a state with the WhitelistedByZoneAttachmentConstraint and a state with the SignatureAttachmentConstraint, when the latest attachment is not signed. Please contact your Zone operator.") - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$constraints.any { it is SignatureAttachmentConstraint } && constraints.any { it is WhitelistedByZoneAttachmentConstraint } MaxLineLength:TransactionBuilder.kt$TransactionBuilder$else -> throw IllegalArgumentException("Attempting to transition a WhitelistedByZoneAttachmentConstraint state backed by an attachment signed by multiple parties to a weaker SignatureConstraint that does not require all those signatures. Please contact your Zone operator.") MaxLineLength:TransactionBuilder.kt$TransactionBuilder$handleContract(ctr, inputContractGroups[ctr], contractClassNameToInputStateRef[ctr], outputContractGroups[ctr], explicitAttachmentContractsMap[ctr], services) - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$if (attachment == null || attachment !is ContractAttachment || !isUploaderTrusted(attachment.uploader)) { // This should never happen because these are input states that should have been validated already. throw MissingContractAttachments(listOf(state)) } - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$inputStates != null -> attachmentConstraintsTransition(inputStates.groupBy { it.constraint }.keys, attachmentToUse) MaxLineLength:TransactionBuilder.kt$TransactionBuilder$internal MaxLineLength:TransactionBuilder.kt$TransactionBuilder$is CommandData -> throw IllegalArgumentException("You passed an instance of CommandData, but that lacks the pubkey. You need to wrap it in a Command object first.") - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$is ContractState -> throw UnsupportedOperationException("Removed as of V1: please use a StateAndContract instead") - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$log MaxLineLength:TransactionBuilder.kt$TransactionBuilder$log.warnOnce("Signature constraints not available on network requiring a minimum platform version of 4. Current is: ${services.networkParameters.minimumPlatformVersion}.") MaxLineLength:TransactionBuilder.kt$TransactionBuilder$private MaxLineLength:TransactionBuilder.kt$TransactionBuilder$private fun useWhitelistedByZoneAttachmentConstraint(contractClassName: ContractClassName, networkParameters: NetworkParameters) @@ -8909,331 +4878,140 @@ MaxLineLength:TransactionBuilder.kt$TransactionBuilder$require(defaultOutputConstraint.isSatisfiedBy(constraintAttachment)) { "Selected output constraint: $defaultOutputConstraint not satisfying $selectedAttachmentId" } MaxLineLength:TransactionBuilder.kt$TransactionBuilder$require(explicitAttachmentContracts.isEmpty() || explicitAttachmentContracts.groupBy { (ctr, _) -> ctr }.all { (_, groups) -> groups.size == 1 }) { "Multiple attachments set for the same contract." } MaxLineLength:TransactionBuilder.kt$TransactionBuilder$require(outputConstraint.canBeTransitionedFrom(input.constraint, attachmentToUse)) { "Output state constraint $outputConstraint cannot be transitioned from ${input.constraint}" } - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$require(outputConstraint.isSatisfiedBy(constraintAttachment)) { "Output state constraint check fails. $outputConstraint" } - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$rootError is ClassNotFoundException -> addMissingAttachment((rootError.message ?: throw e).replace(".", "/"), services, e) - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$selectAttachmentThatSatisfiesConstraints(true, refStateEntry.key, refStateEntry.value, emptySet(), services) MaxLineLength:TransactionBuilder.kt$TransactionBuilder$services: ServicesForResolution MaxLineLength:TransactionBuilder.kt$TransactionBuilder$throw IllegalArgumentException("Can't mix the AlwaysAcceptAttachmentConstraint with a secure constraint in the same transaction. This can be used to hide insecure transitions.") - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$throw IllegalArgumentException("Cannot mix SignatureAttachmentConstraints signed by different parties in the same transaction.") - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$useWhitelistedByZoneAttachmentConstraint(contractClassName, services.networkParameters) -> WhitelistedByZoneAttachmentConstraint MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val (allContractAttachments: Collection<SecureHash>, resolvedOutputs: List<TransactionState<ContractState>>) = selectContractAttachmentsAndOutputStateConstraints(services, serializationContext) - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val attachment = services.attachments.openAttachment((state.constraint as HashAttachmentConstraint).attachmentId) - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val attachmentToUse = services.attachments.openAttachment(selectedAttachmentId)?.let { it as ContractAttachment } ?: throw IllegalArgumentException("Contract attachment $selectedAttachmentId for $contractClassName is missing.") MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val attachments: Collection<AttachmentId> = contractAttachmentsAndResolvedOutputStates.map { it.first } + refStateContractAttachments MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val automaticConstraintPropagation = contractClassName.contractHasAutomaticConstraintPropagation(inputsAndOutputs.first().data::class.java.classLoader) MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val constraintAttachment = AttachmentWithContext(attachmentToUse, contractClassName, services.networkParameters.whitelistedContractImplementations) MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val contractAttachmentsAndResolvedOutputStates: List<Pair<AttachmentId, List<TransactionState<ContractState>>?>> = allContracts.toSet() .map { ctr -> handleContract(ctr, inputContractGroups[ctr], contractClassNameToInputStateRef[ctr], outputContractGroups[ctr], explicitAttachmentContractsMap[ctr], services) } MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val contractClassNameToInputStateRef: Map<ContractClassName, Set<StateRef>> = inputsWithTransactionState.map { Pair(it.state.contract, it.ref) } .groupBy { it.first }.mapValues { it.value.map { e -> e.second }.toSet() } - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val defaultOutputConstraint = selectAttachmentConstraint(contractClassName, inputStates, attachmentToUse, services) - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val inputContractGroups: Map<ContractClassName, List<TransactionState<ContractState>>> = inputsWithTransactionState.map { it.state } .groupBy { it.contract } - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val outputContractGroups: Map<ContractClassName, List<TransactionState<ContractState>>> = outputs.groupBy { it.contract } MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val referenceStateGroups: Map<ContractClassName, List<TransactionState<ContractState>>> = referencesWithTransactionState.groupBy { it.contract } MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val resolvedOutputStatesInTheOriginalOrder: List<TransactionState<ContractState>> = outputStates().map { os -> resolvedStates.find { rs -> rs.data == os.data && rs.encumbrance == os.encumbrance }!! } - MaxLineLength:TransactionBuilder.kt$TransactionBuilder$val resolvedStates: List<TransactionState<ContractState>> = contractAttachmentsAndResolvedOutputStates.mapNotNull { it.second } .flatten() MaxLineLength:TransactionBuilder.kt$TransactionBuilder$when { // Sanity check. constraints.isEmpty() -> throw IllegalArgumentException("Cannot transition from no constraints.") // When all input states have the same constraint. constraints.size == 1 -> constraints.single() // Fail when combining the insecure AlwaysAcceptAttachmentConstraint with something else. The size must be at least 2 at this point. constraints.any { it is AlwaysAcceptAttachmentConstraint } -> throw IllegalArgumentException("Can't mix the AlwaysAcceptAttachmentConstraint with a secure constraint in the same transaction. This can be used to hide insecure transitions.") // Multiple states with Hash constraints with different hashes. This should not happen as we checked already. constraints.all { it is HashAttachmentConstraint } -> throw IllegalArgumentException("Cannot mix HashConstraints with different hashes in the same transaction.") // The HashAttachmentConstraint is the strongest constraint, so it wins when mixed with anything. As long as the actual constraints pass. // TODO - this could change if we decide to introduce a way to gracefully migrate from the Hash Constraint to the Signature Constraint. constraints.any { it is HashAttachmentConstraint } -> constraints.find { it is HashAttachmentConstraint }!! // TODO, we don't currently support mixing signature constraints with different signers. This will change once we introduce third party signers. constraints.all { it is SignatureAttachmentConstraint } -> throw IllegalArgumentException("Cannot mix SignatureAttachmentConstraints signed by different parties in the same transaction.") // This ensures a smooth migration from the Whitelist Constraint, given that for the transaction to be valid it still has to pass both constraints. // The transition is possible only when the SignatureConstraint contains ALL signers from the attachment. constraints.any { it is SignatureAttachmentConstraint } && constraints.any { it is WhitelistedByZoneAttachmentConstraint } -> { val signatureConstraint = constraints.mapNotNull { it as? SignatureAttachmentConstraint }.single() when { attachmentToUse.signerKeys.isEmpty() -> throw IllegalArgumentException("Cannot mix a state with the WhitelistedByZoneAttachmentConstraint and a state with the SignatureAttachmentConstraint, when the latest attachment is not signed. Please contact your Zone operator.") signatureConstraint.key.keys.containsAll(attachmentToUse.signerKeys) -> signatureConstraint else -> throw IllegalArgumentException("Attempting to transition a WhitelistedByZoneAttachmentConstraint state backed by an attachment signed by multiple parties to a weaker SignatureConstraint that does not require all those signatures. Please contact your Zone operator.") } } else -> throw IllegalArgumentException("Unexpected constraints $constraints.") } MaxLineLength:TransactionBuilder.kt$TransactionBuilder${ // If the constraint on the output state is already set, and is not a valid transition or can't be transitioned, then fail early. inputStates?.forEach { input -> require(outputConstraint.canBeTransitionedFrom(input.constraint, attachmentToUse)) { "Output state constraint $outputConstraint cannot be transitioned from ${input.constraint}" } } require(outputConstraint.isSatisfiedBy(constraintAttachment)) { "Output state constraint check fails. $outputConstraint" } it } - MaxLineLength:TransactionBuilder.kt$TransactionBuilder${ // This should never happen because these are input states that should have been validated already. throw MissingContractAttachments(listOf(state)) } - MaxLineLength:TransactionBuilder.kt$TransactionBuilder${ val inputsAndOutputs = (inputStates ?: emptyList()) + (outputStates ?: emptyList()) // Determine if there are any HashConstraints that pin the version of a contract. If there are, check if we trust them. val hashAttachments = inputsAndOutputs .filter { it.constraint is HashAttachmentConstraint } .map { state -> val attachment = services.attachments.openAttachment((state.constraint as HashAttachmentConstraint).attachmentId) if (attachment == null || attachment !is ContractAttachment || !isUploaderTrusted(attachment.uploader)) { // This should never happen because these are input states that should have been validated already. throw MissingContractAttachments(listOf(state)) } attachment }.toSet() // Check that states with the HashConstraint don't conflict between themselves or with an explicitly set attachment. require(hashAttachments.size <= 1) { "Transaction was built with $contractClassName states with multiple HashConstraints. This is illegal, because it makes it impossible to validate with a single version of the contract code." } if (explicitContractAttachment != null && hashAttachments.singleOrNull() != null) { require(explicitContractAttachment == (hashAttachments.single() as ContractAttachment).attachment.id) { "An attachment has been explicitly set for contract $contractClassName in the transaction builder which conflicts with the HashConstraint of a state." } } // This will contain the hash of the JAR that *has* to be used by this Transaction, because it is explicit. Or null if none. val forcedAttachmentId = explicitContractAttachment ?: hashAttachments.singleOrNull()?.id fun selectAttachment() = selectAttachmentThatSatisfiesConstraints( false, contractClassName, inputsAndOutputs.filterNot { it.constraint in automaticConstraints }, inputStateRefs, services) // This will contain the hash of the JAR that will be used by this Transaction. val selectedAttachmentId = forcedAttachmentId ?: selectAttachment() val attachmentToUse = services.attachments.openAttachment(selectedAttachmentId)?.let { it as ContractAttachment } ?: throw IllegalArgumentException("Contract attachment $selectedAttachmentId for $contractClassName is missing.") // For Exit transactions (no output states) there is no need to resolve the output constraints. if (outputStates == null) { return Pair(selectedAttachmentId, null) } // If there are no automatic constraints, there is nothing to resolve. if (outputStates.none { it.constraint in automaticConstraints }) { return Pair(selectedAttachmentId, outputStates) } // The final step is to resolve AutomaticPlaceholderConstraint. val automaticConstraintPropagation = contractClassName.contractHasAutomaticConstraintPropagation(inputsAndOutputs.first().data::class.java.classLoader) // When automaticConstraintPropagation is disabled for a contract, output states must an explicit Constraint. require(automaticConstraintPropagation) { "Contract $contractClassName was marked with @NoConstraintPropagation, which means the constraint of the output states has to be set explicitly." } // This is the logic to determine the constraint which will replace the AutomaticPlaceholderConstraint. val defaultOutputConstraint = selectAttachmentConstraint(contractClassName, inputStates, attachmentToUse, services) // Sanity check that the selected attachment actually passes. val constraintAttachment = AttachmentWithContext(attachmentToUse, contractClassName, services.networkParameters.whitelistedContractImplementations) require(defaultOutputConstraint.isSatisfiedBy(constraintAttachment)) { "Selected output constraint: $defaultOutputConstraint not satisfying $selectedAttachmentId" } val resolvedOutputStates = outputStates.map { val outputConstraint = it.constraint if (outputConstraint in automaticConstraints) { it.copy(constraint = defaultOutputConstraint) } else { // If the constraint on the output state is already set, and is not a valid transition or can't be transitioned, then fail early. inputStates?.forEach { input -> require(outputConstraint.canBeTransitionedFrom(input.constraint, attachmentToUse)) { "Output state constraint $outputConstraint cannot be transitioned from ${input.constraint}" } } require(outputConstraint.isSatisfiedBy(constraintAttachment)) { "Output state constraint check fails. $outputConstraint" } it } } return Pair(selectedAttachmentId, resolvedOutputStates) } - MaxLineLength:TransactionBuilderTest.kt$TransactionBuilderTest$assertThat(wtx.outputs).containsOnly(outputState.copy(constraint = HashAttachmentConstraint(contractAttachmentId))) - MaxLineLength:TransactionBuilderTest.kt$TransactionBuilderTest$private - MaxLineLength:TransactionDSLInterpreter.kt$TransactionDSL$ fun input(stateLabel: String) - MaxLineLength:TransactionDSLInterpreter.kt$TransactionDSL$ fun reference(stateLabel: String) MaxLineLength:TransactionDSLInterpreter.kt$TransactionDSL$fun attachment(contractClassName: ContractClassName, attachmentId: AttachmentId) MaxLineLength:TransactionDSLInterpreter.kt$TransactionDSL$fun attachment(contractClassName: ContractClassName, attachmentId: AttachmentId, signers: List<PublicKey>, jarManifestAttributes: Map<String,String> = emptyMap()) MaxLineLength:TransactionDSLInterpreter.kt$TransactionDSL<out T : TransactionDSLInterpreter> : TransactionDSLInterpreter MaxLineLength:TransactionDSLInterpreter.kt$TransactionDSLInterpreter$ fun _attachment(contractClassName: ContractClassName, attachmentId: AttachmentId, signers: List<PublicKey>, jarManifestAttributes: Map<String,String>) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 0, AutomaticPlaceholderConstraint) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 0, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 3, AutomaticPlaceholderConstraint) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 0, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 3, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY2, 2, AutomaticPlaceholderConstraint) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 3, AutomaticPlaceholderConstraint) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 3, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY2, 0, AutomaticPlaceholderConstraint) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 3, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY2, 0, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 2, AutomaticPlaceholderConstraint) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY2, 0, AutomaticPlaceholderConstraint) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$assertThatExceptionOfType(TransactionVerificationException.TransactionNotaryMismatchEncumbranceException::class.java) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$assertThatExceptionOfType(TransactionVerificationException.TransactionNotaryMismatchEncumbranceException::class.java) .isThrownBy { TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 0, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 3, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY2, 2, AutomaticPlaceholderConstraint) .addCommand(Cash.Commands.Issue(), MEGA_CORP.owningKey) .toLedgerTransaction(ledgerServices) .verify() } .withMessageContaining("index 2 is assigned to notary [O=Notary Service, L=Zurich, C=CH], while its encumbrance with " + "index 3 is assigned to notary [O=Notary Service2, L=Zurich, C=CH]") - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$assertThatExceptionOfType(TransactionVerificationException.TransactionNotaryMismatchEncumbranceException::class.java) .isThrownBy { TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 3, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY2, 0, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 2, AutomaticPlaceholderConstraint) .addCommand(Cash.Commands.Issue(), MEGA_CORP.owningKey) .toLedgerTransaction(ledgerServices) .verify() } .withMessageContaining("index 3 is assigned to notary [O=Notary Service, L=Zurich, C=CH], while its encumbrance with " + "index 2 is assigned to notary [O=Notary Service2, L=Zurich, C=CH]") - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by 5pm time-lock A", encumbrance = 2, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by 5pm time-lock A", encumbrance = 3, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by 5pm time-lock B", encumbrance = 3, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by 5pm time-lock B", encumbrance = 4, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by 5pm time-lock C", encumbrance = 5, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by 5pm time-lock", encumbrance = 1, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by itself", encumbrance = 0, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by state 0", encumbrance = 0, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by state 1", encumbrance = 1, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by state 2", encumbrance = 2, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by state 3 again", encumbrance = 3, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(Cash.PROGRAM_ID, "state encumbered by state 3", encumbrance = 3, contractState = stateWithNewOwner) MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests$output(TEST_TIMELOCK_ID, "state encumbered by state 2 which does not exist", encumbrance = 2, contractState = stateWithNewOwner) - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests${ // Single encumbrance with different notaries. assertFailsWith<TransactionVerificationException.TransactionNotaryMismatchEncumbranceException> { TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY2, 0, AutomaticPlaceholderConstraint) .addCommand(Cash.Commands.Issue(), MEGA_CORP.owningKey) .toLedgerTransaction(ledgerServices) .verify() } // More complex encumbrance (full cycle of size 4) where one of the encumbered states is assigned to a different notary. // 0 -> 1, 1 -> 3, 3 -> 2, 2 -> 0 // We expect that state at index 3 cannot be encumbered with the state at index 2, due to mismatched notaries. assertThatExceptionOfType(TransactionVerificationException.TransactionNotaryMismatchEncumbranceException::class.java) .isThrownBy { TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 3, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY2, 0, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 2, AutomaticPlaceholderConstraint) .addCommand(Cash.Commands.Issue(), MEGA_CORP.owningKey) .toLedgerTransaction(ledgerServices) .verify() } .withMessageContaining("index 3 is assigned to notary [O=Notary Service, L=Zurich, C=CH], while its encumbrance with " + "index 2 is assigned to notary [O=Notary Service2, L=Zurich, C=CH]") // Two different encumbrance chains, where only one fails due to mismatched notary. // 0 -> 1, 1 -> 0, 2 -> 3, 3 -> 2 where encumbered states with indices 2 and 3, respectively, are assigned // to different notaries. assertThatExceptionOfType(TransactionVerificationException.TransactionNotaryMismatchEncumbranceException::class.java) .isThrownBy { TransactionBuilder() .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 1, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 0, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY, 3, AutomaticPlaceholderConstraint) .addOutputState(stateWithNewOwner, Cash.PROGRAM_ID, DUMMY_NOTARY2, 2, AutomaticPlaceholderConstraint) .addCommand(Cash.Commands.Issue(), MEGA_CORP.owningKey) .toLedgerTransaction(ledgerServices) .verify() } .withMessageContaining("index 2 is assigned to notary [O=Notary Service, L=Zurich, C=CH], while its encumbrance with " + "index 3 is assigned to notary [O=Notary Service2, L=Zurich, C=CH]") } - MaxLineLength:TransactionEncumbranceTests.kt$TransactionEncumbranceTests.Companion$val DUMMY_NOTARY2 = TestIdentity(DUMMY_NOTARY_NAME.copy(organisation = "${DUMMY_NOTARY_NAME.organisation}2"), 30).party - MaxLineLength:TransactionGenerator.kt$TransactionGenerator$output(PROGRAM_ID, "c1", State(1000.POUNDS `issued by` DUMMY_CASH_ISSUER, AnonymousParty(MEGA_CORP_PUBKEY))) - MaxLineLength:TransactionGenerator.kt$TransactionGenerator$output(PROGRAM_ID, "c2", State(2000.POUNDS `issued by` DUMMY_CASH_ISSUER, AnonymousParty(MEGA_CORP_PUBKEY))) - MaxLineLength:TransactionGenerator.kt$TransactionGenerator$output(PROGRAM_ID, "c3", State(3000.POUNDS `issued by` DUMMY_CASH_ISSUER, AnonymousParty(MINI_CORP_PUBKEY))) MaxLineLength:TransactionGenerator.kt$TransactionGenerator$private val DUMMY_CASH_ISSUER_IDENTITY = getTestPartyAndCertificate(Party(CordaX500Name("Snake Oil Issuer", "London", "GB"), DUMMY_CASH_ISSUER_KEY.public)) MaxLineLength:TransactionGenerator.kt$TransactionGenerator$val contractAttachment = MockContractAttachment(interpreter.services.cordappProvider.getContractAttachmentID(PROGRAM_ID)!!, PROGRAM_ID) - MaxLineLength:TransactionGraphSearch.kt$TransactionGraphSearch$Query MaxLineLength:TransactionGraphSearch.kt$TransactionGraphSearch$val unvisitedInputTxs: Map<SecureHash, SignedTransaction> = inputsLeadingToUnvisitedTx.map { it.txhash }.toHashSet().mapNotNull { transactions.getTransaction(it) }.associateBy { it.id } MaxLineLength:TransactionGraphSearch.kt$TransactionGraphSearch$val unvisitedInputTxsWithInputIndex: Iterable<Pair<SignedTransaction, Int>> = inputsLeadingToUnvisitedTx.filter { it.txhash in unvisitedInputTxs.keys }.map { Pair(unvisitedInputTxs[it.txhash]!!, it.index) } - MaxLineLength:TransactionGraphSearchTests.kt$TransactionGraphSearchTests$GraphTransactionStorage : MockTransactionStorage - MaxLineLength:TransactionGraphSearchTests.kt$TransactionGraphSearchTests$val megaCorpServices = MockServices(listOf("net.corda.testing.contracts"), megaCorp, rigorousMock<IdentityService>()) - MaxLineLength:TransactionGraphSearchTests.kt$TransactionGraphSearchTests$val notaryServices = MockServices(listOf("net.corda.testing.contracts"), dummyNotary, rigorousMock<IdentityService>()) MaxLineLength:TransactionGraphSearchTests.kt$TransactionGraphSearchTests$val search = TransactionGraphSearch(storage, listOf(storage.inputTx.tx), TransactionGraphSearch.Query(DummyContract.Commands.Create::class.java)) MaxLineLength:TransactionSerializationTests.kt$TransactionSerializationTests$inputState = StateAndRef(TransactionState(TestCash.State(depositRef, 100.POUNDS, MEGA_CORP), TEST_CASH_PROGRAM_ID, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint), fakeStateRef) MaxLineLength:TransactionSerializationTests.kt$TransactionSerializationTests$tx = TransactionBuilder(DUMMY_NOTARY).withItems(inputState, outputState, changeState, Command(TestCash.Commands.Move(), arrayListOf(MEGA_CORP.owningKey))) - MaxLineLength:TransactionSerializationTests.kt$TransactionSerializationTests$val changeState = TransactionState(TestCash.State(depositRef, 400.POUNDS, MEGA_CORP), TEST_CASH_PROGRAM_ID, DUMMY_NOTARY) MaxLineLength:TransactionSerializationTests.kt$TransactionSerializationTests$val fakeTx = megaCorpServices.signInitialTransaction(TransactionBuilder(DUMMY_NOTARY).withItems(outputState, Command(TestCash.Commands.Issue(), arrayListOf(MEGA_CORP.owningKey)))) MaxLineLength:TransactionSerializationTests.kt$TransactionSerializationTests$val megaCorpServices = object : MockServices(listOf("net.corda.core.serialization"), MEGA_CORP.name, mock(), testNetworkParameters(notaries = listOf(NotaryInfo(DUMMY_NOTARY, true))), MEGA_CORP_KEY) { //override mock implementation with a real one override fun loadContractAttachment(stateRef: StateRef): Attachment = servicesForResolution.loadContractAttachment(stateRef) } - MaxLineLength:TransactionSerializationTests.kt$TransactionSerializationTests$val notaryServices = MockServices(listOf("net.corda.core.serialization"), DUMMY_NOTARY.name, rigorousMock(), DUMMY_NOTARY_KEY) - MaxLineLength:TransactionSerializationTests.kt$TransactionSerializationTests$val outputState = TransactionState(TestCash.State(depositRef, 600.POUNDS, MEGA_CORP), TEST_CASH_PROGRAM_ID, DUMMY_NOTARY) MaxLineLength:TransactionSerializationTests.kt$TransactionSerializationTests$val signatures = listOf(TransactionSignature(ByteArray(1), MEGA_CORP_KEY.public, SignatureMetadata(1, Crypto.findSignatureScheme(MEGA_CORP_KEY.public).schemeNumberID))) - MaxLineLength:TransactionSerializationTests.kt$TransactionSerializationTests.<no name provided>$override - MaxLineLength:TransactionSerializationTests.kt$TransactionSerializationTests.TestCash.State$override fun withNewOwner(newOwner: AbstractParty) MaxLineLength:TransactionSignature.kt$TransactionSignature : DigitalSignature MaxLineLength:TransactionSignature.kt$TransactionSignature$ @Throws(InvalidKeyException::class, SignatureException::class) fun verify(txId: SecureHash) - MaxLineLength:TransactionSignature.kt$TransactionSignature$/** * Construct a [TransactionSignature] with [partialMerkleTree] set to null. * This is the recommended constructor when signing over a single transaction. * */ constructor(bytes: ByteArray, by: PublicKey, signatureMetadata: SignatureMetadata) : this(bytes, by, signatureMetadata, null) - MaxLineLength:TransactionSignatureTest.kt$TransactionSignatureTest$val signableData = SignableData(testBytes.sha256(), SignatureMetadata(1, Crypto.findSignatureScheme(keyPair.public).schemeNumberID)) - MaxLineLength:TransactionSignatureTest.kt$TransactionSignatureTest$val signableData = SignableData(txId, SignatureMetadata(3, Crypto.findSignatureScheme(keyPair.public).schemeNumberID)) - MaxLineLength:TransactionSignatureTest.kt$TransactionSignatureTest$val txSignatureWithFullTree = TransactionSignature(txSignature.bytes, txSignature.by, txSignature.signatureMetadata, pmtFull) - MaxLineLength:TransactionSignatureTest.kt$TransactionSignatureTest$val txSignatureWithTree = TransactionSignature(txSignature.bytes, txSignature.by, txSignature.signatureMetadata, pmt) - MaxLineLength:TransactionSignatureTest.kt$TransactionSignatureTest${ val keyPair = Crypto.deriveKeyPairFromEntropy(Crypto.EDDSA_ED25519_SHA512, BigInteger.valueOf(1234567890L)) val txId = "aTransaction".toByteArray().sha256() // One-tx signature. val txSignature = signOneTx(txId, keyPair) // partialMerkleTree should be null. assertNull(txSignature.partialMerkleTree) // Verify the corresponding txId with every possible way. assertTrue(Crypto.doVerify(txId, txSignature)) assertTrue(txSignature.verify(txId)) assertTrue(Crypto.isValid(txId, txSignature)) assertTrue(txSignature.isValid(txId)) // We signed the txId itself, not its hash (because it was a signature over one tx only and no partial tree has been received). assertFailsWith<SignatureException> { Crypto.doVerify(txId.sha256(), txSignature) } } - MaxLineLength:TransactionSignatureTest.kt$TransactionSignatureTest${ val txId = "aTransaction".toByteArray().sha256() // One-tx signature. val txSignature = try { signOneTx(txId, keyPair) } catch (e: Throwable) { e.cause?.printStackTrace() throw e } // partialMerkleTree should be null. assertNull(txSignature.partialMerkleTree) // Verify the corresponding txId with every possible way. assertTrue(Crypto.doVerify(txId, txSignature)) assertTrue(txSignature.verify(txId)) assertTrue(Crypto.isValid(txId, txSignature)) assertTrue(txSignature.isValid(txId)) // We signed the txId itself, not its hash (because it was a signature over one tx only and no partial tree has been received). assertFailsWith<SignatureException> { Crypto.doVerify(txId.sha256(), txSignature) } } - MaxLineLength:TransactionState.kt$TransactionState$ @BelongsToContract, and does not have an enclosing class which implements Contract. Either annotate - MaxLineLength:TransactionState.kt$TransactionState$/** * All contract states may be _encumbered_ by up to one other state. * * The encumbrance state, if present, forces additional controls over the encumbered state, since the platform checks * that the encumbrance state is present as an input in the same transaction that consumes the encumbered state, and * the contract code and rules of the encumbrance state will also be verified during the execution of the transaction. * For example, a cash contract state could be encumbered with a time-lock contract state; the cash state is then only * processable in a transaction that verifies that the time specified in the encumbrance time-lock has passed. * * The encumbered state refers to another by index, and the referred encumbrance state * is an output state in a particular position on the same transaction that created the encumbered state. An alternative * implementation would be encumbering by reference to a [StateRef], which would allow the specification of encumbrance * by a state created in a prior transaction. * * Note that an encumbered state that is being consumed must have its encumbrance consumed in the same transaction, * otherwise the transaction is not valid. */ val encumbrance: Int? = null MaxLineLength:TransactionTests.kt$TransactionTests$assertFailsWith<SignedTransaction.SignaturesMissingException> { makeSigned(wtx, DUMMY_CASH_ISSUER_KEY).verifySignaturesExcept(DUMMY_KEY_1.public) }.missing MaxLineLength:TransactionTests.kt$TransactionTests$assertFailsWith<SignedTransaction.SignaturesMissingException> { makeSigned(wtx, DUMMY_KEY_1).verifyRequiredSignatures() }.missing MaxLineLength:TransactionTests.kt$TransactionTests$assertFailsWith<SignedTransaction.SignaturesMissingException> { makeSigned(wtx, DUMMY_KEY_1, ak).verifyRequiredSignatures() }.missing MaxLineLength:TransactionTests.kt$TransactionTests$assertFailsWith<SignedTransaction.SignaturesMissingException> { makeSigned(wtx, DUMMY_KEY_2).verifyRequiredSignatures() }.missing - MaxLineLength:TransactionTests.kt$TransactionTests$assertFailsWith<TransactionVerificationException.NotaryChangeInWrongTransactionType> { buildTransaction().verify() } MaxLineLength:TransactionTests.kt$TransactionTests$keySigs + DUMMY_NOTARY_KEY.sign(SignableData(wtx.id, SignatureMetadata(1, Crypto.findSignatureScheme(DUMMY_NOTARY_KEY.public).schemeNumberID))) - MaxLineLength:TransactionTests.kt$TransactionTests$makeSigned(wtx, DUMMY_KEY_1, ak).verifySignaturesExcept(compKey, DUMMY_KEY_2.public) MaxLineLength:TransactionTests.kt$TransactionTests$val baseOutState = TransactionState(DummyContract.SingleOwnerState(0, ALICE), DummyContract.PROGRAM_ID, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint) - MaxLineLength:TransactionTests.kt$TransactionTests$val keySigs = keys.map { it.sign(SignableData(wtx.id, SignatureMetadata(1, Crypto.findSignatureScheme(it.public).schemeNumberID))) } - MaxLineLength:TransactionTests.kt$TransactionTests$val outputState = TransactionState(DummyContract.SingleOwnerState(0, ALICE), DummyContract.PROGRAM_ID, DUMMY_NOTARY) MaxLineLength:TransactionUtils.kt$ fun <T : Any> deserialiseComponentGroup(componentGroups: List<ComponentGroup>, clazz: KClass<T>, groupEnum: ComponentGroupEnum, forceDeserialize: Boolean = false, factory: SerializationFactory = SerializationFactory.defaultFactory, context: SerializationContext = factory.defaultContext): List<T> - MaxLineLength:TransactionUtils.kt$"Invalid Transaction. Sizes of CommandData (${commandDataList.size}) and Signers (${signersList.size}) do not match" MaxLineLength:TransactionUtils.kt$ContractUpgradeTransactionBuilder$val components = listOf(inputs, notary, legacyContractAttachmentId, upgradedContractClassName, upgradedContractAttachmentId, networkParametersHash).map { it.serialize() } - MaxLineLength:TransactionUtils.kt$SerializedStateAndRef$@KeepForDJVM data - MaxLineLength:TransactionUtils.kt$check(leafIndices.max()!! < signersList.size) { "Invalid Transaction. A command with no corresponding signer detected" } MaxLineLength:TransactionUtils.kt$if (attachments.isNotEmpty()) componentGroupMap.add(ComponentGroup(ComponentGroupEnum.ATTACHMENTS_GROUP.ordinal, attachments.lazyMapped(serialize))) MaxLineLength:TransactionUtils.kt$if (commands.isNotEmpty()) componentGroupMap.add(ComponentGroup(ComponentGroupEnum.COMMANDS_GROUP.ordinal, commands.map { it.value }.lazyMapped(serialize))) MaxLineLength:TransactionUtils.kt$if (commands.isNotEmpty()) componentGroupMap.add(ComponentGroup(ComponentGroupEnum.SIGNERS_GROUP.ordinal, commands.map { it.signers }.lazyMapped(serialize))) - MaxLineLength:TransactionUtils.kt$if (inputs.isNotEmpty()) componentGroupMap.add(ComponentGroup(ComponentGroupEnum.INPUTS_GROUP.ordinal, inputs.lazyMapped(serialize))) MaxLineLength:TransactionUtils.kt$if (networkParametersHash != null) componentGroupMap.add(ComponentGroup(ComponentGroupEnum.PARAMETERS_GROUP.ordinal, listOf(networkParametersHash.serialize()))) - MaxLineLength:TransactionUtils.kt$if (notary != null) componentGroupMap.add(ComponentGroup(ComponentGroupEnum.NOTARY_GROUP.ordinal, listOf(notary).lazyMapped(serialize))) - MaxLineLength:TransactionUtils.kt$if (outputs.isNotEmpty()) componentGroupMap.add(ComponentGroup(ComponentGroupEnum.OUTPUTS_GROUP.ordinal, outputs.lazyMapped(serialize))) MaxLineLength:TransactionUtils.kt$if (references.isNotEmpty()) componentGroupMap.add(ComponentGroup(ComponentGroupEnum.REFERENCES_GROUP.ordinal, references.lazyMapped(serialize))) MaxLineLength:TransactionUtils.kt$if (timeWindow != null) componentGroupMap.add(ComponentGroup(ComponentGroupEnum.TIMEWINDOW_GROUP.ordinal, listOf(timeWindow).lazyMapped(serialize))) MaxLineLength:TransactionUtils.kt$serviceHub.networkParametersService.lookup(networkParametersHash) ?: throw IllegalArgumentException("Transaction for notarisation contains unknown parameters hash: $networkParametersHash") MaxLineLength:TransactionUtils.kt$val commandDataList: List<CommandData> = deserialiseComponentGroup(componentGroups, CommandData::class, ComponentGroupEnum.COMMANDS_GROUP, forceDeserialize) - MaxLineLength:TransactionUtils.kt$val componentHashes = group.components.mapIndexed { index, component -> componentHash(group.nonces[index], component) } MaxLineLength:TransactionUtils.kt$val signersList: List<List<PublicKey>> = uncheckedCast(deserialiseComponentGroup(componentGroups, List::class, ComponentGroupEnum.SIGNERS_GROUP, forceDeserialize)) - MaxLineLength:TransactionUtils.kt${ // Transactions created on Corda 3.x or below do not contain network parameters, // so no checking is done until the minimum platform version is at least 4. if (networkParametersHash == null) { if (serviceHub.networkParameters.minimumPlatformVersion < 4) return else throw IllegalArgumentException("Transaction for notarisation doesn't contain network parameters hash.") } else { serviceHub.networkParametersService.lookup(networkParametersHash) ?: throw IllegalArgumentException("Transaction for notarisation contains unknown parameters hash: $networkParametersHash") } // TODO: [ENT-2666] Implement network parameters fuzzy checking. By design in Corda network we have propagation time delay. // We will never end up in perfect synchronization with all the nodes. However, network parameters update process // lets us predict what is the reasonable time window for changing parameters on most of the nodes. // For now we don't check whether the attached network parameters match the current ones. } MaxLineLength:TransactionVerificationException.kt$TransactionResolutionException$@KeepForDJVM open MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$ConflictingAttachmentsRejection : TransactionVerificationException MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$ConstraintPropagationRejection : TransactionVerificationException MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$ContractCreationError : TransactionVerificationException MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$ContractRejection : TransactionVerificationException - MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$Direction MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$InvalidAttachmentException : TransactionVerificationException - MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$InvalidNotaryChange : TransactionVerificationException - MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$MissingAttachmentRejection : TransactionVerificationException MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$MissingNetworkParametersException : TransactionVerificationException MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$NotaryChangeInWrongTransactionType : TransactionVerificationException MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$OverlappingAttachmentsException : TransactionVerificationException MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$PackageOwnershipException : TransactionVerificationException MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$SignersMissing : TransactionVerificationException - MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$TransactionContractConflictException : TransactionVerificationException MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$TransactionNetworkParameterOrderingException : TransactionVerificationException MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$TransactionNotaryMismatchEncumbranceException : TransactionVerificationException - MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException$UntrustedAttachmentsException : CordaException - MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException${ /** * Indicates that one of the [Contract.verify] methods selected by the contract constraints and attachments * rejected the transaction by throwing an exception. * * @property contractClass The fully qualified class name of the failing contract. */ @KeepForDJVM class ContractRejection internal constructor(txId: SecureHash, val contractClass: String, cause: Throwable?, message: String) : TransactionVerificationException(txId, "Contract verification failed: $message, contract: $contractClass", cause) { internal constructor(txId: SecureHash, contract: Contract, cause: Throwable) : this(txId, contract.javaClass.name, cause, cause.message ?: "") } /** * This exception happens when a transaction was not built correctly. * When a contract is not annotated with [NoConstraintPropagation], then the platform ensures that the constraints of output states transition correctly from input states. * * @property txId The transaction. * @property contractClass The fully qualified class name of the failing contract. * @property inputConstraint The constraint of the input state. * @property outputConstraint The constraint of the outputs state. */ @KeepForDJVM class ConstraintPropagationRejection(txId: SecureHash, val contractClass: String, inputConstraint: AttachmentConstraint, outputConstraint: AttachmentConstraint) : TransactionVerificationException(txId, "Contract constraints for $contractClass are not propagated correctly. The outputConstraint: $outputConstraint is not a valid transition from the input constraint: $inputConstraint.", null) /** * The transaction attachment that contains the [contractClass] class didn't meet the constraints specified by * the [TransactionState.constraint] object. This usually implies a version mismatch of some kind. * * @property contractClass The fully qualified class name of the failing contract. */ @KeepForDJVM class ContractConstraintRejection(txId: SecureHash, val contractClass: String) : TransactionVerificationException(txId, "Contract constraints failed for $contractClass", null) /** * A state requested a contract class via its [TransactionState.contract] field that didn't appear in any attached * JAR at all. This usually implies the attachments were forgotten or a version mismatch. * * @property contractClass The fully qualified class name of the failing contract. */ @KeepForDJVM class MissingAttachmentRejection(txId: SecureHash, val contractClass: String) : TransactionVerificationException(txId, "Contract constraints failed, could not find attachment for: $contractClass", null) /** * Indicates this transaction violates the "no overlap" rule: two attachments are trying to provide the same file * path. Whereas Java classpaths would normally allow that with the first class taking precedence, this is not * allowed in transactions for security reasons. This usually indicates that two separate apps share a dependency, * in which case you could try 'shading the fat jars' to rename classes of dependencies. Or you could manually * attach dependency JARs when building the transaction. * * @property contractClass The fully qualified class name of the failing contract. */ @KeepForDJVM class ConflictingAttachmentsRejection(txId: SecureHash, val contractClass: String) : TransactionVerificationException(txId, "Contract constraints failed for: $contractClass, because multiple attachments providing this contract were attached.", null) /** * Indicates that the same attachment has been added multiple times to a transaction. */ @KeepForDJVM class DuplicateAttachmentsRejection(txId: SecureHash, val attachmentId: Attachment) : TransactionVerificationException(txId, "The attachment: $attachmentId was added multiple times.", null) /** * A [Contract] class named by a state could not be constructed. Most likely you do not have a no-argument * constructor, or the class doesn't subclass [Contract]. * * @property contractClass The fully qualified class name of the failing contract. */ @KeepForDJVM class ContractCreationError internal constructor(txId: SecureHash, val contractClass: String, cause: Throwable?, message: String) : TransactionVerificationException(txId, "Contract verification failed: $message, could not create contract class: $contractClass", cause) { internal constructor(txId: SecureHash, contractClass: String, cause: Throwable) : this(txId, contractClass, cause, cause.message ?: "") } /** * An output state has a notary that doesn't match the transaction's notary field. It must! * * @property txNotary the [Party] specified by the transaction header. * @property outputNotary the [Party] specified by the errant state. */ @KeepForDJVM class NotaryChangeInWrongTransactionType(txId: SecureHash, val txNotary: Party, val outputNotary: Party) : TransactionVerificationException(txId, "Found unexpected notary change in transaction. Tx notary: $txNotary, found: $outputNotary", null) /** * If a state is encumbered (the [TransactionState.encumbrance] field is set) then its encumbrance must be used * as an input to any transaction that uses it. In this way states can be tied together in chains, thus composing * logic. Note that encumbrances aren't fully supported by all aspects of the platform at this time so if you use * them, you may find transactions created by the platform don't always respect the encumbrance rule. * * @property missing the index of the state missing the encumbrance. * @property inOut whether the issue exists in the input list or output list. */ @KeepForDJVM class TransactionMissingEncumbranceException(txId: SecureHash, val missing: Int, val inOut: Direction) : TransactionVerificationException(txId, "Missing required encumbrance $missing in $inOut", null) /** * If two or more states refer to another state (as their encumbrance), then the bi-directionality property cannot * be satisfied. */ @KeepForDJVM class TransactionDuplicateEncumbranceException(txId: SecureHash, index: Int) : TransactionVerificationException(txId, "The bi-directionality property of encumbered output states " + "is not satisfied. Index $index is referenced more than once", null) /** * An encumbered state should also be referenced as the encumbrance of another state in order to satisfy the * bi-directionality property (a full cycle should be present). */ @KeepForDJVM class TransactionNonMatchingEncumbranceException(txId: SecureHash, nonMatching: Collection<Int>) : TransactionVerificationException(txId, "The bi-directionality property of encumbered output states " + "is not satisfied. Encumbered states should also be referenced as an encumbrance of another state to form " + "a full cycle. Offending indices $nonMatching", null) /** * All encumbered states should be assigned to the same notary. This is due to the fact that multi-notary * transactions are not supported and thus two encumbered states with different notaries cannot be consumed * in the same transaction. */ @KeepForDJVM class TransactionNotaryMismatchEncumbranceException(txId: SecureHash, encumberedIndex: Int, encumbranceIndex: Int, encumberedNotary: Party, encumbranceNotary: Party) : TransactionVerificationException(txId, "Encumbered output states assigned to different notaries found. " + "Output state with index $encumberedIndex is assigned to notary [$encumberedNotary], while its encumbrance with index $encumbranceIndex is assigned to notary [$encumbranceNotary]", null) /** * If a state is identified as belonging to a contract, either because the state class is defined as an inner class * of the contract class or because the state class is annotated with [BelongsToContract], then it must not be * bundled in a [TransactionState] with a different contract. * * @param state The [TransactionState] whose bundled state and contract are in conflict. * @param requiredContractClassName The class name of the contract to which the state belongs. */ @KeepForDJVM class TransactionContractConflictException(txId: SecureHash, state: TransactionState<ContractState>, requiredContractClassName: String) : TransactionVerificationException(txId, """ State of class ${state.data::class.java.typeName} belongs to contract $requiredContractClassName, but is bundled in TransactionState with ${state.contract}. For details see: https://docs.corda.net/api-contract-constraints.html#contract-state-agreement """.trimIndent().replace('\n', ' '), null) // TODO: add reference to documentation @KeepForDJVM class TransactionRequiredContractUnspecifiedException(txId: SecureHash, state: TransactionState<ContractState>) : TransactionVerificationException(txId, """ State of class ${state.data::class.java.typeName} does not have a specified owning contract. Add the @BelongsToContract annotation to this class to ensure that it can only be bundled in a TransactionState with the correct contract. For details see: https://docs.corda.net/api-contract-constraints.html#contract-state-agreement """.trimIndent(), null) /** * If the network parameters associated with an input or reference state in a transaction are more recent than the network parameters of the new transaction itself. */ @KeepForDJVM class TransactionNetworkParameterOrderingException(txId: SecureHash, inputStateRef: StateRef, txnNetworkParameters: NetworkParameters, inputNetworkParameters: NetworkParameters) : TransactionVerificationException(txId, "The network parameters epoch (${txnNetworkParameters.epoch}) of this transaction " + "is older than the epoch (${inputNetworkParameters.epoch}) of input state: $inputStateRef", null) /** * Thrown when the network parameters with hash: missingNetworkParametersHash is not available at this node. Usually all the parameters * that are in the resolution chain for transaction with txId should be fetched from peer via [FetchParametersFlow] or from network map. * * @param txId Id of the transaction that has missing parameters hash in the resolution chain * @param missingNetworkParametersHash Missing hash of the network parameters associated to this transaction */ @KeepForDJVM class MissingNetworkParametersException(txId: SecureHash, missingNetworkParametersHash: SecureHash) : TransactionVerificationException(txId, "Couldn't find network parameters with hash: $missingNetworkParametersHash related to this transaction: $txId", null) /** Whether the inputs or outputs list contains an encumbrance issue, see [TransactionMissingEncumbranceException]. */ @CordaSerializable @KeepForDJVM enum class Direction { /** Issue in the inputs list. */ INPUT, /** Issue in the outputs list. */ OUTPUT } // We could revisit and throw this more appropriate type in a future release that uses targetVersion to // avoid the compatibility break, because IllegalStateException isn't ideal for this. Or we could use this // as a cause. /** @suppress This class is not used: duplicate inputs throw a [IllegalStateException] instead. */ @Deprecated("This class is not used: duplicate inputs throw a [IllegalStateException] instead.") @DeleteForDJVM class DuplicateInputStates(txId: SecureHash, val duplicates: NonEmptySet<StateRef>) : TransactionVerificationException(txId, "Duplicate inputs: ${duplicates.joinToString()}", null) /** @suppress This class is obsolete and nothing has ever used it. */ @Deprecated("This class is obsolete and nothing has ever used it.") @DeleteForDJVM class MoreThanOneNotary(txId: SecureHash) : TransactionVerificationException(txId, "More than one notary", null) /** @suppress This class is obsolete and nothing has ever used it. */ @Deprecated("This class is obsolete and nothing has ever used it.") @DeleteForDJVM class SignersMissing(txId: SecureHash, val missing: List<PublicKey>) : TransactionVerificationException(txId, "Signers missing: ${missing.joinToString()}", null) /** @suppress This class is obsolete and nothing has ever used it. */ @Deprecated("This class is obsolete and nothing has ever used it.") @DeleteForDJVM class InvalidNotaryChange(txId: SecureHash) : TransactionVerificationException(txId, "Detected a notary change. Outputs must use the same notary as inputs", null) /** * Thrown when multiple attachments provide the same file when building the AttachmentsClassloader for a transaction. */ @CordaSerializable @KeepForDJVM class OverlappingAttachmentsException(txId: SecureHash, val path: String) : TransactionVerificationException(txId, "Multiple attachments define a file at $path.", null) /** * Thrown to indicate that a contract attachment is not signed by the network-wide package owner. Please note that * the [txId] will always be [SecureHash.zeroHash] because package ownership is an error with a particular attachment, * and because attachment classloaders are reused this is independent of any particular transaction. */ @CordaSerializable class PackageOwnershipException(txId: SecureHash, @Suppress("unused") val attachmentHash: AttachmentId, @Suppress("unused") val invalidClassName: String, val packageName: String) : TransactionVerificationException(txId, """The attachment JAR: $attachmentHash containing the class: $invalidClassName is not signed by the owner of package $packageName specified in the network parameters. Please check the source of this attachment and if it is malicious contact your zone operator to report this incident. For details see: https://docs.corda.net/network-map.html#network-parameters""".trimIndent(), null) @CordaSerializable class InvalidAttachmentException(txId: SecureHash, @Suppress("unused") val attachmentHash: AttachmentId) : TransactionVerificationException(txId, "The attachment $attachmentHash is not a valid ZIP or JAR file.".trimIndent(), null) // TODO: Make this descend from TransactionVerificationException so that untrusted attachments cause flows to be hospitalized. /** Thrown during classloading upon encountering an untrusted attachment (eg. not in the [TRUSTED_UPLOADERS] list) */ @KeepForDJVM @CordaSerializable class UntrustedAttachmentsException(val txId: SecureHash, val ids: List<SecureHash>) : CordaException("Attempting to load untrusted transaction attachments: $ids. " + "At this time these are not loadable because the DJVM sandbox has not yet been integrated. " + "You will need to manually install the CorDapp to whitelist it for use. " + "Please follow the operational steps outlined in https://docs.corda.net/cordapp-build-systems.html#cordapp-contract-attachments to learn more and continue.") /* If you add a new class extending [TransactionVerificationException], please add a test in `TransactionVerificationExceptionSerializationTests` proving that it can actually be serialised. As a rule, exceptions intended to be serialised _must_ have a corresponding readable property for every named constructor parameter - so make your constructor parameters `val`s even if nothing other than the serializer is ever going to read them. */ } MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException.ContractCreationError$internal constructor(txId: SecureHash, contractClass: String, cause: Throwable) : this(txId, contractClass, cause, cause.message ?: "") MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException.ContractRejection$internal constructor(txId: SecureHash, contract: Contract, cause: Throwable) : this(txId, contract.javaClass.name, cause, cause.message ?: "") - MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException.PackageOwnershipException$ Please check the source of this attachment and if it is malicious contact your zone operator to report this incident. MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException.PackageOwnershipException$"""The attachment JAR: $attachmentHash containing the class: $invalidClassName is not signed by the owner of package $packageName specified in the network parameters. Please check the source of this attachment and if it is malicious contact your zone operator to report this incident. For details see: https://docs.corda.net/network-map.html#network-parameters""" - MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException.TransactionNonMatchingEncumbranceException$"is not satisfied. Encumbered states should also be referenced as an encumbrance of another state to form " MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException.TransactionNotaryMismatchEncumbranceException$"Output state with index $encumberedIndex is assigned to notary [$encumberedNotary], while its encumbrance with index $encumbranceIndex is assigned to notary [$encumbranceNotary]" - MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException.TransactionRequiredContractUnspecifiedException$ Add the @BelongsToContract annotation to this class to ensure that it can only be bundled in a TransactionState MaxLineLength:TransactionVerificationException.kt$TransactionVerificationException.UntrustedAttachmentsException$"Please follow the operational steps outlined in https://docs.corda.net/cordapp-build-systems.html#cordapp-contract-attachments to learn more and continue." MaxLineLength:TransactionVerificationException.kt$net.corda.core.contracts.TransactionVerificationException.kt - MaxLineLength:TransactionVerificationExceptionSerialisationTests.kt$TransactionVerificationExceptionSerialisationTests$val exception = TransactionVerificationException.NotaryChangeInWrongTransactionType(txid, dummyBankA, dummyNotary) MaxLineLength:TransactionVerificationRequest.kt$TransactionVerificationRequest$@Suppress("MemberVisibilityCanBePrivate") //TODO the use of deprecated toLedgerTransaction need to be revisited as resolveContractAttachment requires attachments of the transactions which created input states... //TODO ...to check contract version non downgrade rule, curretly dummy Attachment if not fund is used which sets contract version to '1' @CordaSerializable - MaxLineLength:TransactionVerificationRequest.kt$TransactionVerificationRequest$attachments .mapNotNull { it as? MockContractAttachment } .associateBy(Attachment::id) { ContractAttachment(it, it.contract, uploader = DEPLOYED_CORDAPP_UPLOADER) } - MaxLineLength:TransactionVerifierService.kt$TransactionVerifierService$ fun verify(transaction: LedgerTransaction): CordaFuture<*> MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier - MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$ State of class MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$ private fun validateStatesAgainstContract() - MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$ private fun verifyConstraints(contractAttachmentsByContract: Map<ContractClassName, ContractAttachment>) MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$ private fun verifyConstraintsValidity(contractAttachmentsByContract: Map<ContractClassName, ContractAttachment>) - MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$// Using basic graph theory, a full cycle of encumbered (co-dependent) states should exist to achieve bi-directional // encumbrances. This property is important to ensure that no states involved in an encumbrance-relationship // can be spent on their own. Briefly, if any of the states is having more than one encumbrance references by // other states, a full cycle detection will fail. As a result, all of the encumbered states must be present // as "from" and "to" only once (or zero times if no encumbrance takes place). For instance, // a -> b // c -> b and a -> b // b -> a b -> c // do not satisfy the bi-directionality (full cycle) property. // // In the first example "b" appears twice in encumbrance ("to") list and "c" exists in the encumbered ("from") list only. // Due the above, one could consume "a" and "b" in the same transaction and then, because "b" is already consumed, "c" cannot be spent. // // Similarly, the second example does not form a full cycle because "a" and "c" exist in one of the lists only. // As a result, one can consume "b" and "c" in the same transactions, which will make "a" impossible to be spent. // // On other hand the following are valid constructions: // a -> b a -> c // b -> c and c -> b // c -> a b -> a // and form a full cycle, meaning that the bi-directionality property is satisfied. private fun checkBidirectionalOutputEncumbrances(statesAndEncumbrance: List<Pair<Int, Int>>) MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$?: - MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$checkMinimumPlatformVersion(ltx.networkParameters?.minimumPlatformVersion ?: 1, 4, "Signature constraints") MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$contractAttachmentsPerContract .groupBy { it.first } // Group by contract. .filter { (_, attachments) -> attachments.size > 1 } MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$if (contractWithMultipleAttachments != null) throw TransactionVerificationException.ConflictingAttachmentsRejection(ltx.id, contractWithMultipleAttachments) MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$if (ltx.attachments.size != ltx.attachments.toSet().size) throw TransactionVerificationException.DuplicateAttachmentsRejection(ltx.id, ltx.attachments.groupBy { it }.filterValues { it.size > 1 }.keys.first()) MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$if (result.keys != contractClasses) throw TransactionVerificationException.MissingAttachmentRejection(ltx.id, contractClasses.minus(result.keys).first()) - MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$throw TransactionVerificationException.NotaryChangeInWrongTransactionType(ltx.id, ltx.notary, it.notary) - MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$throw TransactionVerificationException.TransactionNonMatchingEncumbranceException(ltx.id, symmetricDifference) MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$val constraintAttachment = AttachmentWithContext(contractAttachment, contract, ltx.networkParameters!!.whitelistedContractImplementations) - MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$val inputConstraints = (inputContractGroups[contractClassName] ?: emptyList()).map { it.state.constraint }.toSet() - MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier$val outputConstraints = (outputContractGroups[contractClassName] ?: emptyList()).map { it.constraint }.toSet() MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier${ // checkNoNotaryChange and checkEncumbrancesValid are called here, and not in the c'tor, as they need access to the "outputs" // list, the contents of which need to be deserialized under the correct classloader. checkNoNotaryChange() checkEncumbrancesValid() // The following checks ensure the integrity of the current transaction and also of the future chain. // See: https://docs.corda.net/head/api-contract-constraints.html // A transaction contains both the data and the code that must be executed to validate the transition of the data. // Transactions can be created by malicious adversaries, who can try to use code that allows them to create transactions that appear valid but are not. // 1. Check that there is one and only one attachment for each relevant contract. val contractAttachmentsByContract = getUniqueContractAttachmentsByContract() // 2. Check that the attachments satisfy the constraints of the states. (The contract verification code is correct.) verifyConstraints(contractAttachmentsByContract) // 3. Check that the actual state constraints are correct. This is necessary because transactions can be built by potentially malicious nodes // who can create output states with a weaker constraint which can be exploited in a future transaction. verifyConstraintsValidity(contractAttachmentsByContract) // 4. Check that the [TransactionState] objects are correctly formed. validateStatesAgainstContract() // 5. Final step is to run the contract code. After the first 4 steps we are now sure that we are running the correct code. verifyContracts() } - MaxLineLength:TransactionVerifierServiceInternal.kt$Verifier${ if (!contractClassName.contractHasAutomaticConstraintPropagation(transactionClassLoader)) { contractClassName.warnContractWithoutConstraintPropagation() continue } val contractAttachment = contractAttachmentsByContract[contractClassName]!! // Verify that the constraints of output states have at least the same level of restriction as the constraints of the // corresponding input states. val inputConstraints = (inputContractGroups[contractClassName] ?: emptyList()).map { it.state.constraint }.toSet() val outputConstraints = (outputContractGroups[contractClassName] ?: emptyList()).map { it.constraint }.toSet() outputConstraints.forEach { outputConstraint -> inputConstraints.forEach { inputConstraint -> if (!(outputConstraint.canBeTransitionedFrom(inputConstraint, contractAttachment))) { throw TransactionVerificationException.ConstraintPropagationRejection( ltx.id, contractClassName, inputConstraint, outputConstraint) } } } } - MaxLineLength:TransactionViewer.kt$ private fun calculateTotalEquiv(myIdentity: Party?, reportingCurrencyExchange: Pair<Currency, (Amount<Currency>) -> Amount<Currency>>, inputs: List<ContractState>, outputs: List<ContractState>): AmountDiff<Currency> - MaxLineLength:TransactionViewer.kt$TransactionViewer$"Input Party" to { tx, s -> tx.inputParties.any { it.any { it.value?.name?.organisation?.contains(s, true) == true } } } - MaxLineLength:TransactionViewer.kt$TransactionViewer$"Output Party" to { tx, s -> tx.outputParties.any { it.any { it.value?.name?.organisation?.contains(s, true) == true } } } - MaxLineLength:TransactionViewer.kt$TransactionViewer$// Column stays the same size, but we don't violate column restricted resize policy for the whole table view. // It removes that irritating column at the end of table that does nothing. minWidth = 26.0 maxWidth = 26.0 - MaxLineLength:TransactionViewer.kt$TransactionViewer$Inputs - MaxLineLength:TransactionViewer.kt$TransactionViewer$Outputs - MaxLineLength:TransactionViewer.kt$TransactionViewer$Transaction MaxLineLength:TransactionViewer.kt$TransactionViewer$private MaxLineLength:TransactionViewer.kt$TransactionViewer$private fun ObservableList<StateAndRef<ContractState>>.getParties() MaxLineLength:TransactionViewer.kt$TransactionViewer$private fun ObservableList<StateAndRef<ContractState>>.toText() - MaxLineLength:TransactionViewer.kt$TransactionViewer$val commands = if (it.transaction.coreTransaction is WireTransaction) it.transaction.tx.commands else emptyList() MaxLineLength:TransactionViewer.kt$TransactionViewer.ContractStatesView$copyableLabel(party.map { "${signature.toStringShort()} (${it?.let { PartyNameFormatter.short.format(it.name) } ?: "Anonymous"})" }) MaxLineLength:TransactionViewer.kt$TransactionViewer.ContractStatesView$label - MaxLineLength:TransactionViewer.kt$TransactionViewer.ContractStatesView$val issuer: AbstractParty = anonymousIssuer.owningKey.toKnownParty().value ?: anonymousIssuer - MaxLineLength:TransactionViewer.kt$TransactionViewer.TransactionWidget$private val partiallyResolvedTransactions by observableListReadOnly(TransactionDataModel::partiallyResolvedTransactions) MaxLineLength:TransactionViewer.kt$outputs.mapNotNull { it as? Cash.State } .filter { it.amount.token.issuer.party.owningKey.toKnownParty().value == myIdentity && it.owner.owningKey.toKnownParty().value != myIdentity } MaxLineLength:TransactionWithSignatures.kt$TransactionWithSignatures${ val sigKeys = sigs.map { it.by }.toSet() // TODO Problem is that we can get single PublicKey wrapped as CompositeKey in allowedToBeMissing/mustSign // equals on CompositeKey won't catch this case (do we want to single PublicKey be equal to the same key wrapped in CompositeKey with threshold 1?) return requiredSigningKeys.filter { !it.isFulfilledBy(sigKeys) }.toSet() } - MaxLineLength:TransformsSchema.kt$TransformsAnnotationProcessor - MaxLineLength:TransformsSchema.kt$TransformsAnnotationProcessor$private - MaxLineLength:TransitionBuilder.kt$CannotFindSessionException : IllegalStateException - MaxLineLength:TransitionExecutor.kt$TransitionExecutor$ fun forceRemoveFlow(id: StateMachineRunId) - MaxLineLength:TransitionExecutorImpl.kt$TransitionExecutorImpl$log.warn("Error while executing $action during transition to errored state, aborting transition", exception) - MaxLineLength:TransitionExecutorImpl.kt$TransitionExecutorImpl${ // If we errored while transitioning to an error state then we cannot record the additional // error as that may result in an infinite loop, e.g. error propagation fails -> record error -> propagate fails again. // Instead we just keep around the old error state and wait for a new schedule, perhaps // triggered from a flow hospital log.warn("Error while executing $action during transition to errored state, aborting transition", exception) return Pair(FlowContinuation.Abort, previousState.copy(isFlowResumed = false)) } - MaxLineLength:Try.kt$Try$ fun doOnFailure(action: Consumer<Throwable>): Try<A> - MaxLineLength:Try.kt$Try$ fun doOnSuccess(action: Consumer<in A>): Try<A> - MaxLineLength:Try.kt$Try$ inline fun <B> flatMap(function: (A) -> Try<B>): Try<B> - MaxLineLength:Try.kt$Try.Companion$ @JvmStatic inline fun <T> on(body: () -> T): Try<T> - MaxLineLength:TutorialContract.kt$CommercialPaper$"output states are issued by a command signer" using (output.issuance.party.owningKey in command.signers) - MaxLineLength:TutorialContract.kt$CommercialPaper$"the transaction is signed by the owner of the CP" using (input.owner.owningKey in command.signers) - MaxLineLength:TutorialContract.kt$CommercialPaper$return TransactionBuilder(notary = notary).withItems(stateAndContract, Command(Commands.Issue(), issuance.party.owningKey)) - MaxLineLength:TutorialContract.kt$State$override fun withNewOwner(newOwner: AbstractParty) - MaxLineLength:TutorialFlowStateMachines.kt$TwoPartyTradeFlow.Seller$override val progressTracker: ProgressTracker = TwoPartyTradeFlow.Seller.tracker() MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Acceptor$override MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Acceptor$return Triple(ptx, arrayListOf(deal.participants.single { it is Party && serviceHub.myInfo.isLegalIdentity(it) }.owningKey), emptyList()) - MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Handshake$@CordaSerializable data - MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Primary$abstract MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Secondary$@Suspendable protected abstract - MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Secondary$abstract MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Secondary$require(wellKnownMe == ourIdentity){"Well known party for handshake identity ${it.secondaryIdentity} does not match ourIdentity"} MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Secondary$require(wellKnownOtherParty == otherSideSession.counterparty){"Well known party for handshake identity ${it.primaryIdentity} does not match counterparty"} - MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Secondary$serviceHub.signInitialTransaction(utx, additionalSigningPubKeys).withAdditionalSignatures(additionalSignatures) - MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Secondary$val ptxSignedByOtherSide = ptx + subFlow(CollectSignatureFlow(ptx, otherSideSession, otherSideSession.counterparty.owningKey)) MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Secondary$val sessionsForOtherSigners = excludeNotary(groupPublicKeysByWellKnownParty(serviceHub, ptxSignedByOtherSide.getMissingSigners()), ptxSignedByOtherSide).map { initiateFlow(it.key) } - MaxLineLength:TwoPartyDealFlow.kt$TwoPartyDealFlow.Secondary$val stx = subFlow(CollectSignaturesFlow(ptxSignedByOtherSide, sessionsForOtherSigners, additionalSigningPubKeys)) - MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow${ // TODO: Common elements in multi-party transaction consensus and signing should be refactored into a superclass of this // and [AbstractStateReplacementFlow]. class UnacceptablePriceException(givenPrice: Amount<Currency>) : FlowException("Unacceptable price: $givenPrice") class AssetMismatchException(val expectedTypeName: String, val typeName: String) : FlowException() { override fun toString() = "The submitted asset didn't match the expected type: $expectedTypeName vs $typeName" } /** * This object is serialised to the network and is the first flow message the seller sends to the buyer. * * @param payToIdentity anonymous identity of the seller, for payment to be sent to. */ @CordaSerializable data class SellerTradeInfo( val price: Amount<Currency>, val payToIdentity: PartyAndCertificate ) open class Seller(private val otherSideSession: FlowSession, private val assetToSell: StateAndRef<OwnableState>, private val price: Amount<Currency>, private val myParty: PartyAndCertificate, // TODO Left because in tests it's used to pass anonymous party. override val progressTracker: ProgressTracker = Seller.tracker()) : FlowLogic<SignedTransaction>() { companion object { object AWAITING_PROPOSAL : ProgressTracker.Step("Awaiting transaction proposal") // DOCSTART 3 object VERIFYING_AND_SIGNING : ProgressTracker.Step("Verifying and signing transaction proposal") { override fun childProgressTracker() = SignTransactionFlow.tracker() } // DOCEND 3 fun tracker() = ProgressTracker(AWAITING_PROPOSAL, VERIFYING_AND_SIGNING) } // DOCSTART 4 @Suspendable override fun call(): SignedTransaction { progressTracker.currentStep = AWAITING_PROPOSAL // Make the first message we'll send to kick off the flow. val hello = SellerTradeInfo(price, myParty) // What we get back from the other side is a transaction that *might* be valid and acceptable to us, // but we must check it out thoroughly before we sign! // SendTransactionFlow allows seller to access our data to resolve the transaction. subFlow(SendStateAndRefFlow(otherSideSession, listOf(assetToSell))) otherSideSession.send(hello) // Verify and sign the transaction. progressTracker.currentStep = VERIFYING_AND_SIGNING // DOCSTART 07 // Sync identities to ensure we know all of the identities involved in the transaction we're about to // be asked to sign subFlow(IdentitySyncFlow.Receive(otherSideSession)) // DOCEND 07 // DOCSTART 5 val signTransactionFlow = object : SignTransactionFlow(otherSideSession, VERIFYING_AND_SIGNING.childProgressTracker()) { override fun checkTransaction(stx: SignedTransaction) { // Verify that we know who all the participants in the transaction are val states: Iterable<ContractState> = serviceHub.loadStates(stx.tx.inputs.toSet()).map { it.state.data } + stx.tx.outputs.map { it.data } states.forEach { state -> state.participants.forEach { anon -> require(serviceHub.identityService.wellKnownPartyFromAnonymous(anon) != null) { "Transaction state $state involves unknown participant $anon" } } } if (stx.tx.outputStates.sumCashBy(myParty.party).withoutIssuer() != price) throw FlowException("Transaction is not sending us the right amount of cash") } } val txId = subFlow(signTransactionFlow).id // DOCEND 5 return subFlow(ReceiveFinalityFlow(otherSideSession, expectedTxId = txId)) } // DOCEND 4 // Following comment moved here so that it doesn't appear in the docsite: // There are all sorts of funny games a malicious secondary might play with it sends maybeSTX, // we should fix them: // // - This tx may attempt to send some assets we aren't intending to sell to the secondary, if // we're reusing keys! So don't reuse keys! // - This tx may include output states that impose odd conditions on the movement of the cash, // once we implement state pairing. // // but the goal of this code is not to be fully secure (yet), but rather, just to find good ways to // express flow state machines on top of the messaging layer. } open class Buyer(private val sellerSession: FlowSession, private val notary: Party, private val acceptablePrice: Amount<Currency>, private val typeToBuy: Class<out OwnableState>, private val anonymous: Boolean) : FlowLogic<SignedTransaction>() { constructor(otherSideSession: FlowSession, notary: Party, acceptablePrice: Amount<Currency>, typeToBuy: Class<out OwnableState>) : this(otherSideSession, notary, acceptablePrice, typeToBuy, true) // DOCSTART 2 object RECEIVING : ProgressTracker.Step("Waiting for seller trading info") object VERIFYING : ProgressTracker.Step("Verifying seller assets") object SIGNING : ProgressTracker.Step("Generating and signing transaction proposal") object COLLECTING_SIGNATURES : ProgressTracker.Step("Collecting signatures from other parties") { override fun childProgressTracker() = CollectSignaturesFlow.tracker() } object RECORDING : ProgressTracker.Step("Recording completed transaction") { // TODO: Currently triggers a race condition on Team City. See https://github.com/corda/corda/issues/733. // override fun childProgressTracker() = FinalityFlow.tracker() } override val progressTracker = ProgressTracker(RECEIVING, VERIFYING, SIGNING, COLLECTING_SIGNATURES, RECORDING) // DOCEND 2 // DOCSTART 1 @Suspendable override fun call(): SignedTransaction { // Wait for a trade request to come in from the other party. progressTracker.currentStep = RECEIVING val (assetForSale, tradeRequest) = receiveAndValidateTradeRequest() // Create the identity we'll be paying to, and send the counterparty proof we own the identity val buyerAnonymousIdentity = if (anonymous) serviceHub.keyManagementService.freshKeyAndCert(ourIdentityAndCert, false) else ourIdentityAndCert // Put together a proposed transaction that performs the trade, and sign it. progressTracker.currentStep = SIGNING val (ptx, cashSigningPubKeys) = assembleSharedTX(assetForSale, tradeRequest, buyerAnonymousIdentity) // DOCSTART 6 // Now sign the transaction with whatever keys we need to move the cash. val partSignedTx = serviceHub.signInitialTransaction(ptx, cashSigningPubKeys) // Sync up confidential identities in the transaction with our counterparty subFlow(IdentitySyncFlow.Send(sellerSession, ptx.toWireTransaction(serviceHub))) // Send the signed transaction to the seller, who must then sign it themselves and commit // it to the ledger by sending it to the notary. progressTracker.currentStep = COLLECTING_SIGNATURES val sellerSignature = subFlow(CollectSignatureFlow(partSignedTx, sellerSession, sellerSession.counterparty.owningKey)) val twiceSignedTx = partSignedTx + sellerSignature // DOCEND 6 // Notarise and record the transaction. progressTracker.currentStep = RECORDING return subFlow(FinalityFlow(twiceSignedTx, sellerSession)) } @Suspendable private fun receiveAndValidateTradeRequest(): Pair<StateAndRef<OwnableState>, SellerTradeInfo> { val assetForSale = subFlow(ReceiveStateAndRefFlow<OwnableState>(sellerSession)).single() return assetForSale to sellerSession.receive<SellerTradeInfo>().unwrap { progressTracker.currentStep = VERIFYING // What is the seller trying to sell us? val asset = assetForSale.state.data val assetTypeName = asset.javaClass.name // The asset must either be owned by the well known identity of the counterparty, or we must be able to // prove the owner is a confidential identity of the counterparty. val assetForSaleIdentity = serviceHub.identityService.wellKnownPartyFromAnonymous(asset.owner) require(assetForSaleIdentity == sellerSession.counterparty){"Well known identity lookup returned identity that does not match counterparty"} // Register the identity we're about to send payment to. This shouldn't be the same as the asset owner // identity, so that anonymity is enforced. val wellKnownPayToIdentity = serviceHub.identityService.verifyAndRegisterIdentity(it.payToIdentity) ?: it.payToIdentity require(wellKnownPayToIdentity.party == sellerSession.counterparty) { "Well known identity to pay to must match counterparty identity" } if (it.price > acceptablePrice) throw UnacceptablePriceException(it.price) if (!typeToBuy.isInstance(asset)) throw AssetMismatchException(typeToBuy.name, assetTypeName) it } } @Suspendable private fun assembleSharedTX(assetForSale: StateAndRef<OwnableState>, tradeRequest: SellerTradeInfo, buyerAnonymousIdentity: PartyAndCertificate): SharedTx { val ptx = TransactionBuilder(notary) // Add input and output states for the movement of cash, by using the Cash contract to generate the states val (tx, cashSigningPubKeys) = CashUtils.generateSpend(serviceHub, ptx, tradeRequest.price, ourIdentityAndCert, tradeRequest.payToIdentity.party) // Add inputs/outputs/a command for the movement of the asset. tx.addInputState(assetForSale) val (command, state) = assetForSale.state.data.withNewOwner(buyerAnonymousIdentity.party) tx.addOutputState(state, assetForSale.state.contract, assetForSale.state.notary) tx.addCommand(command, assetForSale.state.data.owner.owningKey) // We set the transaction's time-window: it may be that none of the contracts need this! // But it can't hurt to have one. val currentTime = serviceHub.clock.instant() tx.setTimeWindow(currentTime, 30.seconds) return SharedTx(tx, cashSigningPubKeys) } // DOCEND 1 data class SharedTx(val tx: TransactionBuilder, val cashSigningPubKeys: List<PublicKey>) } } MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Buyer$@Suspendable private - MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Buyer$constructor(otherSideSession: FlowSession, notary: Party, acceptablePrice: Amount<Currency>, typeToBuy: Class<out OwnableState>) : this(otherSideSession, notary, acceptablePrice, typeToBuy, true) MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Buyer$require(assetForSaleIdentity == sellerSession.counterparty){"Well known identity lookup returned identity that does not match counterparty"} MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Buyer$require(wellKnownPayToIdentity.party == sellerSession.counterparty) { "Well known identity to pay to must match counterparty identity" } MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Buyer$val (tx, cashSigningPubKeys) = CashUtils.generateSpend(serviceHub, ptx, tradeRequest.price, ourIdentityAndCert, tradeRequest.payToIdentity.party) - MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Buyer$val sellerSignature = subFlow(CollectSignatureFlow(partSignedTx, sellerSession, sellerSession.counterparty.owningKey)) - MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Buyer$val wellKnownPayToIdentity = serviceHub.identityService.verifyAndRegisterIdentity(it.payToIdentity) ?: it.payToIdentity - MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Seller$override val progressTracker: ProgressTracker = Seller.tracker() - MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Seller$private val myParty: PartyAndCertificate - MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Seller$val signTransactionFlow = object : SignTransactionFlow(otherSideSession, VERIFYING_AND_SIGNING.childProgressTracker()) { override fun checkTransaction(stx: SignedTransaction) { // Verify that we know who all the participants in the transaction are val states: Iterable<ContractState> = serviceHub.loadStates(stx.tx.inputs.toSet()).map { it.state.data } + stx.tx.outputs.map { it.data } states.forEach { state -> state.participants.forEach { anon -> require(serviceHub.identityService.wellKnownPartyFromAnonymous(anon) != null) { "Transaction state $state involves unknown participant $anon" } } } if (stx.tx.outputStates.sumCashBy(myParty.party).withoutIssuer() != price) throw FlowException("Transaction is not sending us the right amount of cash") } } MaxLineLength:TwoPartyTradeFlow.kt$TwoPartyTradeFlow.Seller.<no name provided>$val states: Iterable<ContractState> = serviceHub.loadStates(stx.tx.inputs.toSet()).map { it.state.data } + stx.tx.outputs.map { it.data } - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$( // Buyer Bob is told about Alice's commercial paper, but doesn't know it .. expect(TxRecord.Get(alicesFakePaper[0].id)), // He asks and gets the tx, validates it, sees it's a self issue with no dependencies, stores. expect(TxRecord.Add(alicesSignedTxns.values.first())), // Alice gets Bob's proposed transaction and doesn't know his two cash states. She asks, Bob answers. expect(TxRecord.Get(bobsFakeCash[1].id)), expect(TxRecord.Get(bobsFakeCash[2].id)), // Alice notices that Bob's cash txns depend on a third tx she also doesn't know. She asks, Bob answers. expect(TxRecord.Get(bobsFakeCash[0].id)) ) MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$( // Seller Alice sends her seller info to Bob, who wants to check the asset for sale. // He requests, Alice looks up in her DB to send the tx to Bob expect(TxRecord.Get(alicesFakePaper[0].id)), // Seller Alice gets a proposed tx which depends on Bob's two cash txns and her own tx. expect(TxRecord.Get(bobsFakeCash[1].id)), expect(TxRecord.Get(bobsFakeCash[2].id)), expect(TxRecord.Get(alicesFakePaper[0].id)), // Alice notices that Bob's cash txns depend on a third tx she also doesn't know. expect(TxRecord.Get(bobsFakeCash[0].id)), // Bob answers with the transactions that are now all verifiable, as Alice bottomed out. // Bob's transactions are valid, so she commits to the database //expect(TxRecord.Add(bobsSignedTxns[bobsFakeCash[0].id]!!)), //TODO investigate missing event after introduction of signature constraints non-downgrade rule expect(TxRecord.Get(bobsFakeCash[0].id)), // Verify expect(TxRecord.Add(bobsSignedTxns[bobsFakeCash[2].id]!!)), expect(TxRecord.Get(bobsFakeCash[0].id)), // Verify expect(TxRecord.Add(bobsSignedTxns[bobsFakeCash[1].id]!!)), // Now she verifies the transaction is contract-valid (not signature valid) which means // looking up the states again. expect(TxRecord.Get(bobsFakeCash[1].id)), expect(TxRecord.Get(bobsFakeCash[2].id)), expect(TxRecord.Get(alicesFakePaper[0].id)), // Alice needs to look up the input states to find out which Notary they point to expect(TxRecord.Get(bobsFakeCash[1].id)), expect(TxRecord.Get(bobsFakeCash[2].id)), expect(TxRecord.Get(alicesFakePaper[0].id)) ) - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$// Insert a prospectus type attachment into the commercial paper transaction. val stream = ByteArrayOutputStream() JarOutputStream(stream).use { it.putNextEntry(ZipEntry("Prospectus.txt")) it.write("Our commercial paper is top notch stuff".toByteArray()) it.closeEntry() } val attachmentID = aliceNode.database.transaction { attachment(stream.toByteArray().inputStream()) } val bobsKey = bobNode.services.keyManagementService.keys.single() val bobsFakeCash = bobNode.database.transaction { fillUpForBuyerAndInsertFakeTransactions(false, issuer, AnonymousParty(bobsKey), notary, bobNode, bob, notaryNode, bankNode) }.second val alicesFakePaper = aliceNode.database.transaction { fillUpForSeller(false, issuer, alice, 1200.DOLLARS `issued by` bank.ref(0), attachmentID, notary).second } insertFakeTransactions(alicesFakePaper, aliceNode, alice, notaryNode, bankNode) val aliceTxStream = aliceNode.services.validatedTransactions.track().updates val aliceTxMappings = with(aliceNode) { database.transaction { services.stateMachineRecordedTransactionMapping.track().updates } } val aliceSmId = runBuyerAndSeller(notary, bob, aliceNode, bobNode, "alice's paper".outputStateAndRef()).sellerId mockNet.runNetwork() // We need to declare this here, if we do it inside [expectEvents] kotlin throws an internal compiler error(!). val aliceTxExpectations = sequence( expect { tx: SignedTransaction -> require(tx.id == bobsFakeCash[0].id) }, expect { tx: SignedTransaction -> require(tx.id == bobsFakeCash[2].id) }, expect { tx: SignedTransaction -> require(tx.id == bobsFakeCash[1].id) } ) aliceTxStream.expectEvents { aliceTxExpectations } val aliceMappingExpectations = sequence( expect<StateMachineTransactionMapping> { (stateMachineRunId, transactionId) -> require(stateMachineRunId == aliceSmId) require(transactionId == bobsFakeCash[0].id) }, expect<StateMachineTransactionMapping> { (stateMachineRunId, transactionId) -> require(stateMachineRunId == aliceSmId) require(transactionId == bobsFakeCash[2].id) }, expect { (stateMachineRunId, transactionId) -> require(stateMachineRunId == aliceSmId) require(transactionId == bobsFakeCash[1].id) } ) aliceTxMappings.expectEvents { aliceMappingExpectations } - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$SignableData(id, SignatureMetadata(1, Crypto.findSignatureScheme(notaryParty.owningKey).schemeNumberID)) MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$VaultFiller(bobNode.services, dummyNotary, notary, ::Random).fillWithSomeTestCash(2000.DOLLARS, bankNode.services, 3, 10, cashIssuer) MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$VaultFiller(bobNode.services, dummyNotary, notary, ::Random).fillWithSomeTestCash(2000.DOLLARS, bankNode.services, 3, 10, issuer) MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$VaultFiller(bobNode.services, dummyNotary, notary, ::Random).fillWithSomeTestCash(2000.DOLLARS, bankNode.services, 3, issuer) - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$fillUpForBuyerAndInsertFakeTransactions(bobError, issuer, bob, notary, bobNode, bob, notaryNode, bankNode).second MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$fillUpForBuyerAndInsertFakeTransactions(false, issuer, AnonymousParty(bob.owningKey), notary, bobNode, bob, notaryNode, bankNode) - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$fillUpForBuyerAndInsertFakeTransactions(false, issuer, AnonymousParty(bobsKey), notary, bobNode, bob, notaryNode, bankNode) - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$output(Cash.PROGRAM_ID, "bob cash 1", notary = notary, contractState = 800.DOLLARS.CASH issuedBy issuer ownedBy owner) - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$output(Cash.PROGRAM_ID, "bob cash 2", notary = notary, contractState = 300.DOLLARS.CASH issuedBy issuer ownedBy owner) MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$output(Cash.PROGRAM_ID, "elbonian money 1", notary = notary, contractState = 800.DOLLARS.CASH issuedBy issuer ownedBy interimOwner) MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$output(Cash.PROGRAM_ID, "elbonian money 2", notary = notary, contractState = 1000.DOLLARS.CASH issuedBy issuer ownedBy interimOwner) MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$output(Cash.PROGRAM_ID, notary = notary, contractState = 700.DOLLARS.CASH issuedBy issuer ownedBy interimOwner) - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$private - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$val (bobStateMachine, aliceResult) = runBuyerAndSeller(notary, bob, aliceNode, bobNode, "alice's paper".outputStateAndRef()) - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$val aliceFuture = runBuyerAndSeller(notary, bob, aliceNode, bobNode, "alice's paper".outputStateAndRef()).sellerResult - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests$val aliceNode = mockNet.createPartyNode(ALICE_NAME) var bobNode = mockNet.createPartyNode(BOB_NAME) val bankNode = mockNet.createPartyNode(BOC_NAME) aliceNode.internals.disableDBCloseOnStop() bobNode.internals.disableDBCloseOnStop() val bobAddr = bobNode.network.myAddress mockNet.runNetwork() // Clear network map registration messages val alice = aliceNode.info.singleIdentity() val bank = bankNode.info.singleIdentity() val bob = bobNode.info.singleIdentity() val issuer = bank.ref(1, 2, 3) bobNode.database.transaction { VaultFiller(bobNode.services, dummyNotary, notary, ::Random).fillWithSomeTestCash(2000.DOLLARS, bankNode.services, 3, 10, issuer) } val alicesFakePaper = aliceNode.database.transaction { fillUpForSeller(false, issuer, alice, 1200.DOLLARS `issued by` bank.ref(0), null, notary).second } insertFakeTransactions(alicesFakePaper, aliceNode, alice, notaryNode, bankNode) val aliceFuture = runBuyerAndSeller(notary, bob, aliceNode, bobNode, "alice's paper".outputStateAndRef()).sellerResult // Everything is on this thread so we can now step through the flow one step at a time. // Seller Alice already sent a message to Buyer Bob. Pump once: bobNode.pumpReceive() // Bob sends a couple of queries for the dependencies back to Alice. Alice reponds. aliceNode.pumpReceive() bobNode.pumpReceive() aliceNode.pumpReceive() bobNode.pumpReceive() aliceNode.pumpReceive() bobNode.pumpReceive() // OK, now Bob has sent the partial transaction back to Alice and is waiting for Alice's signature. bobNode.database.transaction { assertThat(bobNode.internals.checkpointStorage.checkpoints()).hasSize(1) } val storage = bobNode.services.validatedTransactions val bobTransactionsBeforeCrash = bobNode.database.transaction { (storage as DBTransactionStorage).transactions } assertThat(bobTransactionsBeforeCrash).isNotEmpty // .. and let's imagine that Bob's computer has a power cut. He now has nothing now beyond what was on disk. bobNode.dispose() // Alice doesn't know that and carries on: she wants to know about the cash transactions he's trying to use. // She will wait around until Bob comes back. assertThat(aliceNode.pumpReceive()).isNotNull() // FIXME: Knowledge of confidential identities is lost on node shutdown, so Bob's node now refuses to sign the // transaction because it has no idea who the parties are. // ... bring the node back up ... the act of constructing the SMM will re-register the message handlers // that Bob was waiting on before the reboot occurred. bobNode = mockNet.createNode(InternalMockNodeParameters(bobAddr.id, BOB_NAME)) // Find the future representing the result of this state machine again. val bobFuture = bobNode.smm.findStateMachines(BuyerAcceptor::class.java).single().second // And off we go again. mockNet.runNetwork() // Bob is now finished and has the same transaction as Alice. assertThat(bobFuture.getOrThrow()).isEqualTo(aliceFuture.getOrThrow()) assertThat(bobNode.smm.findStateMachines(Buyer::class.java)).isEmpty() bobNode.database.transaction { assertThat(bobNode.internals.checkpointStorage.checkpoints()).isEmpty() } aliceNode.database.transaction { assertThat(aliceNode.internals.checkpointStorage.checkpoints()).isEmpty() } bobNode.database.transaction { val restoredBobTransactions = bobTransactionsBeforeCrash.filter { bobNode.services.validatedTransactions.getTransaction(it.id) != null } assertThat(restoredBobTransactions).containsAll(bobTransactionsBeforeCrash) } aliceNode.internals.manuallyCloseDB() bobNode.internals.manuallyCloseDB() - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests.<no name provided>$return RecordingTransactionStorage(database, super.makeTransactionStorage(transactionCacheSizeBytes)) - MaxLineLength:TwoPartyTradeFlowTests.kt$TwoPartyTradeFlowTests.BuyerAcceptor$require(serviceHub.networkMapCache.isNotary(it.notaryIdentity)) { "${it.notaryIdentity} is not a notary" } - MaxLineLength:TypeIdentifier.kt$TypeIdentifier.Companion$ fun forGenericType(type: Type, resolutionContext: Type = type): TypeIdentifier - MaxLineLength:TypeIdentifier.kt$TypeIdentifier.Companion$is GenericArrayType -> ArrayOf(forGenericType(type.genericComponentType.resolveAgainst(resolutionContext))) MaxLineLength:TypeIdentifier.kt$TypeIdentifier.Parameterised$data - MaxLineLength:TypeLoader.kt$ClassCarpentingTypeLoader : TypeLoader - MaxLineLength:TypeLoader.kt$TypeLoader$ fun load(remoteTypeInformation: Collection<RemoteTypeInformation>, context: SerializationContext): Map<TypeIdentifier, Type> MaxLineLength:TypeModellingFingerPrinter.kt$FingerPrintingState$val customTypeDescriptor = customSerializerRegistry.findCustomSerializer(type.observedType.asClass(), type.observedType)?.typeDescriptor?.toString() - MaxLineLength:TypeModellingFingerPrinter.kt$FingerPrintingState$writer.writeAlreadySeen() MaxLineLength:TypeParameterUtils.kt$private MaxLineLength:TypeParameterUtils.kt${ if (declaredClass == actualClass) { return null } if (actualClass.typeParameters.isEmpty()) { return actualClass } // The actual class can never have type variables resolved, due to the JVM's use of type erasure, so let's try and resolve them // Search for declared type in the inheritance hierarchy and then see if that fills in all the variables val implementationChain: List<Type> = findPathToDeclared(actualClass, declaredType)?.toList() ?: throw AMQPNotSerializableException( declaredType, "No inheritance path between actual $actualClass and declared $declaredType.") val start = implementationChain.last() val rest = implementationChain.dropLast(1).drop(1) val resolver = rest.reversed().fold(TypeResolver().where(start, declaredType)) { resolved, chainEntry -> val newResolved = resolved.resolveType(chainEntry) TypeResolver().where(chainEntry, newResolved) } // The end type is a special case as it is a Class, so we need to fake up a ParameterizedType for it to get the TypeResolver to do anything. val endType = actualClass.asParameterizedType() return resolver.resolveType(endType) } - MaxLineLength:TypesafeCordappConfigTests.kt$TypesafeCordappConfigTests$val config = ConfigFactory.parseString("string=string\nint=1\nfloat=1.0\ndouble=1.0\nnumber=2\ndouble=1.01\nbool=false") MaxLineLength:UniqueDummyFungibleContract.kt$UniqueDummyFungibleContract.State$override fun withNewOwnerAndAmount(newAmount: Amount<Issued<Currency>>, newOwner: AbstractParty): FungibleAsset<Currency> - MaxLineLength:UniqueDummyFungibleContract.kt$UniqueDummyFungibleContract.State$return UniqueDummyFungibleStateSchema.UniquePersistentDummyFungibleState(currency = amount.token.product.currencyCode) MaxLineLength:UniqueDummyFungibleContract.kt$UniqueDummyFungibleStateSchema : MappedSchema MaxLineLength:UniqueDummyLinearContract.kt$UniqueDummyLinearStateSchema : MappedSchema MaxLineLength:UniqueIdentifier.kt$UniqueIdentifier$@CordaSerializable @KeepForDJVM data MaxLineLength:UniquenessProviderTests.kt$PersistentUniquenessProviderFactory$database = configureDatabase(makeTestDataSourceProperties(), DatabaseConfig(), { null }, { null }, NodeSchemaService(extraSchemas = setOf(NodeNotarySchemaV1))) MaxLineLength:UniquenessProviderTests.kt$RaftUniquenessProviderFactory$database = configureDatabase(makeTestDataSourceProperties(), DatabaseConfig(), { null }, { null }, NodeSchemaService(extraSchemas = setOf(RaftNotarySchemaV1))) - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$private val requestSignature = NotarisationRequestSignature(DigitalSignature.WithKey(NullKeys.NullPublicKey, ByteArray(32)), 0) - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val response: UniquenessProvider.Result = uniquenessProvider.commit(inputs, secondTxId, identity, requestSignature).get() MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val response: UniquenessProvider.Result = uniquenessProvider.commit(inputs, secondTxId, identity, requestSignature, invalidTimeWindow) .get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val response: UniquenessProvider.Result = uniquenessProvider.commit(inputs, secondTxId, identity, requestSignature, timeWindow) .get() MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result = uniquenessProvider.commit(emptyList(), firstTxId, identity, requestSignature, invalidTimeWindow, references = listOf(referenceState)) .get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result = uniquenessProvider.commit(emptyList(), firstTxId, identity, requestSignature, references = listOf(referenceState)) .get() MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result = uniquenessProvider.commit(emptyList(), firstTxId, identity, requestSignature, timeWindow, references = listOf(referenceState)) .get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result = uniquenessProvider.commit(listOf(inputState), firstTxId, identity, requestSignature, references = emptyList()).get() MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result = uniquenessProvider.commit(listOf(inputState), firstTxId, identity, requestSignature, timeWindow, references = listOf(referenceState)) .get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result = uniquenessProvider.commit(listOf(inputState), txID, identity, requestSignature, invalidTimeWindow).get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result = uniquenessProvider.commit(listOf(inputState1), firstTxId, identity, requestSignature, invalidTimeWindow).get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result = uniquenessProvider.commit(listOf(inputState1), firstTxId, identity, requestSignature, timeWindow).get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result = uniquenessProvider.commit(listOf(referenceState), firstTxId, identity, requestSignature, references = emptyList()) .get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result2 = uniquenessProvider.commit(emptyList(), firstTxId, identity, requestSignature, references = listOf(referenceState)) .get() MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result2 = uniquenessProvider.commit(emptyList(), secondTxId, identity, requestSignature, invalidTimeWindow, references = listOf(referenceState)) .get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result2 = uniquenessProvider.commit(emptyList(), secondTxId, identity, requestSignature, references = listOf(referenceState)) .get() MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result2 = uniquenessProvider.commit(emptyList(), secondTxId, identity, requestSignature, timeWindow, references = listOf(referenceState)) .get() MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result2 = uniquenessProvider.commit(listOf(inputState), firstTxId, identity, requestSignature, timeWindow, references = listOf(referenceState)) .get() MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result2 = uniquenessProvider.commit(listOf(inputState), secondTxId, identity, requestSignature, timeWindow, references = listOf(referenceState)) .get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result2 = uniquenessProvider.commit(listOf(inputState1), firstTxId, identity, requestSignature, timeWindow).get() - MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result2 = uniquenessProvider.commit(listOf(referenceState), SecureHash.randomSHA256(), identity, requestSignature, timeWindow) .get() MaxLineLength:UniquenessProviderTests.kt$UniquenessProviderTests$val result3 = uniquenessProvider.commit(emptyList(), firstTxId, identity, requestSignature, timeWindow, references = listOf(referenceState)) .get() - MaxLineLength:UniversalContract.kt$UniversalContract$"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 evalBoolean(tx, action.condition) - MaxLineLength:UniversalContract.kt$UniversalContract$"the transaction is signed by all liable parties" using (liableParties(outState.details).all { it in cmd.signers }) MaxLineLength:UniversalContract.kt$UniversalContract$Action(arr.name, replaceFixing(tx, arr.condition, fixings, unusedFixings), replaceFixing(tx, arr.arrangement, fixings, unusedFixings)) - MaxLineLength:UniversalContract.kt$UniversalContract$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)]!!)) } else perceivable MaxLineLength:UniversalContract.kt$UniversalContract$is Actions -> Actions(arr.actions.map { Action(it.name, it.condition, replaceFixing(tx, it.arrangement, fixings, unusedFixings)) }.toSet()) - MaxLineLength:UniversalContract.kt$UniversalContract$is Actions -> Actions(arrangement.actions.map { Action(it.name, it.condition, removeNext(it.arrangement)) }.toSet()) MaxLineLength:UniversalContract.kt$UniversalContract$is Actions -> Actions(arrangement.actions.map { Action(it.name, it.condition, replaceNext(it.arrangement, nextReplacement)) }.toSet()) MaxLineLength:UniversalContract.kt$UniversalContract$is Actions -> Actions(arrangement.actions.map { Action(it.name, replaceStartEnd(it.condition, start, end), replaceStartEnd(it.arrangement, start, end)) }.toSet()) MaxLineLength:UniversalContract.kt$UniversalContract$is Interest -> uncheckedCast(Interest(replaceStartEnd(p.amount, start, end), p.dayCountConvention, replaceStartEnd(p.interest, start, end), replaceStartEnd(p.start, start, end), replaceStartEnd(p.end, start, end))) - MaxLineLength:UniversalContract.kt$UniversalContract$is Obligation -> Obligation(replaceFixing(tx, arr.amount, fixings, unusedFixings), arr.currency, arr.from, arr.to) MaxLineLength:UniversalContract.kt$UniversalContract$is Obligation -> Obligation(replaceStartEnd(arrangement.amount, start, end), arrangement.currency, arrangement.from, arrangement.to) - MaxLineLength:UniversalContract.kt$UniversalContract$is PerceivableAnd -> uncheckedCast(replaceStartEnd(p.left, start, end) and replaceStartEnd(p.right, start, end)) - MaxLineLength:UniversalContract.kt$UniversalContract$is PerceivableOperation MaxLineLength:UniversalContract.kt$UniversalContract$is PerceivableOperation -> PerceivableOperation(replaceStartEnd(p.left, start, end), p.op, replaceStartEnd(p.right, start, end)) - MaxLineLength:UniversalContract.kt$UniversalContract$is PerceivableOr -> uncheckedCast(replaceStartEnd(p.left, start, end) or replaceStartEnd(p.right, start, end)) - MaxLineLength:UniversalContract.kt$UniversalContract$is RollOut -> RollOut(arr.startDate, arr.endDate, arr.frequency, replaceFixing(tx, arr.template, fixings, unusedFixings)) - MaxLineLength:UniversalContract.kt$UniversalContract$val action = actions[value.name] ?: throw IllegalArgumentException("Failed requirement: action must be defined") - MaxLineLength:UniversalContract.kt$UniversalContract$val schedule = BusinessCalendar.createGenericSchedule(start, rollOut.frequency, noOfAdditionalPeriods = 1, endDate = end) - MaxLineLength:UnstartedFlowTransition.kt$UnstartedFlowTransition$Action.PersistCheckpoint(context.id, currentState.checkpoint, isCheckpointUpdate = currentState.isAnyCheckpointPersisted) MaxLineLength:UnstartedFlowTransition.kt$UnstartedFlowTransition$SenderDeduplicationId(DeduplicationId.createForNormal(currentState.checkpoint, 0, initiatedState), currentState.senderUUID) - MaxLineLength:UnstartedFlowTransition.kt$UnstartedFlowTransition$deduplicationSeed = "D-${initiatingMessage.initiatorSessionId.toLong}-${initiatingMessage.initiationEntropy}" - MaxLineLength:Util.kt$arrangement.actions.fold(ImmutableSet.builder<Party>(), { builder, k -> builder.addAll(involvedPartiesVisitor(k)) }).build() MaxLineLength:Util.kt$arrangement.actions.fold(ImmutableSet.builder<PublicKey>(), { builder, k -> builder.addAll(liablePartiesVisitor(k)) }).build() MaxLineLength:Util.kt$arrangement.arrangements.fold(ImmutableSet.builder<Party>(), { builder, k -> builder.addAll(involvedPartiesVisitor(k)) }).build() MaxLineLength:Util.kt$arrangement.arrangements.fold(ImmutableSet.builder<PublicKey>(), { builder, k -> builder.addAll(liablePartiesVisitor(k)) }).build() - MaxLineLength:Util.kt$is PerceivableAnd -> Sets.union( signingParties( perceivable.left ), signingParties(perceivable.right) ).immutableCopy() - MaxLineLength:Util.kt$is PerceivableOr -> Sets.union( signingParties( perceivable.left ), signingParties(perceivable.right) ).immutableCopy() - MaxLineLength:Util.kt$net.corda.finance.contracts.universal.Util.kt - MaxLineLength:Utils.kt$ fun <SNAPSHOT, ELEMENT> DataFeed<SNAPSHOT, ELEMENT>.doOnError(action: (Throwable) -> Unit): DataFeed<SNAPSHOT, ELEMENT> - MaxLineLength:Utils.kt$ fun <SNAPSHOT, ELEMENT> DataFeed<SNAPSHOT, ELEMENT>.mapErrors(transform: (Throwable) -> Throwable): DataFeed<SNAPSHOT, ELEMENT> - MaxLineLength:Utils.kt$ fun <T> Observable<T>.notUsed() - MaxLineLength:Utils.kt$ fun TransactionBuilder.addAttachmentOnce(att: SecureHash?): TransactionBuilder - MaxLineLength:Utils.kt$@Suppress("UNCHECKED_CAST") inline - MaxLineLength:Utils.kt$StateRefHere MaxLineLength:Utils.kt$fun <TYPE> Configuration.Property.Definition.Single<TYPE>.listOrEmpty(): Configuration.Property.Definition<List<TYPE>> - MaxLineLength:Utils.kt$fun <TYPE> PropertyDelegate.Single<TYPE>.listOrEmpty(): PropertyDelegate<List<TYPE>> MaxLineLength:Utils.kt$inline fun <TYPE, reified MAPPED> Configuration.Property.Definition.RequiredList<TYPE>.map(noinline convert: (List<TYPE>) -> MAPPED): Configuration.Property.Definition.Required<MAPPED> MaxLineLength:Utils.kt$inline fun <TYPE, reified MAPPED> Configuration.Property.Definition.RequiredList<TYPE>.mapValid(noinline convert: (List<TYPE>) -> Valid<MAPPED>): Configuration.Property.Definition.Required<MAPPED> MaxLineLength:Utils.kt$inline fun <TYPE, reified MAPPED> Configuration.Property.Definition.Standard<TYPE>.map(noinline convert: (TYPE) -> MAPPED): Configuration.Property.Definition.Standard<MAPPED> @@ -9246,19 +5024,12 @@ MaxLineLength:Utils.kt$inline fun <reified NESTED : Any> Configuration.Specification<*>.nested(specification: Configuration.Specification<NESTED>, key: String? = null, sensitive: Boolean = false): PropertyDelegate.Standard<NESTED> MaxLineLength:Utils.kt$internal fun Config.serialize(options: ConfigRenderOptions = ConfigRenderOptions.concise().setFormatted(true).setJson(true)): String MaxLineLength:Utils.kt$internal fun ConfigValue.serialize(options: ConfigRenderOptions = ConfigRenderOptions.concise().setFormatted(true).setJson(true)): String - MaxLineLength:Utils.kt$return requireNotNull(getDeclaredAnnotation(A::class.java)) { "$name needs to be annotated with ${A::class.java.name}" } MaxLineLength:Utils.kt$return results.states.firstOrNull() ?: throw IllegalArgumentException("State (type=${T::class}) corresponding to the reference $ref not found (or is spent).") - MaxLineLength:UtilsTest.kt$UtilsTest$rawConfiguration += "key1.key2" to configObject("key3" to "value2", "key4" to configObject("key5" to -2.0, "key6" to false)) - MaxLineLength:UtilsTest.kt$UtilsTest$rawConfiguration += "key7" to listOf("Hey!", true, 17, 0.0, configObject("key8" to listOf(-12.0, "HH", false), "key9" to "blah")) - MaxLineLength:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$flowMonitorSuspensionLoggingThresholdMillis = configuration[flowMonitorSuspensionLoggingThresholdMillis] MaxLineLength:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$private val additionalNodeInfoPollingFrequencyMsec by long().optional().withDefaultValue(Defaults.additionalNodeInfoPollingFrequencyMsec) MaxLineLength:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$private val additionalP2PAddresses by string().mapValid(::toNetworkHostAndPort).list().optional().withDefaultValue(Defaults.additionalP2PAddresses) MaxLineLength:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$private val certificateChainCheckPolicies by nested(CertChainPolicyConfigSpec).list().optional().withDefaultValue(Defaults.certificateChainCheckPolicies) MaxLineLength:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$private val cordappSignerKeyFingerprintBlacklist by string().list().optional().withDefaultValue(Defaults.cordappSignerKeyFingerprintBlacklist) - MaxLineLength:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$private val extraNetworkMapKeys by string().mapValid(::toUUID).list().optional().withDefaultValue(Defaults.extraNetworkMapKeys) MaxLineLength:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$private val flowMonitorSuspensionLoggingThresholdMillis by duration().optional().withDefaultValue(Defaults.flowMonitorSuspensionLoggingThresholdMillis) - MaxLineLength:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$return result.mapValid { conf -> Valid.withResult(conf as NodeConfiguration, conf.validate().map(::toError).toSet()) } - MaxLineLength:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$val cordappDirectories = configuration[cordappDirectories] ?: Defaults.cordappsDirectories(configuration[baseDirectory]) MaxLineLength:V1NodeConfigurationSpec.kt$V1NodeConfigurationSpec$val messagingServerExternal = configuration[messagingServerExternal] ?: Defaults.messagingServerExternal(configuration[messagingServerAddress]) MaxLineLength:V1NodeConfigurationSpec.kt$private fun toError(validationErrorMessage: String): Configuration.Validation.Error MaxLineLength:ValidateConfigurationCli.kt$ValidateConfigurationCli$internal @@ -9266,273 +5037,111 @@ MaxLineLength:ValidateConfigurationCli.kt$ValidateConfigurationCli$val rawConfig = cmdLineOptions.rawConfiguration().doOnErrors(cmdLineOptions::logRawConfigurationErrors).optional ?: return ExitCodes.FAILURE MaxLineLength:ValidateConfigurationCli.kt$ValidateConfigurationCli.Companion$internal fun logRawConfig(config: Config) MaxLineLength:ValidateConfigurationCli.kt$ValidateConfigurationCli.Companion$logger.error(errors.joinToString(System.lineSeparator(), "Error(s) while parsing node configuration:${System.lineSeparator()}") { error -> "\t- ${error.description()}" }) - MaxLineLength:ValidateConfigurationCli.kt$ValidateConfigurationCli.Companion$private val configRenderingOptions = ConfigRenderOptions.defaults().setFormatted(true).setComments(false).setOriginComments(false) MaxLineLength:Validated.kt$Validated$ fun <MAPPED> map(convert: (TARGET) -> MAPPED): Validated<MAPPED, ERROR> MaxLineLength:Validated.kt$Validated$ fun <MAPPED> mapValid(convert: (TARGET) -> Validated<MAPPED, ERROR>): Validated<MAPPED, ERROR> MaxLineLength:Validated.kt$Validated$ fun <MAPPED_ERROR> mapErrors(convertError: (ERROR) -> MAPPED_ERROR): Validated<TARGET, MAPPED_ERROR> MaxLineLength:Validated.kt$Validated$ fun value(exceptionOnErrors: (Set<ERROR>) -> Exception = { errors -> IllegalStateException(errors.joinToString(System.lineSeparator())) }): TARGET - MaxLineLength:Validated.kt$Validated$/** * Returns the underlying value as optional, with a null result instead of an exception if validation rules were violated. */ val optional: TARGET? get() = if (isValid) value() else null MaxLineLength:Validated.kt$Validated.Companion$ fun <T, E> withResult(target: T, errors: Set<E>): Validated<T, E> - MaxLineLength:Validated.kt$Validated.Result$Unsuccessful<TARGET, ERROR> : ResultValidated - MaxLineLength:Validated.kt$Validated.Result.Successful$override - MaxLineLength:Validated.kt$Validated.Result.Unsuccessful$override - MaxLineLength:ValidatingNotaryFlow.kt$ValidatingNotaryFlow : NotaryServiceFlow MaxLineLength:ValidatingNotaryFlow.kt$ValidatingNotaryFlow$open - MaxLineLength:ValidatingNotaryServiceTests.kt$ValidatingNotaryServiceTests$SignableData(wtx.id, SignatureMetadata(1, Crypto.findSignatureScheme(alice.owningKey).schemeNumberID)) - MaxLineLength:ValidatingNotaryServiceTests.kt$ValidatingNotaryServiceTests$assertThat(notaryError.cause).hasMessageContaining("Transaction for notarisation doesn't contain network parameters hash.") - MaxLineLength:ValidatingNotaryServiceTests.kt$ValidatingNotaryServiceTests$private - MaxLineLength:ValidatingNotaryServiceTests.kt$ValidatingNotaryServiceTests$val modifiedSignature = NotarisationRequestSignature(randomKeyPair.sign(bytesToSign), aliceNode.services.myInfo.platformVersion) MaxLineLength:ValidatingNotaryServiceTests.kt$ValidatingNotaryServiceTests.<no name provided>$val alteredMessage = InMemoryMessage(message.topic, OpaqueBytes(alteredMessageData.serialize().bytes), message.uniqueMessageId) - MaxLineLength:Validator.kt$Validator$ fun validate(target: TARGET, options: OPTIONS): Validated<TARGET, ERROR> - MaxLineLength:VaultFiller.kt$CommodityState$override - MaxLineLength:VaultFiller.kt$CommodityState$override fun withNewOwner(newOwner: AbstractParty) MaxLineLength:VaultFiller.kt$VaultFiller MaxLineLength:VaultFiller.kt$VaultFiller$ // TODO: need to make all FungibleAsset commands (issue, move, exit) generic fun fillWithSomeTestCommodity(amount: Amount<Commodity>, issuerServices: ServiceHub, issuedBy: PartyAndReference): Vault<CommodityState> - MaxLineLength:VaultFiller.kt$VaultFiller$ fun fillWithSomeTestCash(howMuch: Amount<Currency>, issuerServices: ServiceHub, atLeastThisManyStates: Int, atMostThisManyStates: Int, issuedBy: PartyAndReference, owner: AbstractParty? = null, rng: Random? = null, statesToRecord: StatesToRecord = StatesToRecord.ONLY_RELEVANT): Vault<Cash.State> MaxLineLength:VaultFiller.kt$VaultFiller$ fun generateCommoditiesIssue(tx: TransactionBuilder, amount: Amount<Issued<Commodity>>, owner: AbstractParty, notary: Party) - MaxLineLength:VaultFiller.kt$VaultFiller$addOutputState(DummyDealContract.State(ref = "test ref", participants = participants.plus(me)), DUMMY_DEAL_PROGRAM_ID) - MaxLineLength:VaultFiller.kt$VaultFiller$addOutputState(DummyDealContract.State(ref = it, participants = participantsToUse), DUMMY_DEAL_PROGRAM_ID) MaxLineLength:VaultFiller.kt$VaultFiller$cash.generateIssue(issuance, Amount(pennies, Issued(issuedBy, howMuch.token)), owner ?: services.myInfo.singleIdentity(), altNotary) - MaxLineLength:VaultFiller.kt$VaultFiller$fun evolveLinearState(linearState: StateAndRef<LinearState>): StateAndRef<LinearState> MaxLineLength:VaultFiller.kt$VaultFiller$statesToRecord: StatesToRecord = StatesToRecord.ONLY_RELEVANT - MaxLineLength:VaultFiller.kt$VaultFiller$val amounts = calculateRandomlySizedAmounts(howMuch, atLeastThisManyStates, atMostThisManyStates, rng ?: rngFactory()) MaxLineLength:VaultFiller.kt$VaultFiller$val signatureMetadata = SignatureMetadata(services.myInfo.platformVersion, Crypto.findSignatureScheme(issuerKey.public).schemeNumberID) - MaxLineLength:VaultFiller.kt$VaultFiller.Companion${ val numSlots = min + Math.floor(rng.nextDouble() * (max - min)).toInt() val baseSize = howMuch.quantity / numSlots check(baseSize > 0) { baseSize } val amounts = LongArray(numSlots) { baseSize } var distanceFromGoal = 0L // If we want 10 slots then max adjust is 0.1, so even if all random numbers come out to the largest downward // adjustment possible, the last slot ends at zero. With 20 slots, max adjust is 0.05 etc. val maxAdjust = 1.0 / numSlots for (i in amounts.indices) { if (i != amounts.lastIndex) { val adjustBy = rng.nextDouble() * maxAdjust - (maxAdjust / 2) val adjustment = (1 + adjustBy) val adjustTo = (amounts[i] * adjustment).toLong() amounts[i] = adjustTo distanceFromGoal += baseSize - adjustTo } else { amounts[i] += distanceFromGoal } } // The desired amount may not have divided equally to start with, so adjust the first value to make up. amounts[0] += howMuch.quantity - amounts.sum() return amounts } - MaxLineLength:VaultFlowTest.kt$VaultFlowTest.Initiator$addOutputState(UniqueDummyLinearContract.State(participants, "Dummy linear id"), UNIQUE_DUMMY_LINEAR_CONTRACT_PROGRAM_ID) - MaxLineLength:VaultFlowTest.kt$VaultFlowTest.Initiator$val stx = serviceHub.signInitialTransaction(TransactionBuilder(serviceHub.networkMapCache.notaryIdentities.first()).apply { addOutputState(UniqueDummyLinearContract.State(participants, "Dummy linear id"), UNIQUE_DUMMY_LINEAR_CONTRACT_PROGRAM_ID) addOutputState(DummyDealContract.State(participants, "linear id"), DUMMY_DEAL_PROGRAM_ID) addCommand(DummyCommandData, listOf(ourIdentity.owningKey)) }) MaxLineLength:VaultQueryTests.kt$VaultQueryTestRule$(notaryServices.myInfo.legalIdentitiesAndCerts + BOC_IDENTITY + CASH_NOTARY_IDENTITY + MINI_CORP_IDENTITY + MEGA_CORP_IDENTITY) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestRule$makeTestIdentityService(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, dummyCashIssuer.identity, dummyNotary.identity) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestRule$notaryServices = MockServices(cordappPackages, dummyNotary, mock(), dummyCashIssuer.keyPair, BOC_KEY, MEGA_CORP_KEY) - MaxLineLength:VaultQueryTests.kt$VaultQueryTests$require(produced.filter { ContractState::class.java.isAssignableFrom(it.state.data::class.java) }.size == 20) {} - MaxLineLength:VaultQueryTests.kt$VaultQueryTests$require(produced.filter { DealState::class.java.isAssignableFrom(it.state.data::class.java) }.size == 10) {} MaxLineLength:VaultQueryTests.kt$VaultQueryTests$require(produced.filter { DummyDealContract.State::class.java.isAssignableFrom(it.state.data::class.java) }.size == 10) {} - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$/** * Query result returns a [Vault.Page] which contains: * 1) actual states as a list of [StateAndRef] * 2) state reference and associated vault metadata as a list of [Vault.StateMetadata] * 3) [PageSpecification] used to delimit the size of items returned in the result set (defaults to [DEFAULT_PAGE_SIZE]) * 4) Total number of items available (to aid further pagination if required) */ val states = result.states MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$// Beware: do not use `MyContractClass::class.qualifiedName` as this returns a fully qualified name using "dot" notation for enclosed class val MYCONTRACT_ID = "net.corda.node.services.vault.VaultQueryTestsBase\$MyContractClass" MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$@Suppress("EXPECTED_CONDITION") val pagingSpec = PageSpecification(DEFAULT_PAGE_NUM, @Suppress("INTEGER_OVERFLOW") Integer.MAX_VALUE + 1) // overflow = -2147483648 - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `logical operator NOT LIKE does not return results containing the same characters as the case insensitive string`() MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `logical operator case insensitive NOT IN does not return results containing the same characters as the case insensitive strings`() MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$@Test fun `logical operator case insensitive NOT_EQUAL does not return results containing the same characters as the case insensitive string`() - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$CashSchemaV1.PersistentCashState::pennies - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$CommercialPaperUtils.generateIssue(issuance, faceValue, TEST_TX_TIME + 30.days, DUMMY_NOTARY) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$CommercialPaperUtils.generateIssue(issuance, faceValue2, TEST_TX_TIME + 30.days, DUMMY_NOTARY) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$MyState : BaseState MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$QueryCriteria.TimeInstantType.CONSUMED - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$Sort.Direction.ASC -> assertThat(allStates.sortedBy { it.ref.txhash }.sortedBy { it.ref.index }).isEqualTo(allStates) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$Sort.Direction.ASC -> assertThat(allStates.sortedBy { it.state.data.linearNumber }.sortedBy { it.ref.txhash }.sortedBy { it.ref.index }).isEqualTo(allStates) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$Sort.Direction.DESC -> assertThat(allStates.sortedByDescending { it.ref.txhash }.sortedByDescending { it.ref.index }).isEqualTo(allStates) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$Sort.Direction.DESC -> assertThat(allStates.sortedByDescending { it.state.data.linearNumber }.sortedBy { it.ref.txhash }.sortedBy { it.ref.index }).isEqualTo(allStates) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$assertThat(constraintResults.states.map { it.state.constraint }).containsAll(listOf(constraintHash, constraintSignature, constraintSignatureCompositeKey)) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$assertThat(constraintResults4.states.map { it.state.constraint }).containsAll(listOf(constraintSignature, constraintSignatureCompositeKey)) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$assertThat(enrichedResults.map { it.state.constraint }).containsAll(listOf(constraintSignature, alwaysAcceptConstraint)) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$assertThat(fungibleStateCountUnconsumed.toInt()).isEqualTo(10 - cashUpdates.consumed.size + cashUpdates.produced.size) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$assertThat(metadata.last().contractStateClassName).isEqualTo("net.corda.finance.contracts.asset.Cash\$State") - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$assertThat(results.states).hasSize(1) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$assertThat(results.states).hasSize(2) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$groupByColumns = listOf(SampleCashSchemaV2.PersistentCashState::currency, SampleCashSchemaV2.PersistentCashState::stateRef) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$listOf(10.DOLLARS, 25.POUNDS, 50.POUNDS, 100.SWISS_FRANCS).zip(listOf(3, 1, 1, 3)) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$listOf(100.DOLLARS, 200.DOLLARS, 300.DOLLARS, 400.POUNDS, 500.SWISS_FRANCS).zip(1..5) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$listOf(100.DOLLARS, 200.DOLLARS, 300.POUNDS, 400.POUNDS, 500.SWISS_FRANCS, 600.SWISS_FRANCS).zip(1..6) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$softLockingCondition = QueryCriteria.SoftLockingCondition(QueryCriteria.SoftLockingType.UNLOCKED_AND_SPECIFIED, listOf(UUID.randomUUID())) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val allStates = vaultService.queryBy<DummyLinearContract.State>(sorting = sorting, criteria = criteria).states MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val alwaysAcceptConstraint = vaultFiller.fillWithSomeTestLinearStates(1, constraint = AlwaysAcceptAttachmentConstraint).states.first().state.constraint MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val avg = builder { CashSchemaV1.PersistentCashState::pennies.avg(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency)) } - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val baseCriteria = VaultQueryCriteria(constraints = setOf(Vault.ConstraintInfo(AlwaysAcceptAttachmentConstraint))) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val ccyIndex = builder { CashSchemaV1.PersistentCashState::pennies.sum(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency)) } - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val ccyIndex = builder { CommercialPaperSchemaV1.PersistentCommercialPaperState::currency.equal(USD.currencyCode) } - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val chfCashIssuerName = CordaX500Name(organisation = "Swiss Francs Cash Issuer", locality = "Zurich", country = "CH") MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val compositeKey = CompositeKey.Builder().addKeys(alice.publicKey, bob.publicKey, charlie.publicKey, bankOfCorda.publicKey, bigCorp.publicKey, megaCorp.publicKey, miniCorp.publicKey, cashNotary.publicKey, dummyNotary.publicKey, dummyCashIssuer.publicKey).build() - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val constraintCriteria1 = VaultQueryCriteria(constraints = setOf(Vault.ConstraintInfo(AlwaysAcceptAttachmentConstraint))) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val constraintCriteria3 = VaultQueryCriteria(constraints = setOf(Vault.ConstraintInfo(constraintSignatureCompositeKey))) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val constraintSignature = linearStateSignature.states.first().state.constraint as SignatureAttachmentConstraint MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val constraintSignatureCompositeKey = linearStateSignatureCompositeKey.states.first().state.constraint as SignatureAttachmentConstraint MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val criteriaByLockId = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(lockId1))) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val criteriaByLockIds = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.SPECIFIED, listOf(lockId1, lockId2))) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val criteriaExclusive = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_ONLY)) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val criteriaLockedOnly = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.LOCKED_ONLY)) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val criteriaMissingLockId = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_AND_SPECIFIED)) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val criteriaUnlockedAndByLockId = VaultQueryCriteria(softLockingCondition = SoftLockingCondition(SoftLockingType.UNLOCKED_AND_SPECIFIED, listOf(lockId2))) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val database = configureDatabase(makePersistentDataSourceProperties(), DatabaseConfig(), identitySvc::wellKnownPartyFromX500Name, identitySvc::wellKnownPartyFromAnonymous) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val dealStateCountConsumed = vaultService.queryBy<DealState>(countCriteriaConsumed).otherResults.single() as Long - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val dealStateCountUnconsumed = vaultService.queryBy<DealState>(countCriteriaUnconsumed).otherResults.single() as Long MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val externalIds = listOf(linearState1.states.first().state.data.linearId.externalId!!, linearState3.states.first().state.data.linearId.externalId!!) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val faceValueIndex = CommercialPaperSchemaV1.PersistentCommercialPaperState::faceValue.greaterThanOrEqual(10000L) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val fungibleAssetStateCriteria = FungibleAssetQueryCriteria(participants = listOf(services.myInfo.singleIdentity())) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val fungibleStateCountConsumed = vaultService.queryBy<FungibleAsset<*>>(countCriteriaConsumed).otherResults.single() as Long - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val fungibleStateCountUnconsumed = vaultService.queryBy<FungibleAsset<*>>(countCriteriaUnconsumed).otherResults.single() as Long - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val gbpCashIssuerName = CordaX500Name(organisation = "British Pounds Cash Issuer", locality = "London", country = "GB") MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val issuedStates = vaultFillerCashNotary.fillWithSomeTestCash(100.DOLLARS, notaryServices, 10, DUMMY_CASH_ISSUER).states.toList() - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearIds = listOf(linearState1.states.first().state.data.linearId, linearState3.states.first().state.data.linearId) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearState2 = vaultFiller.evolveLinearState(linearState) // consume current and produce new state reference - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearState3 = vaultFiller.evolveLinearState(linearState2) // consume current and produce new state reference - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearStateCountConsumed = vaultService.queryBy<LinearState>(countCriteriaConsumed).otherResults.single() as Long - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearStateCountUnconsumed = vaultService.queryBy<LinearState>(countCriteriaUnconsumed).otherResults.single() as Long - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearStateCriteria = LinearStateQueryCriteria(linearId = listOf(linearId), status = Vault.StateStatus.ALL) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearStateCriteria = LinearStateQueryCriteria(linearId = txns.states.map { it.state.data.linearId }, status = Vault.StateStatus.CONSUMED) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearStateCriteria = LinearStateQueryCriteria(uuid = linearStates.map { it.state.data.linearId.id }, status = Vault.StateStatus.ALL) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearStateHash = vaultFiller.fillWithSomeTestLinearStates(1, constraint = AutomaticPlaceholderConstraint) // defaults to the HashConstraint MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearStateHash = vaultFiller.fillWithSomeTestLinearStates(1, constraint = AutomaticPlaceholderConstraint) // defaults to the hash constraint. MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearStateSignature = vaultFiller.fillWithSomeTestLinearStates(1, constraint = SignatureAttachmentConstraint(alice.publicKey)) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearStateSignatureCompositeKey = vaultFiller.fillWithSomeTestLinearStates(1, constraint = SignatureAttachmentConstraint(compositeKey)) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val linearStates = vaultFiller.fillWithSomeTestLinearStates(2, "TEST") // create 2 states with same externalId - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val logicalExpression = builder { CashSchemaV1.PersistentCashState::pennies.`in`(listOf(10000L, 20000L), false) } - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val logicalExpression = builder { CashSchemaV1.PersistentCashState::pennies.notIn(listOf(10000L, 20000L), false) } MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val maturityIndex = CommercialPaperSchemaV1.PersistentCommercialPaperState::maturity.greaterThanOrEqual(TEST_TX_TIME + 30.days) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val max = builder { CashSchemaV1.PersistentCashState::pennies.max(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency)) } MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val max = builder { CashSchemaV1.PersistentCashState::pennies.max(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency), orderBy = Sort.Direction.DESC) } MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val min = builder { CashSchemaV1.PersistentCashState::pennies.min(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency)) } MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val min = builder { CashSchemaV1.PersistentCashState::pennies.min(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency), orderBy = Sort.Direction.DESC) } - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val newAllStates = vaultService.queryBy<DummyLinearContract.State>(sorting = sorting, criteria = criteria).states - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val page = vaultService.queryBy<DummyLinearContract.State>(sorting = sorting, paging = paging, criteria = criteria) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val result = vaultService.queryBy<ContractState>(VaultQueryCriteria(status = Vault.StateStatus.ALL), sorting = sorting) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val results = services.vaultService.queryBy<FungibleAsset<*>>(baseCriteria and enrichedCriteria, sorter).states - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val results = vaultService.queryBy<Cash.State>(criteria, Sort(setOf(Sort.SortColumn(sortAttribute, Sort.Direction.ASC)))) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val results = vaultService.queryBy<DummyLinearContract.State>(criteria, Sort(setOf(Sort.SortColumn(sortAttribute, Sort.Direction.ASC)))) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val resultsComposite = vaultService.queryBy<ContractState>(linearStateCriteria.or(fungibleAssetStateCriteria)) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val resultsCompositeAnd = vaultService.queryBy<ContractState>(fungibleAssetStateCriteria.and(linearStateCriteria)) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val resultsCompositeOr = vaultService.queryBy<ContractState>(fungibleAssetStateCriteria.or(linearStateCriteria)) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val signatureMetadata = SignatureMetadata(services.myInfo.platformVersion, Crypto.findSignatureScheme(issuerKey.public).schemeNumberID) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val signedStatesExitingTx = services.signInitialTransaction(statesExitingTx).withAdditionalSignature(issuerKey, signatureMetadata) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val sortAttribute = SortAttribute.Custom(DummyLinearStateSchemaV1.PersistentDummyLinearState::class.java, "linearNumber") - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val sortAttribute = SortAttribute.Custom(DummyLinearStateSchemaV1.PersistentDummyLinearState::class.java, "stateRef") - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val sortCol1 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.CONTRACT_STATE_TYPE), Sort.Direction.DESC) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val sortCol2 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.STATE_STATUS), Sort.Direction.ASC) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val sortCol3 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.CONSUMED_TIME), Sort.Direction.DESC) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Custom(DummyLinearStateSchemaV1.PersistentDummyLinearState::class.java, "linearString"), Sort.Direction.DESC))) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.EXTERNAL_ID), Sort.Direction.DESC))) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.UUID), Sort.Direction.DESC))) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val statesExitingTx = TransactionBuilder(notary.party).withItems(*states.toList().toTypedArray()).addCommand(dummyCommand()) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val sum = builder { CashSchemaV1.PersistentCashState::pennies.sum(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency)) } MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val sum = builder { CashSchemaV1.PersistentCashState::pennies.sum(groupByColumns = listOf(CashSchemaV1.PersistentCashState::currency), orderBy = Sort.Direction.DESC) } - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val usdCashIssuerName = CordaX500Name(organisation = "US Dollars Cash Issuer", locality = "New York", country = "US") MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$val utx = TransactionBuilder(notary = notaryServices.myInfo.singleIdentity()).withItems(stateAndContract).withItems(dummyCommand()) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, BOC.ref(0), MINI_CORP) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER, services.myInfo.singleIdentity()) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$vaultFiller.fillWithSomeTestCommodity(Amount(100, Commodity.getInstance("FCOJ")!!), notaryServices, DUMMY_OBLIGATION_ISSUER.ref(1)) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$vaultFiller.fillWithSomeTestLinearStates(1, "TEST1") vaultFiller.fillWithSomeTestDeals(listOf("123")) vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER, services.myInfo.singleIdentity()) vaultFiller.fillWithSomeTestCommodity(Amount(100, Commodity.getInstance("FCOJ")!!), notaryServices, DUMMY_OBLIGATION_ISSUER.ref(1)) vaultFiller.fillWithDummyState() // all contract states query val results = vaultService.queryBy<ContractState>() assertThat(results.states).hasSize(5) // linear states only query val linearStateCriteria = LinearStateQueryCriteria() val resultsLSC = vaultService.queryBy<ContractState>(linearStateCriteria) assertThat(resultsLSC.states).hasSize(2) // fungible asset states only query val fungibleAssetStateCriteria = FungibleAssetQueryCriteria() val resultsFASC = vaultService.queryBy<ContractState>(fungibleAssetStateCriteria) assertThat(resultsFASC.states).hasSize(2) // composite OR query for both linear and fungible asset states (eg. all states in either Fungible and Linear states tables) val resultsCompositeOr = vaultService.queryBy<ContractState>(fungibleAssetStateCriteria.or(linearStateCriteria)) assertThat(resultsCompositeOr.states).hasSize(4) // composite AND query for both linear and fungible asset states (eg. all states in both Fungible and Linear states tables) val resultsCompositeAnd = vaultService.queryBy<ContractState>(fungibleAssetStateCriteria.and(linearStateCriteria)) assertThat(resultsCompositeAnd.states).hasSize(0) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$vaultFiller.fillWithSomeTestLinearStates(1, constraint = AlwaysAcceptAttachmentConstraint).states.first().state.constraint - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$vaultFiller.fillWithSomeTestLinearStates(1, constraint = AutomaticPlaceholderConstraint) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$vaultFiller.fillWithSomeTestLinearStates(1, constraint = WhitelistedByZoneAttachmentConstraint).states.first().state.constraint MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$vaultFillerCashNotary.fillWithSomeTestCash(100.DOLLARS, notaryServices, 10, DUMMY_CASH_ISSUER, charlie.party, statesToRecord = StatesToRecord.ALL_VISIBLE) MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$vaultFillerCashNotary.fillWithSomeTestCash(100.DOLLARS, notaryServices, 10, DUMMY_CASH_ISSUER, statesToRecord = StatesToRecord.ALL_VISIBLE) - MaxLineLength:VaultQueryTests.kt$VaultQueryTestsBase$vaultService.softLockReserve(UUID.randomUUID(), NonEmptySet.of(issuedStates[1].ref, issuedStates[2].ref, issuedStates[3].ref)) - MaxLineLength:VaultRestartTest.kt$VaultRestartTest$val node = startNode(providedName = DUMMY_BANK_A_NAME, customOverrides = mapOf("p2pAddress" to "localhost:30000")).getOrThrow() MaxLineLength:VaultRestartTest.kt$VaultRestartTest$val restartedNode = startNode(providedName = DUMMY_BANK_A_NAME, customOverrides = mapOf("p2pAddress" to "localhost:30000")).getOrThrow() MaxLineLength:VaultSchema.kt$VaultSchemaV1.PersistentStateRefAndKey$@Embeddable @Immutable data MaxLineLength:VaultSchema.kt$VaultSchemaV1.VaultLinearStates$@Table(name = "vault_linear_states", indexes = [Index(name = "external_id_index", columnList = "external_id"), Index(name = "uuid_index", columnList = "uuid")]) MaxLineLength:VaultSchema.kt$VaultSchemaV1.VaultStates$@Table(name = "vault_states", indexes = [Index(name = "state_status_idx", columnList = "state_status"), Index(name = "lock_id_idx", columnList = "lock_id, state_status")]) MaxLineLength:VaultSchema.kt$VaultSchemaV1.VaultTxnNote$@Table(name = "vault_transaction_notes", indexes = [Index(name = "seq_no_index", columnList = "seq_no"), Index(name = "transaction_id_index", columnList = "transaction_id")]) - MaxLineLength:VaultService.kt$StatesNotAvailableException : FlowException - MaxLineLength:VaultService.kt$Vault$Update<U : ContractState> - MaxLineLength:VaultService.kt$Vault.Companion$@Deprecated("No longer used. The vault does not emit empty updates") val NoNotaryUpdate = Vault.Update(emptySet(), emptySet(), type = Vault.UpdateType.NOTARY_CHANGE, references = emptySet()) - MaxLineLength:VaultService.kt$Vault.StateMetadata$return StateMetadata(ref, contractStateClassName, recordedTime, consumedTime, status, notary, lockId, lockUpdateTime, null) MaxLineLength:VaultService.kt$Vault.StateMetadata$return StateMetadata(ref, contractStateClassName, recordedTime, consumedTime, status, notary, lockId, lockUpdateTime, relevancyStatus, ConstraintInfo(AlwaysAcceptAttachmentConstraint)) - MaxLineLength:VaultService.kt$Vault.Update$ operator fun plus(rhs: Update<U>): Update<U> - MaxLineLength:VaultService.kt$Vault.Update$/** * Specifies the type of update, currently supported types are general and, contract upgrade and notary change. * Notary change transactions only modify the notary field on states, and potentially need to be handled * differently. */ val type: UpdateType = UpdateType.GENERAL MaxLineLength:VaultService.kt$Vault.Update$inline - MaxLineLength:VaultService.kt$Vault.Update$return copy(consumed = combinedConsumed, produced = combinedProduced, references = references + rhs.references) MaxLineLength:VaultService.kt$Vault.Update${ require(rhs.type == type) { "Cannot combine updates of different types" } val combinedConsumed = consumed + (rhs.consumed - produced) // The ordering below matters to preserve ordering of consumed/produced Sets when they are insertion order dependent implementations. val combinedProduced = produced.filter { it !in rhs.consumed }.toSet() + rhs.produced return copy(consumed = combinedConsumed, produced = combinedProduced, references = references + rhs.references) } - MaxLineLength:VaultService.kt$VaultService$ @Suspendable @Throws(StatesNotAvailableException::class) fun <T : FungibleState<*>> tryLockFungibleStatesForSpending(lockId: UUID, eligibleStatesQuery: QueryCriteria, amount: Amount<*>, contractStateType: Class<out T>): List<StateAndRef<T>> - MaxLineLength:VaultService.kt$VaultService$ @Throws(VaultQueryException::class) fun <T : ContractState> _queryBy(criteria: QueryCriteria, paging: PageSpecification, sorting: Sort, contractStateType: Class<out T>): Vault.Page<T> - MaxLineLength:VaultService.kt$VaultService$/** * Prefer the use of [updates] unless you know why you want to use this instead. * * Get a synchronous [Observable] of updates. When observations are pushed to the Observer, the [Vault] will already * incorporate the update, and the database transaction associated with the update will still be open and current. * If for some reason the processing crosses outside of the database transaction (for example, the update is pushed * outside the current JVM or across to another [Thread], which is executing in a different database transaction), * then the [Vault] may not incorporate the update due to racing with committing the current database transaction. */ val rawUpdates: Observable<Vault.Update<ContractState>> - MaxLineLength:VaultService.kt$VaultService$doneFuture(Vault.Update(consumed = setOf(snapshot.single()), produced = emptySet(), references = emptySet())) - MaxLineLength:VaultService.kt$VaultService$fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification): Vault.Page<T> MaxLineLength:VaultService.kt$VaultService$fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification, sorting: Sort): Vault.Page<T> - MaxLineLength:VaultService.kt$VaultService$fun <T : ContractState> queryBy(contractStateType: Class<out T>, criteria: QueryCriteria, sorting: Sort): Vault.Page<T> - MaxLineLength:VaultService.kt$VaultService$fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria): DataFeed<Vault.Page<T>, Vault.Update<T>> MaxLineLength:VaultService.kt$VaultService$fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification): DataFeed<Vault.Page<T>, Vault.Update<T>> MaxLineLength:VaultService.kt$VaultService$fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria, paging: PageSpecification, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> MaxLineLength:VaultService.kt$VaultService$fun <T : ContractState> trackBy(contractStateType: Class<out T>, criteria: QueryCriteria, sorting: Sort): DataFeed<Vault.Page<T>, Vault.Update<T>> - MaxLineLength:VaultService.kt$VaultService$fun <T : ContractState> trackBy(contractStateType: Class<out T>, paging: PageSpecification): DataFeed<Vault.Page<T>, Vault.Update<T>> MaxLineLength:VaultService.kt$inline MaxLineLength:VaultSoftLockManagerTest.kt$NodePair$internals.disableDBCloseOnStop() // Otherwise the in-memory database may disappear (taking the checkpoint with it) while we reboot the client. - MaxLineLength:VaultSoftLockManagerTest.kt$NodePair$server.registerCoreFlowFactory(AbstractClientLogic::class.java, ServerLogic::class.java, { ServerLogic(it, serverRunning) }, false) - MaxLineLength:VaultSoftLockManagerTest.kt$NodePair.ServerLogic$private - MaxLineLength:VaultSoftLockManagerTest.kt$VaultSoftLockManagerTest$ClientLogic : AbstractClientLogic - MaxLineLength:VaultSoftLockManagerTest.kt$VaultSoftLockManagerTest$private - MaxLineLength:VaultSoftLockManagerTest.kt$VaultSoftLockManagerTest${ assertEquals(emptyList(), fsm.resultFuture.getOrThrow()) // In this case we don't want softLockRelease called so that we avoid its expensive query, even after restore from checkpoint. } - MaxLineLength:VaultSoftLockManagerTest.kt$VaultSoftLockManagerTest.<no name provided>.<no name provided>$mockVault.softLockRelease(lockId, stateRefs) MaxLineLength:VaultSoftLockManagerTest.kt$VaultSoftLockManagerTest.ClientLogic$return serviceHub.vaultService.queryBy<ContractState>(VaultQueryCriteria(softLockingCondition = SoftLockingCondition(LOCKED_ONLY))).states.map { it.state.data } - MaxLineLength:VaultSoftLockManagerTest.kt$VaultSoftLockManagerTest.FungibleAssetImpl$@BelongsToContract(ContractImpl::class) private - MaxLineLength:VaultSoftLockManagerTest.kt$VaultSoftLockManagerTest.FungibleAssetImpl$override fun withNewOwnerAndAmount(newAmount: Amount<Issued<Unit>>, newOwner: AbstractParty) - MaxLineLength:VaultStateMigration.kt$VaultMigrationSchema - MaxLineLength:VaultStateMigration.kt$VaultStateIterator : Iterator - MaxLineLength:VaultStateMigration.kt$VaultStateIterator$// The rest of this class is an attempt at multithreading that was ultimately scuppered by liquibase not providing a connection pool. // This may be useful as a starting point for improving performance of the migration, so is left here. To start using it, remove the // serialization environment changes in the execute function in the migration, and change forEach -> parallelForEach. private val pool = ForkJoinPool.commonPool() - MaxLineLength:VaultStateMigration.kt$VaultStateIterator$criteriaBuilder MaxLineLength:VaultStateMigration.kt$VaultStateIterator$logger.debug("Loaded page $pageNumber of ${(numStates - 1 / pageNumber.toLong()) + 1}. Current page has ${result.size} vault states") - MaxLineLength:VaultStateMigration.kt$VaultStateIterator$private - MaxLineLength:VaultStateMigration.kt$VaultStateIterator${ endTransaction() transaction = database.newTransaction() val query = createVaultStatesQuery(VaultSchemaV1.VaultStates::class.java) { it } // The above query excludes states that have entries in the state party table. As the iteration proceeds, each state has entries // added to this table. The result is that when the next page is retrieved, any results that were in the previous page are not in // the query at all! As such, the next set of states that need processing start at the first result. query.firstResult = 0 query.maxResults = pageSize pageNumber++ val result = query.resultList logger.debug("Loaded page $pageNumber of ${(numStates - 1 / pageNumber.toLong()) + 1}. Current page has ${result.size} vault states") return result } MaxLineLength:VaultStateMigration.kt$VaultStateIterator.Companion$effectiveSerializationEnv.serializationFactory - MaxLineLength:VaultStateMigration.kt$VaultStateIterator.Companion.AMQPInspectorSerializationScheme$override - MaxLineLength:VaultStateMigration.kt$VaultStateIterator.Companion.AMQPInspectorSerializationScheme$override fun rpcClientSerializerFactory(context: SerializationContext) - MaxLineLength:VaultStateMigration.kt$VaultStateIterator.Companion.AMQPInspectorSerializationScheme$override fun rpcServerSerializerFactory(context: SerializationContext) MaxLineLength:VaultStateMigration.kt$VaultStateIterator.VaultPageTask$effectiveSerializationEnv.serializationFactory MaxLineLength:VaultStateMigration.kt$VaultStateIterator.VaultPageTask$return listOf(VaultPageTask(database, page.subList(0, pageSize / 2), block), VaultPageTask(database, page.subList(pageSize / 2, pageSize), block)) - MaxLineLength:VaultStateMigration.kt$VaultStateMigration$logger - MaxLineLength:VaultStateMigration.kt$VaultStateMigration$logger.info("Finished performing vault state data migration for ${persistentStates.numStates - statesSkipped} states") - MaxLineLength:VaultStateMigration.kt$VaultStateMigration$throw VaultStateMigrationException("Cannot add state parties for state ${stateAndRef.ref} as state class is not on the " + "classpath and participants cannot be synthesised") - MaxLineLength:VaultStateMigration.kt$VaultStateMigration$throw VaultStateMigrationException("Cannot migrate vault states as liquibase failed to provide a suitable database connection") - MaxLineLength:VaultStateMigration.kt$VaultStateMigration$throw VaultStateMigrationException("Failed to migrate $statesSkipped states in the vault. Check the logs for details of the " + "error for each state.") - MaxLineLength:VaultStateMigration.kt$VaultStateMigration$val myKeys = identityService.stripNotOurKeys(stateAndRef.state.data.participants.map { participant -> participant.owningKey }).toSet() - MaxLineLength:VaultStateMigration.kt$VaultStateMigration${ // This should only happen if there was no attachment that could be used to deserialise the output states, and the state was // serialised such that the participants list cannot be accessed (participants is calculated and not marked as a // SerializableCalculatedProperty. throw VaultStateMigrationException("Cannot add state parties for state ${stateAndRef.ref} as state class is not on the " + "classpath and participants cannot be synthesised") } - MaxLineLength:VaultStateMigration.kt$VaultStateMigration${ val stateAndRef = getStateAndRef(it) addStateParties(session, stateAndRef) // Can get away without checking for AbstractMethodErrors here as these will have already occurred when trying to add // state parties. val myKeys = identityService.stripNotOurKeys(stateAndRef.state.data.participants.map { participant -> participant.owningKey }).toSet() if (!NodeVaultService.isRelevant(stateAndRef.state.data, myKeys)) { it.relevancyStatus = Vault.RelevancyStatus.NOT_RELEVANT } } - MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest$OnLedgerAsset.generateIssue(txBuilder, TransactionState(CommodityState(amount, owner), Obligation.PROGRAM_ID, dummyNotary.party), Obligation.Commands.Issue()) MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest$cordaDB = configureDatabase(makePersistentDataSourceProperties(), DatabaseConfig(), notaryServices.identityService::wellKnownPartyFromX500Name, notaryServices.identityService::wellKnownPartyFromAnonymous) - MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest$createCommodityTransaction(Amount(it.toLong(), Issued(bankOfCorda.ref(2), Commodity.getInstance("FCOJ")!!)), owner) - MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest$createVaultStatesFromNotaryChangeTransaction(notaryTx, cashTx.coreTransaction.outputs + cashTx2.coreTransaction.outputs) - MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest$criteriaQuery.where(criteriaBuilder.equal(queryRootStates.get<Vault.RelevancyStatus>("relevancyStatus"), relevancyStatus)) - MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest$private - MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest$val notaryTx = createNotaryChangeTransaction(listOf(StateRef(cashTx.id, 0), StateRef(cashTx2.id, 0)), SecureHash.allOnesHash) MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest$val persistentIDs = certs.map { PersistentIdentityService.PersistentIdentity(it.owningKey.hash.toString(), it.certPath.encoded) } MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest$val persistentName = PersistentIdentityService.PersistentIdentityNames(name.toString(), certs.first().owningKey.hash.toString()) - MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest$val signableData = SignableData(notaryTx.id, SignatureMetadata(3, Crypto.findSignatureScheme(notaryKey).schemeNumberID)) - MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest${ // Liquibase automatically closes the database connection when doing an actual migration. This test ensures the custom migration // leaves it open. addCashStates(12, ALICE) val migration = VaultStateMigration() migration.execute(liquibaseDB) assertFalse(cordaDB.dataSource.connection.isClosed) } - MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest${ // This test is a little bit of a hack - it checks that these states are migrated correctly by looking at params in the database, // but these will not be there for V3 nodes. Handling for this must be tested manually. val cashTx = createCashTransaction(Cash(), 5.DOLLARS, BOB) val cashTx2 = createCashTransaction(Cash(), 10.DOLLARS, BOB) val notaryTx = createNotaryChangeTransaction(listOf(StateRef(cashTx.id, 0), StateRef(cashTx2.id, 0)), SecureHash.allOnesHash) createVaultStatesFromTransaction(cashTx, stateStatus = Vault.StateStatus.CONSUMED) createVaultStatesFromTransaction(cashTx2, stateStatus = Vault.StateStatus.CONSUMED) createVaultStatesFromNotaryChangeTransaction(notaryTx, cashTx.coreTransaction.outputs + cashTx2.coreTransaction.outputs) storeTransaction(cashTx) storeTransaction(cashTx2) storeTransaction(notaryTx) val migration = VaultStateMigration() migration.execute(liquibaseDB) assertEquals(2, getStatePartyCount()) } MaxLineLength:VaultStateMigrationTest.kt$VaultStateMigrationTest${ val cashStatesToAdd = 1000 val linearStatesToAdd = 0 val commodityStatesToAdd = 0 val stateMultiplier = 10 cordaDB = configureDatabase(makePersistentDataSourceProperties(), DatabaseConfig(), notaryServices.identityService::wellKnownPartyFromX500Name, notaryServices.identityService::wellKnownPartyFromAnonymous) // Starting the database this way runs the migration under test. This is fine for the unit tests (as the changelog table is ignored), // but when starting an actual node using these databases the migration will be skipped, as it has an entry in the changelog table. // This must therefore be removed. cordaDB.dataSource.connection.createStatement().use { it.execute("DELETE FROM DATABASECHANGELOG WHERE FILENAME IN ('migration/vault-schema.changelog-v9.xml')") } for (i in 1..stateMultiplier) { addCashStates(cashStatesToAdd, BOB) addLinearStates(linearStatesToAdd, listOf(BOB, ALICE)) addCommodityStates(commodityStatesToAdd, BOB) } saveOurKeys(listOf(bob.keyPair)) saveAllIdentities(listOf(BOB_IDENTITY, ALICE_IDENTITY, BOC_IDENTITY, dummyNotary.identity)) cordaDB.close() } - MaxLineLength:VaultSteps.kt$VaultSteps$Then MaxLineLength:VaultSteps.kt$VaultSteps$val sumCashStates = cashStates.filter { it.state.data.amount.token.product.currencyCode == currency }.sumByLong { it.state.data.amount.quantity } - MaxLineLength:VaultUpdateTests.kt$VaultUpdateTests$@Test fun `something plus consume states 0 and 1, and produce state 4, is something without state 0 and 1 outputs and only state 4 output`() MaxLineLength:VaultUpdateTests.kt$VaultUpdateTests$private val stateAndRef0 = StateAndRef(TransactionState(DummyState(), DUMMY_PROGRAM_ID, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint), stateRef0) MaxLineLength:VaultUpdateTests.kt$VaultUpdateTests$private val stateAndRef1 = StateAndRef(TransactionState(DummyState(), DUMMY_PROGRAM_ID, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint), stateRef1) MaxLineLength:VaultUpdateTests.kt$VaultUpdateTests$private val stateAndRef2 = StateAndRef(TransactionState(DummyState(), DUMMY_PROGRAM_ID, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint), stateRef2) MaxLineLength:VaultUpdateTests.kt$VaultUpdateTests$private val stateAndRef3 = StateAndRef(TransactionState(DummyState(), DUMMY_PROGRAM_ID, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint), stateRef3) MaxLineLength:VaultUpdateTests.kt$VaultUpdateTests$private val stateAndRef4 = StateAndRef(TransactionState(DummyState(), DUMMY_PROGRAM_ID, DUMMY_NOTARY, constraint = AlwaysAcceptAttachmentConstraint), stateRef4) - MaxLineLength:VaultUpdateTests.kt$VaultUpdateTests$val expected = Vault.Update<ContractState>(setOf(stateAndRef2, stateAndRef3), setOf(stateAndRef0, stateAndRef1, stateAndRef4)) MaxLineLength:VaultUpdateTests.kt$VaultUpdateTests$val notaryChangeUpdate = Vault.Update<ContractState>(setOf(stateAndRef2, stateAndRef3), setOf(stateAndRef0, stateAndRef1), type = Vault.UpdateType.NOTARY_CHANGE) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$Cash().generateIssue(usefulBuilder, 100.DOLLARS `issued by` MEGA_CORP.ref(1), AnonymousParty(freshKey), DUMMY_NOTARY) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$CashUtils.generateSpend(services, spendTXBuilder, 80.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$CashUtils.generateSpend(services, txn1Builder, 60.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$CashUtils.generateSpend(services, txn2Builder, 80.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB) MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$TransactionBuilder(notary = DUMMY_NOTARY) .addOutputState(DummyLinearContract.State(linearId = linearId, participants = listOf(freshIdentity)), DUMMY_LINEAR_CONTRACT_PROGRAM_ID) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$addOutputState(DummyDealContract.State(ref = "999", participants = listOf(freshIdentity)), DUMMY_DEAL_PROGRAM_ID) MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$addOutputState(DummyLinearContract.State(linearId = linearId, participants = listOf(freshIdentity)), DUMMY_LINEAR_CONTRACT_PROGRAM_ID) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$addOutputState(DummyLinearContract.State(participants = listOf(freshIdentity)), DUMMY_LINEAR_CONTRACT_PROGRAM_ID) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$makeTestIdentityService(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, dummyCashIssuer.identity, dummyNotary.identity) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$services.validatedTransactions.getTransaction(deals.first().ref.txhash)?.apply { notaryServices.recordTransactions(this) } MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$services.validatedTransactions.getTransaction(linearStates.first().ref.txhash)?.apply { notaryServices.recordTransactions(this) } - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$val consumedStates = vaultService.queryBy<ContractState>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)).states - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$val consumedStates1 = vaultService.queryBy<Cash.State>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$val consumedStates2 = vaultService.queryBy<Cash.State>(VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)) MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$val criteriaLocked = VaultQueryCriteria(softLockingCondition = QueryCriteria.SoftLockingCondition(QueryCriteria.SoftLockingType.LOCKED_ONLY)) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$vaultFiller.fillWithSomeTestCash(100.DOLLARS, issuerServices, 10, MEGA_CORP.ref(1), AnonymousParty(freshKey)) - MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest$vaultFiller.fillWithSomeTestCash(100.DOLLARS, issuerServices, 3, DUMMY_CASH_ISSUER, AnonymousParty(freshKey)) MaxLineLength:VaultWithCashTest.kt$VaultWithCashTest.Companion$val cordappPackages = listOf("net.corda.testing.internal.vault", "net.corda.finance.contracts.asset", CashSchemaV1::class.packageName, "net.corda.core.contracts") - MaxLineLength:VersionExtractor.kt$VersionExtractor.Spec$private MaxLineLength:VersionExtractorTest.kt$VersionExtractorTest$val rawConfiguration = configObject("configuration" to configObject("metadata" to configObject("version" to null), "node" to configObject("p2pAddress" to "localhost:8080"))).toConfig() MaxLineLength:VersionExtractorTest.kt$VersionExtractorTest$val rawConfiguration = configObject("configuration" to configObject("metadata" to configObject("version" to versionValue), "node" to configObject("p2pAddress" to "localhost:8080"))).toConfig() MaxLineLength:VersionExtractorTest.kt$VersionExtractorTest$val rawConfiguration = configObject("configuration" to configObject("metadata" to configObject(), "node" to configObject("p2pAddress" to "localhost:8080"))).toConfig() MaxLineLength:VersionExtractorTest.kt$VersionExtractorTest$val rawConfiguration = configObject("configuration" to configObject("node" to configObject("p2pAddress" to "localhost:8080"))).toConfig() - MaxLineLength:VersionInfo.kt$VersionInfo$/** * Platform version of the node which is an integer value which increments on any release where any of the public * API of the entire Corda platform changes. This includes messaging, serialisation, node APIs, etc. */ val platformVersion: Int MaxLineLength:VersionedParsingExampleTest.kt$VersionedParsingExampleTest$val addressesValue = configObject("principal" to "${principalAddressValue.host}:${principalAddressValue.port}", "admin" to "${adminAddressValue.host}:${adminAddressValue.port}") MaxLineLength:VersionedParsingExampleTest.kt$VersionedParsingExampleTest$val configurationV1 = configObject("configuration.metadata.version" to 1, "principalHost" to principalAddressValue.host, "principalPort" to principalAddressValue.port, "adminHost" to adminAddressValue.host, "adminPort" to adminAddressValue.port).toConfig().also { println(it.serialize()) } MaxLineLength:VersionedParsingExampleTest.kt$VersionedParsingExampleTest$val configurationV2 = configObject("configuration.metadata.version" to 2, "configuration.value.addresses" to addressesValue).toConfig().also { println(it.serialize()) } - MaxLineLength:VersionedParsingExampleTest.kt$VersionedParsingExampleTest$val configurationV2 = configObject("configuration.value.addresses" to addressesValue).toConfig().also { println(it.serialize()) } - MaxLineLength:VersionedParsingExampleTest.kt$VersionedParsingExampleTest$val parseConfiguration = VersionedSpecificationRegistry.mapping(extractVersion, 1 to RpcSettingsSpec.V1, 2 to RpcSettingsSpec.V2) - MaxLineLength:VersionedParsingExampleTest.kt$VersionedParsingExampleTest$val rpcSettingsFromVersion1Conf = parseConfiguration.invoke(configurationV1).mapValid { it.parse(configurationV1) } - MaxLineLength:VersionedParsingExampleTest.kt$VersionedParsingExampleTest$val rpcSettingsFromVersion2Conf = parseConfiguration.invoke(configurationV2).mapValid { it.parse(configurationV2) } MaxLineLength:VersionedParsingExampleTest.kt$VersionedParsingExampleTest.RpcSettingsSpec$return Validated.invalid(Configuration.Validation.Error.BadValue.of(host, Address::class.java.simpleName, "Value must be of format \"host(String):port(Int > 0)\" e.g., \"127.0.0.1:8080\"")) - MaxLineLength:VersionedParsingExampleTest.kt$VersionedParsingExampleTest.RpcSettingsSpec.V2.AddressesSpec$override fun parseValid(configuration: Config) - MaxLineLength:VersionedParsingExampleTest.kt$VersionedParsingExampleTest.RpcSettingsSpec.V2.AddressesSpec$return Address.validFromRawValue(rawValue) { error -> Configuration.Validation.Error.BadValue.of(error) } MaxLineLength:VersionedParsingExampleTest.kt$private fun Configuration.Version.Extractor.parseRequired(config: Config, options: Configuration.Validation.Options = Configuration.Validation.Options.defaults) MaxLineLength:VersionedSpecificationRegistry.kt$VersionedSpecificationRegistry$value?.let { valid(it) } ?: invalid<Configuration.Specification<VALUE>, Configuration.Validation.Error>(Configuration.Validation.Error.UnsupportedVersion.of(version)) MaxLineLength:VersionedSpecificationRegistry.kt$VersionedSpecificationRegistry.Companion$fun <V> mapping(versionParser: (Config) -> Valid<Int>, specifications: Map<Int, Configuration.Specification<V>>) @@ -9540,99 +5149,38 @@ MaxLineLength:VersionedSpecificationRegistry.kt$VersionedSpecificationRegistry.Companion$fun <V> mapping(versionParser: Configuration.Value.Parser<Int>, specifications: Map<Int, Configuration.Specification<V>>) MaxLineLength:VersionedSpecificationRegistry.kt$VersionedSpecificationRegistry.Companion$fun <V> mapping(versionParser: Configuration.Value.Parser<Int>, vararg specifications: Pair<Int, Configuration.Specification<V>>) MaxLineLength:VersionedSpecificationRegistry.kt$VersionedSpecificationRegistry<VALUE> : - MaxLineLength:VirtualCordapps.kt$VirtualCordapp$info = Cordapp.Info.Default("corda-core", versionInfo.vendor, versionInfo.releaseVersion, "Open Source (Apache 2)") - MaxLineLength:VirtualCordapps.kt$VirtualCordapp$info = Cordapp.Info.Default("corda-notary", versionInfo.vendor, versionInfo.releaseVersion, "Open Source (Apache 2)") MaxLineLength:VirtualCordapps.kt$VirtualCordapp$info = Cordapp.Info.Default("corda-notary-bft-smart", versionInfo.vendor, versionInfo.releaseVersion, "Open Source (Apache 2)") - MaxLineLength:VirtualCordapps.kt$VirtualCordapp$info = Cordapp.Info.Default("corda-notary-raft", versionInfo.vendor, versionInfo.releaseVersion, "Open Source (Apache 2)") - MaxLineLength:Volume.kt$Volume$nodeInfoFile.readBytes().deserialize<SignedNodeInfo>().verified().let { NotaryInfo(it.legalIdentities.first(), validating) } - MaxLineLength:Volume.kt$Volume$val validating = ConfigFactory.parseFile(configFile).getConfig("notary").getBooleanCaseInsensitive("validating") - MaxLineLength:WebArgsParser.kt$ArgsParser$// The intent of allowing a command line configurable directory and config path is to allow deployment flexibility. // Other general configuration should live inside the config file unless we regularly need temporary overrides on the command line private val baseDirectoryArg = optionParser .accepts("base-directory", "The node working directory where all the files are kept") .withRequiredArg() .defaultsTo(".") - MaxLineLength:WebArgsParser.kt$ArgsParser$private val logToConsoleArg = optionParser.accepts("log-to-console", "If set, prints logging to the console as well as to a file.") - MaxLineLength:WebServerPluginRegistry.kt$WebServerPluginRegistry MaxLineLength:WebServerPluginRegistry.kt$WebServerPluginRegistry$/** * Map of static serving endpoints to the matching resource directory. All endpoints will be prefixed with "/web" and postfixed with "\*. * Resource directories can be either on disk directories (especially when debugging) in the form "a/b/c". Serving from a JAR can * be specified with: javaClass.getResource("<folder-in-jar>").toExternalForm() */ val staticServeDirs: Map<String, String> get() = emptyMap() MaxLineLength:WhitelistGenerator.kt$logger.info("Include contracts from $INCLUDE_WHITELIST_FILE_NAME: ${includeContracts.joinToString()} present in JARs: $optionalCordappJars.") - MaxLineLength:WhitelistGenerator.kt$private fun readAllLines(path: Path) : List<String> - MaxLineLength:WhitelistGeneratorTest.kt$WhitelistGeneratorTest$val newWhitelist = generateWhitelist(existingWhitelist, emptyList(), listOf(TestContractsJar(contractClassNames = emptyList()))) - MaxLineLength:WhitelistGeneratorTest.kt$WhitelistGeneratorTest$val whitelist = generateWhitelist(emptyMap(), emptyList(), listOf(TestContractsJar(contractClassNames = emptyList()))) MaxLineLength:WireTransaction.kt$WireTransaction : TraversableTransaction - MaxLineLength:WireTransaction.kt$WireTransaction$( inputs: List<StateRef>, attachments: List<SecureHash>, outputs: List<TransactionState<ContractState>>, commands: List<Command<*>>, notary: Party?, timeWindow: TimeWindow?, privacySalt: PrivacySalt = PrivacySalt() ) MaxLineLength:WireTransaction.kt$WireTransaction$( resolveIdentity, resolveAttachment, { stateRef -> resolveStateRef(stateRef)?.serialize() }, { null }, // Returning a dummy `missingAttachment` Attachment allows this deprecated method to work and it disables "contract version no downgrade rule" as a dummy Attachment returns version 1 { resolveAttachment(it.txhash) ?: missingAttachment } ) - MaxLineLength:WireTransaction.kt$WireTransaction$/** * Builds whole Merkle tree for a transaction. * Briefly, each component group has its own sub Merkle tree and all of the roots of these trees are used as leaves * in a top level Merkle tree. * Note that ordering of elements inside a [ComponentGroup] matters when computing the Merkle root. * On the other hand, insertion group ordering does not affect the top level Merkle tree construction, as it is * actually an ordered Merkle tree, where its leaves are ordered based on the group ordinal in [ComponentGroupEnum]. * If any of the groups is an empty list or a null object, then [SecureHash.allOnesHash] is used as its hash. * Also, [privacySalt] is not a Merkle tree leaf, because it is already "inherently" included via the component nonces. */ val merkleTree: MerkleTree by lazy { MerkleTree.getMerkleTree(groupHashes) } - MaxLineLength:WireTransaction.kt$WireTransaction$/** * Calculate nonces for every transaction component, including new fields (due to backwards compatibility support) we cannot process. * Nonce are computed in the following way: * nonce1 = H(salt || path_for_1st_component) * nonce2 = H(salt || path_for_2nd_component) * etc. * Thus, all of the nonces are "independent" in the sense that knowing one or some of them, you can learn * nothing about the rest. */ internal val availableComponentNonces: Map<Int, List<SecureHash>> by lazy { componentGroups.map { Pair(it.groupIndex, it.components.mapIndexed { internalIndex, internalIt -> componentHash(internalIt, privacySalt, it.groupIndex, internalIndex) }) }.toMap() } - MaxLineLength:WireTransaction.kt$WireTransaction$/** * The leaves (group hashes) of the top level Merkle tree. * If a group's Merkle root is allOnesHash, it is a flag that denotes this group is empty (if list) or null (if single object) * in the wire transaction. */ internal val groupHashes: List<SecureHash> by lazy { val listOfLeaves = mutableListOf<SecureHash>() // Even if empty and not used, we should at least send oneHashes for each known // or received but unknown (thus, bigger than known ordinal) component groups. for (i in 0..componentGroups.map { it.groupIndex }.max()!!) { val root = groupsMerkleRoots[i] ?: SecureHash.allOnesHash listOfLeaves.add(root) } listOfLeaves } MaxLineLength:WireTransaction.kt$WireTransaction$// This calculates a value that is slightly lower than the actual re-serialized version. But it is stable and does not depend on the classloader. fun componentGroupSize(componentGroup: ComponentGroupEnum): Int MaxLineLength:WireTransaction.kt$WireTransaction$ReplaceWith("WireTransaction(val componentGroups: List<ComponentGroup>, override val privacySalt: PrivacySalt)") - MaxLineLength:WireTransaction.kt$WireTransaction$SerializedStateAndRef(resolveStateRefAsSerialized(ref) ?: throw TransactionResolutionException(ref.txhash), ref) - MaxLineLength:WireTransaction.kt$WireTransaction$check(componentGroups.map { it.groupIndex }.toSet().size == componentGroups.size) { "Duplicated component groups detected" } - MaxLineLength:WireTransaction.kt$WireTransaction$check(inputs.isNotEmpty() || outputs.isNotEmpty()) { "A transaction must contain at least one input or output state" } - MaxLineLength:WireTransaction.kt$WireTransaction$checkTransactionSize(ltx, resolvedNetworkParameters.maxTransactionSize, serializedResolvedInputs, serializedResolvedReferences) MaxLineLength:WireTransaction.kt$WireTransaction$componentGroups.map { Pair(it.groupIndex, it.components.mapIndexed { internalIndex, internalIt -> componentHash(availableComponentNonces[it.groupIndex]!![internalIndex], internalIt) }) }.toMap() MaxLineLength:WireTransaction.kt$WireTransaction$componentGroups.map { Pair(it.groupIndex, it.components.mapIndexed { internalIndex, internalIt -> componentHash(internalIt, privacySalt, it.groupIndex, internalIndex) }) }.toMap() MaxLineLength:WireTransaction.kt$WireTransaction$require(remainingTransactionSize > size) { "Transaction exceeded network's maximum transaction size limit : $maxTransactionSize bytes." } MaxLineLength:WireTransaction.kt$WireTransaction$return this.componentGroups.firstOrNull { it.groupIndex == componentGroup.ordinal }?.let { cg -> cg.components.sumBy { it.size } + 4 } ?: 0 - MaxLineLength:WireTransaction.kt$WireTransaction$val resolvedAttachments = attachments.lazyMapped { att, _ -> resolveAttachment(att) ?: throw AttachmentResolutionException(att) } MaxLineLength:WireTransaction.kt$WireTransaction$val resolvedNetworkParameters = resolveParameters(networkParametersHash) ?: throw TransactionResolutionException.UnknownParametersException(id, networkParametersHash!!) - MaxLineLength:WireTransaction.kt$WireTransaction${ var remainingTransactionSize = maxTransactionSize fun minus(size: Int) { require(remainingTransactionSize > size) { "Transaction exceeded network's maximum transaction size limit : $maxTransactionSize bytes." } remainingTransactionSize -= size } // This calculates a value that is slightly lower than the actual re-serialized version. But it is stable and does not depend on the classloader. fun componentGroupSize(componentGroup: ComponentGroupEnum): Int { return this.componentGroups.firstOrNull { it.groupIndex == componentGroup.ordinal }?.let { cg -> cg.components.sumBy { it.size } + 4 } ?: 0 } // Check attachments size first as they are most likely to go over the limit. With ContractAttachment instances // it's likely that the same underlying Attachment CorDapp will occur more than once so we dedup on the attachment id. ltx.attachments.distinctBy { it.id }.forEach { minus(it.size) } minus(resolvedSerializedInputs.sumBy { it.serializedState.size }) minus(resolvedSerializedReferences.sumBy { it.serializedState.size }) // For Commands and outputs we can use the component groups as they are already serialized. minus(componentGroupSize(COMMANDS_GROUP)) minus(componentGroupSize(OUTPUTS_GROUP)) } MaxLineLength:WireTransaction.kt$WireTransaction.Companion$ @CordaInternal fun resolveStateRefBinaryComponent(stateRef: StateRef, services: ServicesForResolution): SerializedBytes<TransactionState<ContractState>>? MaxLineLength:WireTransaction.kt$WireTransaction.Companion$else -> throw UnsupportedOperationException("Attempting to resolve input ${stateRef.index} of a ${coreTransaction.javaClass} transaction. This is not supported.") - MaxLineLength:WireTransaction.kt$WireTransaction.Companion$is ContractUpgradeWireTransaction -> coreTransaction.resolveOutputComponent(services, stateRef, params) MaxLineLength:WireTransaction.kt$WireTransaction.Companion$val params = services.networkParametersService.lookup(paramsHash) ?: throw IllegalStateException("Should have been able to fetch parameters by this point: $paramsHash") - MaxLineLength:WithContracts.kt$WithContracts$//region Operations fun TestStartedNode.signDummyContract(owner: PartyAndReference, magicNumber: Int = 0, vararg others: PartyAndReference) - MaxLineLength:WithFinality.kt$WithFinality$//region Operations fun TestStartedNode.finalise(stx: SignedTransaction, vararg recipients: Party): FlowStateMachine<SignedTransaction> - MaxLineLength:WithReferencedStatesFlow.kt$WithReferencedStatesFlow<T : Any> : FlowLogic MaxLineLength:WorkflowTransactionBuildTutorial.kt$SubmitCompletionFlow : FlowLogic MaxLineLength:WorkflowTransactionBuildTutorial.kt$TradeApprovalContract$"Completed command requires the counterparty as signer" using (command.signers.contains(before.counterparty.owningKey)) - MaxLineLength:WorkflowTransactionBuildTutorial.kt$TradeApprovalContract$"Completed command requires the source Party as signer" using (command.signers.contains(before.source.owningKey)) - MaxLineLength:WorkflowTransactionBuildTutorial.kt$TradeApprovalContract$"Issue requires the source Party as signer" using (command.signers.contains(issued.source.owningKey)) - MaxLineLength:WorkflowTransactionBuildTutorial.kt$TradeApprovalContract$"Output must be a final state" using (after.state in setOf(WorkflowState.APPROVED, WorkflowState.REJECTED)) - MaxLineLength:X500Utils.kt$ fun X500Principal.toAttributesMap(supportedAttributes: Set<ASN1ObjectIdentifier> = emptySet()): Map<ASN1ObjectIdentifier, ASN1Encodable> MaxLineLength:X509KeyStore.kt$X509KeyStore - MaxLineLength:X509KeyStore.kt$X509KeyStore$val certArray = requireNotNull(internal.getCertificateChain(alias)) { "No certificate chain under the alias $alias" } MaxLineLength:X509KeyStore.kt$X509KeyStore.Companion$val internal: KeyStore = if (createNew) loadOrCreateKeyStore(keyStoreFile, storePassword) else loadKeyStore(keyStoreFile, storePassword) - MaxLineLength:X509NameConstraintsTest.kt$X509NameConstraintsTest$private MaxLineLength:X509NameConstraintsTest.kt$X509NameConstraintsTest$setPrivateKey(X509Utilities.CORDA_CLIENT_TLS, tlsKeyPair.private, listOf(tlsCert, nodeCaCert, intermediateCa.certificate, rootCa.certificate), keyPassword) - MaxLineLength:X509NameConstraintsTest.kt$X509NameConstraintsTest$val (keystore, trustStore) = makeKeyStores(X500Name("CN=Bank A TLS, UID=, E=me@email.com, C=GB"), nameConstraints) - MaxLineLength:X509NameConstraintsTest.kt$X509NameConstraintsTest$val (keystore, trustStore) = makeKeyStores(X500Name("O=Bank A, UID=, E=me@email.com, C=GB"), nameConstraints) - MaxLineLength:X509Utilities.kt$CertificateType$enum - MaxLineLength:X509Utilities.kt$X509Utilities$ @JvmStatic fun createCertificate(certificateType: CertificateType, issuerCertificate: X509Certificate, issuerKeyPair: KeyPair, subject: X500Principal, subjectPublicKey: PublicKey, validityWindow: Pair<Duration, Duration> = DEFAULT_VALIDITY_WINDOW, nameConstraints: NameConstraints? = null, crlDistPoint: String? = null, crlIssuer: X500Name? = null): X509Certificate - MaxLineLength:X509Utilities.kt$X509Utilities$ @JvmStatic fun saveCertificateAsPEMFile(certificate: X509Certificate, file: Path) MaxLineLength:X509Utilities.kt$X509Utilities$ fun createCertificateSigningRequest(subject: X500Principal, email: String, publicKey: PublicKey, contentSigner: ContentSigner, certRole: CertRole = CertRole.NODE_CA): PKCS10CertificationRequest - MaxLineLength:X509Utilities.kt$X509Utilities$ fun getCertificateValidityWindow(before: Duration, after: Duration, parent: X509Certificate? = null): Pair<Date, Date> MaxLineLength:X509Utilities.kt$X509Utilities$JcaX509v3CertificateBuilder(issuer, serial, validityWindow.first, validityWindow.second, subject, subjectPublicKey) .addExtension(Extension.subjectKeyIdentifier, false, BcX509ExtensionUtils().createSubjectKeyIdentifier(subjectPublicKeyInfo)) MaxLineLength:X509Utilities.kt$X509Utilities$JcaX509v3CertificateBuilder(issuer, serial, validityWindow.first, validityWindow.second, subject, subjectPublicKey) .addExtension(Extension.subjectKeyIdentifier, false, BcX509ExtensionUtils().createSubjectKeyIdentifier(subjectPublicKeyInfo)) .addExtension(Extension.basicConstraints, true, BasicConstraints(certificateType.isCA)) .addExtension(Extension.keyUsage, false, certificateType.keyUsage) .addExtension(Extension.extendedKeyUsage, false, keyPurposes) .addExtension(Extension.authorityKeyIdentifier, false, JcaX509ExtensionUtils().createAuthorityKeyIdentifier(issuerPublicKey)) MaxLineLength:X509Utilities.kt$X509Utilities$fun createCertificateSigningRequest(subject: X500Principal, email: String, keyPair: KeyPair, certRole: CertRole = CertRole.NODE_CA): PKCS10CertificationRequest - MaxLineLength:X509Utilities.kt$X509Utilities$require(isSignatureValid(JcaContentVerifierProviderBuilder().build(issuerKeyPair.public))){"Invalid signature"} - MaxLineLength:X509Utilities.kt$X509Utilities$val builder = JcaX509v3CertificateBuilder(issuer, serial, validityWindow.first, validityWindow.second, subject, subjectPublicKey) .addExtension(Extension.subjectKeyIdentifier, false, BcX509ExtensionUtils().createSubjectKeyIdentifier(subjectPublicKeyInfo)) .addExtension(Extension.basicConstraints, true, BasicConstraints(certificateType.isCA)) .addExtension(Extension.keyUsage, false, certificateType.keyUsage) .addExtension(Extension.extendedKeyUsage, false, keyPurposes) .addExtension(Extension.authorityKeyIdentifier, false, JcaX509ExtensionUtils().createAuthorityKeyIdentifier(issuerPublicKey)) MaxLineLength:X509Utilities.kt$X509Utilities$val builder = createPartialCertificate(certificateType, issuer, issuerPublicKey, subject, subjectPublicKey, validityWindow, nameConstraints, crlDistPoint, crlIssuer) - MaxLineLength:X509Utilities.kt$X509Utilities$val distPointName = DistributionPointName(GeneralNames(GeneralName(GeneralName.uniformResourceIdentifier, crlDistPoint))) - MaxLineLength:X509Utilities.kt$X509Utilities$val signer = ContentSignerBuilder.build(signatureScheme, keyPair.private, Crypto.findProvider(signatureScheme.providerName)) - MaxLineLength:X509Utilities.kt$X509Utilities$validityWindow: Pair<Duration, Duration> = DEFAULT_VALIDITY_WINDOW MaxLineLength:X509Utilities.kt$X509Utilities${ val distPointName = DistributionPointName(GeneralNames(GeneralName(GeneralName.uniformResourceIdentifier, crlDistPoint))) val crlIssuerGeneralNames = crlIssuer?.let { GeneralNames(GeneralName(crlIssuer)) } // The second argument is flag that allows you to define what reason of certificate revocation is served by this distribution point see [ReasonFlags]. // The idea is that you have different revocation per revocation reason. Since we won't go into such a granularity, we can skip that parameter. // The third argument allows you to specify the name of the CRL issuer, it needs to be consistent with the crl (IssuingDistributionPoint) extension and the idp argument. // If idp == true, set it, if idp == false, leave it null as done here. val distPoint = DistributionPoint(distPointName, null, crlIssuerGeneralNames) builder.addExtension(Extension.cRLDistributionPoints, false, CRLDistPoint(arrayOf(distPoint))) } - MaxLineLength:X509Utilities.kt$val Certificate.x509: X509Certificate get() = requireNotNull(this as? X509Certificate) { "Not an X.509 certificate: $this" } - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$Crypto.supportedSignatureSchemes().filter { it != COMPOSITE_KEY }.forEach { serializeDeserializeX509CertPath(it) } - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$assertFalse { keyUsage.hasUsages(5) } - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$assertTrue { Crypto.isValid(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME, serverCert.publicKey, signature, testData) } MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$childSubject: X500Principal = X500Principal("CN=Test Child Cert,O=R3 Ltd,L=London,C=GB") - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$clientParams.endpointIdentificationAlgorithm = null MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$p2pSslConfig.keyStore.get(createNew = true).also { it.registerDevP2pCertificates(MEGA_CORP.name, rootCa.certificate, intermediateCa, nodeCa) } - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$private - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$serverParams.endpointIdentificationAlgorithm = null MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$signingCertStore.get(createNew = true).also { it.registerDevSigningCertificates(MEGA_CORP.name, rootCa.certificate, intermediateCa, nodeCa) } - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val (_, caCert, childKeyPair, childCert) = genCaAndChildKeysCertsAndSubjects(signatureSchemeRoot, signatureSchemeChild) - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val (serverCert, serverKeyPair) = serverKeyStore.getCertificateAndKeyPair(X509Utilities.CORDA_CLIENT_CA, certStore.entryPassword) MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val (sslCert) = sslKeyStoreReloaded.query { getCertificateAndKeyPair(X509Utilities.CORDA_CLIENT_TLS, sslKeyStoreReloaded.entryPassword) } - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val caCert = X509Utilities.createSelfSignedCACertificate(X500Principal("CN=Test CA Cert,O=R3 Ltd,L=London,C=GB"), caKey) - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val caCert = X509Utilities.createSelfSignedCACertificate(X500Principal("CN=Test Cert,O=R3 Ltd,L=London,C=GB"), caKey) MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val caSubjectKeyIdentifier = SubjectKeyIdentifier.getInstance(caCert.toBc().getExtension(Extension.subjectKeyIdentifier).parsedValue) MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val certCaAuthorityKeyIdentifier = AuthorityKeyIdentifier.getInstance(getExtension(Extension.authorityKeyIdentifier).parsedValue) - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val certificate = X509Utilities.createCertificate(CertificateType.TLS, rootCACert, rootCAKey, BOB_NAME.x500Principal, BOB.publicKey) - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val childCert = X509Utilities.createCertificate(CertificateType.TLS, caCert, caKeyPair, childSubject, childKeyPair.public) - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val expected = X509Utilities.createSelfSignedCACertificate(ALICE.name.x500Principal, generateKeyPair(signatureScheme)) - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val p2pSslConfig = CertificateStoreStubs.P2P.withCertificatesDirectory(certificatesDirectory, keyStorePassword = "serverstorepass") - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val serverSocket = serverSocketFactory.createServerSocket(0) as SSLServerSocket // use 0 to get first free socket - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val signingCertStore = CertificateStoreStubs.Signing.withCertificatesDirectory(certificatesDirectory, "serverstorepass") - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest$val sslConfig = CertificateStoreStubs.P2P.withCertificatesDirectory(tempFolder.root.toPath(), keyStorePassword = "serverstorepass") - MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest.Companion$// We ensure that all of the algorithms are both used (at least once) as first and second in the following [Pair]s. // We also add [DEFAULT_TLS_SIGNATURE_SCHEME] and [DEFAULT_IDENTITY_SIGNATURE_SCHEME] combinations for consistency. val certChainSchemeCombinations = listOf( Pair(DEFAULT_TLS_SIGNATURE_SCHEME, DEFAULT_TLS_SIGNATURE_SCHEME), Pair(DEFAULT_IDENTITY_SIGNATURE_SCHEME, DEFAULT_IDENTITY_SIGNATURE_SCHEME), Pair(DEFAULT_TLS_SIGNATURE_SCHEME, DEFAULT_IDENTITY_SIGNATURE_SCHEME), Pair(ECDSA_SECP256R1_SHA256, SPHINCS256_SHA256), Pair(ECDSA_SECP256K1_SHA256, RSA_SHA256), Pair(EDDSA_ED25519_SHA512, ECDSA_SECP256K1_SHA256), Pair(RSA_SHA256, EDDSA_ED25519_SHA512), Pair(SPHINCS256_SHA256, ECDSA_SECP256R1_SHA256) ) MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest.Companion$Triple(ECDSA_SECP256K1_SHA256,java.security.interfaces.ECPrivateKey::class.java, org.bouncycastle.jce.interfaces.ECPrivateKey::class.java) MaxLineLength:X509UtilitiesTest.kt$X509UtilitiesTest.Companion$Triple(ECDSA_SECP256R1_SHA256,java.security.interfaces.ECPrivateKey::class.java, org.bouncycastle.jce.interfaces.ECPrivateKey::class.java) MaxLineLength:YearMonthSerializer.kt$YearMonthSerializer : Proxy @@ -9640,7 +5188,6 @@ MaxLineLength:ZoneIdSerializer.kt$ZoneIdSerializer : Proxy MaxLineLength:ZonedDateTimeSerializer.kt$ZonedDateTimeSerializer : Proxy MaxLineLength:ZonedDateTimeSerializer.kt$ZonedDateTimeSerializer$override fun fromProxy(proxy: ZonedDateTimeProxy): ZonedDateTime - MaxLineLength:ZonedDateTimeSerializer.kt$ZonedDateTimeSerializer$override fun toProxy(obj: ZonedDateTime): ZonedDateTimeProxy MaxLineLength:ZonedDateTimeSerializer.kt$ZonedDateTimeSerializer$override val additionalSerializers: Iterable<CustomSerializer<out Any>> = listOf(LocalDateTimeSerializer(factory), ZoneIdSerializer(factory)) MaxLineLength:ZonedDateTimeSerializer.kt$ZonedDateTimeSerializer.Companion$val ofLenient: Method = ZonedDateTime::class.java.getDeclaredMethod("ofLenient", LocalDateTime::class.java, ZoneOffset::class.java, ZoneId::class.java) ModifierOrder:NodeNamedCache.kt$DefaultNamedCacheFactory$open protected @@ -9691,630 +5238,6 @@ NestedBlockDepth:StatusTransitions.kt$StatusTransitions$ fun verify(tx: LedgerTransaction) NestedBlockDepth:ThrowableSerializer.kt$ThrowableSerializer$override fun fromProxy(proxy: ThrowableProxy): Throwable NestedBlockDepth:TransactionVerifierServiceInternal.kt$Verifier$ private fun verifyConstraintsValidity(contractAttachmentsByContract: Map<ContractClassName, ContractAttachment>) - NewLineAtEndOfFile:AMQPBridgeManager.kt$net.corda.nodeapi.internal.bridging.AMQPBridgeManager.kt - NewLineAtEndOfFile:AMQPBridgeTest.kt$net.corda.node.amqp.AMQPBridgeTest.kt - NewLineAtEndOfFile:AMQPChannelHandler.kt$net.corda.nodeapi.internal.protonwrapper.netty.AMQPChannelHandler.kt - NewLineAtEndOfFile:AMQPClient.kt$net.corda.nodeapi.internal.protonwrapper.netty.AMQPClient.kt - NewLineAtEndOfFile:AMQPExceptions.kt$net.corda.serialization.internal.amqp.AMQPExceptions.kt - NewLineAtEndOfFile:AMQPPrimitiveSerializer.kt$net.corda.serialization.internal.amqp.AMQPPrimitiveSerializer.kt - NewLineAtEndOfFile:AMQPRemoteTypeModel.kt$net.corda.serialization.internal.amqp.AMQPRemoteTypeModel.kt - NewLineAtEndOfFile:AMQPRemoteTypeModelTests.kt$net.corda.serialization.internal.amqp.AMQPRemoteTypeModelTests.kt - NewLineAtEndOfFile:AMQPSerializerFactories.kt$net.corda.serialization.internal.amqp.AMQPSerializerFactories.kt - NewLineAtEndOfFile:AMQPServer.kt$net.corda.nodeapi.internal.protonwrapper.netty.AMQPServer.kt - NewLineAtEndOfFile:AMQPTestSerialiationScheme.kt$net.corda.node.internal.serialization.testutils.AMQPTestSerialiationScheme.kt - NewLineAtEndOfFile:AMQPTypeIdentifierParser.kt$net.corda.serialization.internal.amqp.AMQPTypeIdentifierParser.kt - NewLineAtEndOfFile:AMQPTypeIdentifierParserTests.kt$net.corda.serialization.internal.amqp.AMQPTypeIdentifierParserTests.kt - NewLineAtEndOfFile:AMQPTypeIdentifiers.kt$net.corda.serialization.internal.amqp.AMQPTypeIdentifiers.kt - NewLineAtEndOfFile:ANSIProgressRenderer.kt$net.corda.tools.shell.utlities.ANSIProgressRenderer.kt - NewLineAtEndOfFile:ANSIProgressRendererTest.kt$net.corda.tools.shell.utilities.ANSIProgressRendererTest.kt - NewLineAtEndOfFile:APIServer.kt$net.corda.webserver.api.APIServer.kt - NewLineAtEndOfFile:AbstractCashFlow.kt$net.corda.finance.flows.AbstractCashFlow.kt - NewLineAtEndOfFile:AbstractNode.kt$net.corda.node.internal.AbstractNode.kt - NewLineAtEndOfFile:AbstractParty.kt$net.corda.core.identity.AbstractParty.kt - NewLineAtEndOfFile:AbstractPartyDescriptor.kt$net.corda.node.services.persistence.AbstractPartyDescriptor.kt - NewLineAtEndOfFile:Address.kt$net.corda.common.configuration.parsing.internal.Address.kt - NewLineAtEndOfFile:AddressBindingException.kt$net.corda.core.internal.errors.AddressBindingException.kt - NewLineAtEndOfFile:AddressBindingFailureTests.kt$net.corda.node.AddressBindingFailureTests.kt - NewLineAtEndOfFile:AddressUtils.kt$net.corda.node.utilities.AddressUtils.kt - NewLineAtEndOfFile:Addresses.kt$net.corda.common.configuration.parsing.internal.Addresses.kt - NewLineAtEndOfFile:AdvancedExceptionDialog.kt$net.corda.explorer.ui.AdvancedExceptionDialog.kt - NewLineAtEndOfFile:AllExceptionMapper.kt$net.corda.webserver.internal.AllExceptionMapper.kt - NewLineAtEndOfFile:AmountTest.kt$net.corda.client.jackson.AmountTest.kt - NewLineAtEndOfFile:AmountTests.kt$net.corda.core.contracts.AmountTests.kt - NewLineAtEndOfFile:AnalysisContext.kt$net.corda.djvm.analysis.AnalysisContext.kt - NewLineAtEndOfFile:AnnotationModule.kt$net.corda.djvm.references.AnnotationModule.kt - NewLineAtEndOfFile:AnonymousParty.kt$net.corda.core.identity.AnonymousParty.kt - NewLineAtEndOfFile:AnotherDummyContract.kt$net.corda.isolated.contracts.AnotherDummyContract.kt - NewLineAtEndOfFile:AppendOnlyPersistentMapNonConcurrentTest.kt$net.corda.node.services.persistence.AppendOnlyPersistentMapNonConcurrentTest.kt - NewLineAtEndOfFile:AppendOnlyPersistentMapTest.kt$net.corda.node.services.persistence.AppendOnlyPersistentMapTest.kt - NewLineAtEndOfFile:ApplicationMessage.kt$net.corda.nodeapi.internal.protonwrapper.messages.ApplicationMessage.kt - NewLineAtEndOfFile:ArgumentUnwrapper.kt$net.corda.djvm.rules.implementation.ArgumentUnwrapper.kt - NewLineAtEndOfFile:Arrangement.kt$net.corda.finance.contracts.universal.Arrangement.kt - NewLineAtEndOfFile:ArtemisBroker.kt$net.corda.node.internal.artemis.ArtemisBroker.kt - NewLineAtEndOfFile:ArtemisRpcTests.kt$net.corda.node.services.rpc.ArtemisRpcTests.kt - NewLineAtEndOfFile:ArtemisTcpTransport.kt$net.corda.nodeapi.internal.ArtemisTcpTransport.kt - NewLineAtEndOfFile:AssertiveDJVMObject.kt$net.corda.djvm.assertions.AssertiveDJVMObject.kt - NewLineAtEndOfFile:AsyncLoggingTest.kt$net.corda.node.utilities.logging.AsyncLoggingTest.kt - NewLineAtEndOfFile:AttachmentTest.kt$net.corda.deterministic.contracts.AttachmentTest.kt - NewLineAtEndOfFile:AttachmentVersionNumberMigration.kt$net.corda.nodeapi.internal.persistence.AttachmentVersionNumberMigration.kt - NewLineAtEndOfFile:AttachmentWithContext.kt$net.corda.core.internal.AttachmentWithContext.kt - NewLineAtEndOfFile:AttachmentsClassLoader.kt$net.corda.core.serialization.internal.AttachmentsClassLoader.kt - NewLineAtEndOfFile:AuthDBTests.kt$net.corda.node.AuthDBTests.kt - NewLineAtEndOfFile:AuthenticatedRpcOpsProxy.kt$net.corda.node.internal.rpc.proxies.AuthenticatedRpcOpsProxy.kt - NewLineAtEndOfFile:AuthorizingSubject.kt$net.corda.node.internal.security.AuthorizingSubject.kt - NewLineAtEndOfFile:AzureBackend.kt$net.corda.networkbuilder.backends.AzureBackend.kt - NewLineAtEndOfFile:AzureContainerPusher.kt$net.corda.networkbuilder.containers.push.azure.AzureContainerPusher.kt - NewLineAtEndOfFile:AzureInstantiator.kt$net.corda.networkbuilder.containers.instance.azure.AzureInstantiator.kt - NewLineAtEndOfFile:AzureRegistryLocator.kt$net.corda.networkbuilder.containers.push.azure.AzureRegistryLocator.kt - NewLineAtEndOfFile:AzureSmbVolume.kt$net.corda.networkbuilder.volumes.azure.AzureSmbVolume.kt - NewLineAtEndOfFile:Backend.kt$net.corda.networkbuilder.backends.Backend.kt - NewLineAtEndOfFile:BankOfCordaWebApi.kt$net.corda.bank.api.BankOfCordaWebApi.kt - NewLineAtEndOfFile:BaseTransaction.kt$net.corda.core.transactions.BaseTransaction.kt - NewLineAtEndOfFile:BaseTransactions.kt$net.corda.core.transactions.BaseTransactions.kt - NewLineAtEndOfFile:BigDecimalSerializer.kt$net.corda.serialization.internal.amqp.custom.BigDecimalSerializer.kt - NewLineAtEndOfFile:BigIntegerSerializer.kt$net.corda.serialization.internal.amqp.custom.BigIntegerSerializer.kt - NewLineAtEndOfFile:BitSetSerializer.kt$net.corda.serialization.internal.amqp.custom.BitSetSerializer.kt - NewLineAtEndOfFile:BootstrapperView.kt$net.corda.networkbuilder.gui.BootstrapperView.kt - NewLineAtEndOfFile:BranchInstruction.kt$net.corda.djvm.code.instructions.BranchInstruction.kt - NewLineAtEndOfFile:BridgeControlListener.kt$net.corda.nodeapi.internal.bridging.BridgeControlListener.kt - NewLineAtEndOfFile:BridgeControlMessages.kt$net.corda.nodeapi.internal.bridging.BridgeControlMessages.kt - NewLineAtEndOfFile:BridgeManager.kt$net.corda.nodeapi.internal.bridging.BridgeManager.kt - NewLineAtEndOfFile:BridgeMetricsService.kt$net.corda.nodeapi.internal.bridging.BridgeMetricsService.kt - NewLineAtEndOfFile:BrokerJaasLoginModule.kt$net.corda.node.internal.artemis.BrokerJaasLoginModule.kt - NewLineAtEndOfFile:BrokerRpcSslOptions.kt$net.corda.nodeapi.BrokerRpcSslOptions.kt - NewLineAtEndOfFile:BuiltNode.kt$net.corda.networkbuilder.nodes.BuiltNode.kt - NewLineAtEndOfFile:CarpenterExceptionTests.kt$net.corda.serialization.internal.carpenter.CarpenterExceptionTests.kt - NewLineAtEndOfFile:CarpentryDependencyGraph.kt$net.corda.serialization.internal.model.CarpentryDependencyGraph.kt - NewLineAtEndOfFile:Cash.kt$net.corda.behave.scenarios.helpers.Cash.kt - NewLineAtEndOfFile:CashSelectionH2Impl.kt$net.corda.finance.workflows.asset.selection.CashSelectionH2Impl.kt - NewLineAtEndOfFile:CashSelectionH2ImplTest.kt$net.corda.finance.workflows.asset.selection.CashSelectionH2ImplTest.kt - NewLineAtEndOfFile:CashSelectionSQLServerImpl.kt$net.corda.finance.workflows.asset.selection.CashSelectionSQLServerImpl.kt - NewLineAtEndOfFile:CertPathSerializer.kt$net.corda.serialization.internal.amqp.custom.CertPathSerializer.kt - NewLineAtEndOfFile:CertificateChainCheckPolicy.kt$net.corda.node.internal.artemis.CertificateChainCheckPolicy.kt - NewLineAtEndOfFile:CertificateStore.kt$net.corda.nodeapi.internal.config.CertificateStore.kt - NewLineAtEndOfFile:CertificateStoreStubs.kt$net.corda.testing.internal.stubs.CertificateStoreStubs.kt - NewLineAtEndOfFile:CertificatesUtils.kt$net.corda.node.utilities.CertificatesUtils.kt - NewLineAtEndOfFile:CheatingSecurityProvider.kt$net.corda.deterministic.CheatingSecurityProvider.kt - NewLineAtEndOfFile:CheckpointSerializationAPI.kt$net.corda.core.serialization.internal.CheckpointSerializationAPI.kt - NewLineAtEndOfFile:CheckpointSerializationScheme.kt$net.corda.serialization.internal.CheckpointSerializationScheme.kt - NewLineAtEndOfFile:CheckpointStorage.kt$net.corda.node.services.api.CheckpointStorage.kt - NewLineAtEndOfFile:ChosenList.kt$net.corda.client.jfx.utils.ChosenList.kt - NewLineAtEndOfFile:CityDatabaseTest.kt$net.corda.worldmap.CityDatabaseTest.kt - NewLineAtEndOfFile:ClassCarpenterWhitelistTest.kt$net.corda.serialization.internal.carpenter.ClassCarpenterWhitelistTest.kt - NewLineAtEndOfFile:ClassCarpentingTypeLoaderTests.kt$net.corda.serialization.internal.model.ClassCarpentingTypeLoaderTests.kt - NewLineAtEndOfFile:ClassCommand.kt$net.corda.djvm.tools.cli.ClassCommand.kt - NewLineAtEndOfFile:ClassHierarchyTest.kt$net.corda.djvm.references.ClassHierarchyTest.kt - NewLineAtEndOfFile:ClassLoadingUtils.kt$net.corda.core.internal.ClassLoadingUtils.kt - NewLineAtEndOfFile:ClassLoadingUtilsTest.kt$net.corda.core.internal.ClassLoadingUtilsTest.kt - NewLineAtEndOfFile:ClassModuleTest.kt$net.corda.djvm.references.ClassModuleTest.kt - NewLineAtEndOfFile:ClassResolver.kt$net.corda.djvm.analysis.ClassResolver.kt - NewLineAtEndOfFile:ClassRewriterTest.kt$net.corda.djvm.rewiring.ClassRewriterTest.kt - NewLineAtEndOfFile:ClassSerializer.kt$net.corda.serialization.internal.amqp.custom.ClassSerializer.kt - NewLineAtEndOfFile:ClassSource.kt$net.corda.djvm.source.ClassSource.kt - NewLineAtEndOfFile:ClearNetworkCacheCli.kt$net.corda.node.internal.subcommands.ClearNetworkCacheCli.kt - NewLineAtEndOfFile:CliBackwardsCompatibleTest.kt$net.corda.testing.CliBackwardsCompatibleTest.kt - NewLineAtEndOfFile:ClientCacheFactory.kt$net.corda.client.rpc.internal.ClientCacheFactory.kt - NewLineAtEndOfFile:ClientRelevantError.kt$net.corda.core.ClientRelevantError.kt - NewLineAtEndOfFile:ClientRelevantException.kt$net.corda.ClientRelevantException.kt - NewLineAtEndOfFile:ClientRpcExample.kt$net.corda.docs.kotlin.ClientRpcExample.kt - NewLineAtEndOfFile:ClientRpcSslOptions.kt$net.corda.core.messaging.ClientRpcSslOptions.kt - NewLineAtEndOfFile:ClientRpcTutorial.kt$net.corda.docs.kotlin.ClientRpcTutorial.kt - NewLineAtEndOfFile:CollectionSerializer.kt$net.corda.serialization.internal.amqp.CollectionSerializer.kt - NewLineAtEndOfFile:CommandLineCompatibilityCheckerTest.kt$net.corda.testing.CommandLineCompatibilityCheckerTest.kt - NewLineAtEndOfFile:CommandLineCompatibilityUtils.kt$net.corda.testing.CommandLineCompatibilityUtils.kt - NewLineAtEndOfFile:CommandTests.kt$net.corda.behave.process.CommandTests.kt - NewLineAtEndOfFile:CommandsSerializationTests.kt$net.corda.core.serialization.CommandsSerializationTests.kt - NewLineAtEndOfFile:CommercialPaper.kt$net.corda.finance.contracts.CommercialPaper.kt - NewLineAtEndOfFile:CommonSchema.kt$net.corda.core.schemas.CommonSchema.kt - NewLineAtEndOfFile:CompatibilityTest.kt$net.corda.finance.flows.CompatibilityTest.kt - NewLineAtEndOfFile:ComposableTypePropertySerializer.kt$net.corda.serialization.internal.amqp.ComposableTypePropertySerializer.kt - NewLineAtEndOfFile:CompositeSignature.kt$net.corda.core.crypto.CompositeSignature.kt - NewLineAtEndOfFile:ConfigExporter.kt$net.corda.core.ConfigExporter.kt - NewLineAtEndOfFile:ConfigParsingTest.kt$net.corda.nodeapi.internal.config.ConfigParsingTest.kt - NewLineAtEndOfFile:ConfigSections.kt$net.corda.node.services.config.schema.v1.ConfigSections.kt - NewLineAtEndOfFile:Configuration.kt$net.corda.common.configuration.parsing.internal.Configuration.kt - NewLineAtEndOfFile:ConjunctiveWatch.kt$net.corda.behave.monitoring.ConjunctiveWatch.kt - NewLineAtEndOfFile:ConnectionChange.kt$net.corda.nodeapi.internal.protonwrapper.netty.ConnectionChange.kt - NewLineAtEndOfFile:ConnectionStateMachine.kt$net.corda.nodeapi.internal.protonwrapper.engine.ConnectionStateMachine.kt - NewLineAtEndOfFile:ConstantInstruction.kt$net.corda.djvm.code.instructions.ConstantInstruction.kt - NewLineAtEndOfFile:Constants.kt$net.corda.networkbuilder.Constants.kt - NewLineAtEndOfFile:ConstructorForDeserialization.kt$net.corda.core.serialization.ConstructorForDeserialization.kt - NewLineAtEndOfFile:ContainerPusher.kt$net.corda.networkbuilder.containers.push.ContainerPusher.kt - NewLineAtEndOfFile:Context.kt$net.corda.networkbuilder.context.Context.kt - NewLineAtEndOfFile:ContextualLoggingUtils.kt$net.corda.node.services.logging.ContextualLoggingUtils.kt - NewLineAtEndOfFile:ContractAttachmentSerializer.kt$net.corda.serialization.internal.amqp.custom.ContractAttachmentSerializer.kt - NewLineAtEndOfFile:ContractHierarchyTest.kt$net.corda.core.contracts.ContractHierarchyTest.kt - NewLineAtEndOfFile:ContractJarTestUtils.kt$net.corda.testing.core.internal.ContractJarTestUtils.kt - NewLineAtEndOfFile:ContractUpgradeTransactions.kt$net.corda.core.transactions.ContractUpgradeTransactions.kt - NewLineAtEndOfFile:ContractUpgradeUtils.kt$net.corda.core.internal.ContractUpgradeUtils.kt - NewLineAtEndOfFile:Converters.kt$net.corda.webserver.converters.Converters.kt - NewLineAtEndOfFile:CopiedNode.kt$net.corda.networkbuilder.nodes.CopiedNode.kt - NewLineAtEndOfFile:CopiedNotary.kt$net.corda.networkbuilder.notaries.CopiedNotary.kt - NewLineAtEndOfFile:CorDappSerializerTests.kt$net.corda.serialization.internal.amqp.CorDappSerializerTests.kt - NewLineAtEndOfFile:CordaAuthenticationPlugin.kt$net.corda.tools.shell.CordaAuthenticationPlugin.kt - NewLineAtEndOfFile:CordaClassResolverTests.kt$net.corda.serialization.internal.CordaClassResolverTests.kt - NewLineAtEndOfFile:CordaClosureSerializer.kt$net.corda.node.serialization.kryo.CordaClosureSerializer.kt - NewLineAtEndOfFile:CordaException.kt$net.corda.core.CordaException.kt - NewLineAtEndOfFile:CordaExceptionTest.kt$net.corda.deterministic.CordaExceptionTest.kt - NewLineAtEndOfFile:CordaInternal.kt$net.corda.core.CordaInternal.kt - NewLineAtEndOfFile:CordaPersistenceTest.kt$net.corda.nodeapi.internal.CordaPersistenceTest.kt - NewLineAtEndOfFile:CordaRPCClient.kt$net.corda.client.rpc.CordaRPCClient.kt - NewLineAtEndOfFile:CordaRPCOpsImpl.kt$net.corda.node.internal.CordaRPCOpsImpl.kt - NewLineAtEndOfFile:CordaSSHAuthInfo.kt$net.corda.tools.shell.CordaSSHAuthInfo.kt - NewLineAtEndOfFile:CordaServiceFlowTests.kt$net.corda.node.services.CordaServiceFlowTests.kt - NewLineAtEndOfFile:CordaServiceTest.kt$net.corda.node.internal.CordaServiceTest.kt - NewLineAtEndOfFile:CordaVersion.kt$net.corda.common.logging.CordaVersion.kt - NewLineAtEndOfFile:CordaVersionProvider.kt$net.corda.cliutils.CordaVersionProvider.kt - NewLineAtEndOfFile:CordaViewModel.kt$net.corda.explorer.model.CordaViewModel.kt - NewLineAtEndOfFile:CordaX500Name.kt$net.corda.core.identity.CordaX500Name.kt - NewLineAtEndOfFile:CordappConfig.kt$net.corda.core.cordapp.CordappConfig.kt - NewLineAtEndOfFile:CordappConfigFileProviderTests.kt$net.corda.node.internal.cordapp.CordappConfigFileProviderTests.kt - NewLineAtEndOfFile:CordappConfigProvider.kt$net.corda.node.internal.cordapp.CordappConfigProvider.kt - NewLineAtEndOfFile:CordappLoader.kt$net.corda.nodeapi.internal.cordapp.CordappLoader.kt - NewLineAtEndOfFile:CordappProvider.kt$net.corda.core.cordapp.CordappProvider.kt - NewLineAtEndOfFile:CordappResolver.kt$net.corda.core.internal.cordapp.CordappResolver.kt - NewLineAtEndOfFile:CostSummary.kt$net.corda.djvm.execution.CostSummary.kt - NewLineAtEndOfFile:CurrenciesTests.kt$net.corda.finance.CurrenciesTests.kt - NewLineAtEndOfFile:CurrencyConfiguration.kt$net.corda.behave.node.configuration.CurrencyConfiguration.kt - NewLineAtEndOfFile:CurrencyParameterSensitivitiesSerializer.kt$net.corda.vega.plugin.customserializers.CurrencyParameterSensitivitiesSerializer.kt - NewLineAtEndOfFile:CustomSerializerRegistry.kt$net.corda.serialization.internal.amqp.CustomSerializerRegistry.kt - NewLineAtEndOfFile:CustomSerializerRegistryTests.kt$net.corda.serialization.internal.amqp.CustomSerializerRegistryTests.kt - NewLineAtEndOfFile:CustomTypeJsonParsingTests.kt$net.corda.tools.shell.CustomTypeJsonParsingTests.kt - NewLineAtEndOfFile:DJVMException.kt$sandbox.java.lang.DJVMException.kt - NewLineAtEndOfFile:DJVMExceptionTest.kt$net.corda.djvm.DJVMExceptionTest.kt - NewLineAtEndOfFile:DJVMTest.kt$net.corda.djvm.DJVMTest.kt - NewLineAtEndOfFile:Dashboard.kt$net.corda.explorer.views.Dashboard.kt - NewLineAtEndOfFile:Database.kt$net.corda.behave.scenarios.helpers.Database.kt - NewLineAtEndOfFile:DatabaseConfigurationTemplate.kt$net.corda.behave.database.DatabaseConfigurationTemplate.kt - NewLineAtEndOfFile:DatabaseConnection.kt$net.corda.behave.database.DatabaseConnection.kt - NewLineAtEndOfFile:DatabaseType.kt$net.corda.behave.database.DatabaseType.kt - NewLineAtEndOfFile:DbExceptionHandler.kt$net.corda.node.internal.DbExceptionHandler.kt - NewLineAtEndOfFile:DeduplicationId.kt$net.corda.node.services.statemachine.DeduplicationId.kt - NewLineAtEndOfFile:DefaultCacheProvider.kt$net.corda.serialization.internal.model.DefaultCacheProvider.kt - NewLineAtEndOfFile:DefaultKryoCustomizer.kt$net.corda.node.serialization.kryo.DefaultKryoCustomizer.kt - NewLineAtEndOfFile:DefinitionProvider.kt$net.corda.djvm.code.DefinitionProvider.kt - NewLineAtEndOfFile:DemoBenchNodeInfoFilesCopier.kt$net.corda.demobench.model.DemoBenchNodeInfoFilesCopier.kt - NewLineAtEndOfFile:DescriptorBasedSerializerRegistry.kt$net.corda.serialization.internal.amqp.DescriptorBasedSerializerRegistry.kt - NewLineAtEndOfFile:DeserializeNeedingCarpentrySimpleTypesTest.kt$net.corda.serialization.internal.amqp.DeserializeNeedingCarpentrySimpleTypesTest.kt - NewLineAtEndOfFile:DeserializeQueryableStateTest.kt$net.corda.serialization.internal.amqp.DeserializeQueryableStateTest.kt - NewLineAtEndOfFile:DigitalSignatureWithCert.kt$net.corda.core.internal.DigitalSignatureWithCert.kt - NewLineAtEndOfFile:DisallowNonDeterministicMethods.kt$net.corda.djvm.rules.implementation.DisallowNonDeterministicMethods.kt - NewLineAtEndOfFile:DistributedServiceTests.kt$net.corda.node.services.distributed.DistributedServiceTests.kt - NewLineAtEndOfFile:DoNotImplement.kt$net.corda.core.DoNotImplement.kt - NewLineAtEndOfFile:DockerBackend.kt$net.corda.networkbuilder.backends.DockerBackend.kt - NewLineAtEndOfFile:DockerInstantiator.kt$net.corda.networkbuilder.containers.instance.docker.DockerInstantiator.kt - NewLineAtEndOfFile:DockerUtils.kt$net.corda.networkbuilder.docker.DockerUtils.kt - NewLineAtEndOfFile:DriverTests.kt$net.corda.testing.driver.DriverTests.kt - NewLineAtEndOfFile:DummyClusterSpec.kt$net.corda.testing.node.internal.DummyClusterSpec.kt - NewLineAtEndOfFile:DummyLinearContract.kt$net.corda.testing.internal.vault.DummyLinearContract.kt - NewLineAtEndOfFile:DurationSerializer.kt$net.corda.serialization.internal.amqp.custom.DurationSerializer.kt - NewLineAtEndOfFile:Emitter.kt$net.corda.djvm.code.Emitter.kt - NewLineAtEndOfFile:EmitterContext.kt$net.corda.djvm.code.EmitterContext.kt - NewLineAtEndOfFile:EmitterModule.kt$net.corda.djvm.code.EmitterModule.kt - NewLineAtEndOfFile:EnumClassTests.kt$net.corda.serialization.internal.carpenter.EnumClassTests.kt - NewLineAtEndOfFile:EnumSerializer.kt$net.corda.serialization.internal.amqp.EnumSerializer.kt - NewLineAtEndOfFile:EnumSetSerializer.kt$net.corda.serialization.internal.amqp.custom.EnumSetSerializer.kt - NewLineAtEndOfFile:EnumTests.kt$net.corda.serialization.internal.amqp.EnumTests.kt - NewLineAtEndOfFile:EnumTransformationTests.kt$net.corda.serialization.internal.amqp.EnumTransformationTests.kt - NewLineAtEndOfFile:EnumTransforms.kt$net.corda.serialization.internal.model.EnumTransforms.kt - NewLineAtEndOfFile:ErrorCodeLoggingTests.kt$net.corda.node.logging.ErrorCodeLoggingTests.kt - NewLineAtEndOfFile:ErrorCodeRewritePolicy.kt$net.corda.common.logging.ErrorCodeRewritePolicy.kt - NewLineAtEndOfFile:ErrorMessagesTests.kt$net.corda.serialization.internal.amqp.ErrorMessagesTests.kt - NewLineAtEndOfFile:EventProcessor.kt$net.corda.nodeapi.internal.protonwrapper.engine.EventProcessor.kt - NewLineAtEndOfFile:Eventually.kt$net.corda.testing.common.internal.Eventually.kt - NewLineAtEndOfFile:EvolutionSerializerFactory.kt$net.corda.serialization.internal.amqp.EvolutionSerializerFactory.kt - NewLineAtEndOfFile:EvolutionSerializerFactoryTests.kt$net.corda.serialization.internal.amqp.EvolutionSerializerFactoryTests.kt - NewLineAtEndOfFile:ExampleConfigTest.kt$net.corda.docs.ExampleConfigTest.kt - NewLineAtEndOfFile:Examples.kt$net.corda.finance.contracts.universal.Examples.kt - NewLineAtEndOfFile:ExceptionResolver.kt$net.corda.djvm.analysis.ExceptionResolver.kt - NewLineAtEndOfFile:ExceptionSerialisingRpcOpsProxy.kt$net.corda.node.internal.rpc.proxies.ExceptionSerialisingRpcOpsProxy.kt - NewLineAtEndOfFile:ExceptionsErrorCodeFunctions.kt$net.corda.common.logging.ExceptionsErrorCodeFunctions.kt - NewLineAtEndOfFile:ExceptionsSerializationTest.kt$net.corda.node.services.statemachine.ExceptionsSerializationTest.kt - NewLineAtEndOfFile:ExchangeRateModelTest.kt$net.corda.client.jfx.model.ExchangeRateModelTest.kt - NewLineAtEndOfFile:ExitCodes.kt$net.corda.cliutils.ExitCodes.kt - NewLineAtEndOfFile:Explorer.kt$net.corda.demobench.explorer.Explorer.kt - NewLineAtEndOfFile:ExposeJpaToFlowsTests.kt$net.corda.node.services.persistence.ExposeJpaToFlowsTests.kt - NewLineAtEndOfFile:ExternalIdMappingTest.kt$net.corda.node.services.vault.ExternalIdMappingTest.kt - NewLineAtEndOfFile:FXFwdTimeOption.kt$net.corda.finance.contracts.universal.FXFwdTimeOption.kt - NewLineAtEndOfFile:FetchDataFlow.kt$net.corda.core.internal.FetchDataFlow.kt - NewLineAtEndOfFile:FingerPrinterTesting.kt$net.corda.serialization.internal.amqp.FingerPrinterTesting.kt - NewLineAtEndOfFile:FlowHandle.kt$net.corda.core.messaging.FlowHandle.kt - NewLineAtEndOfFile:FlowInitiator.kt$net.corda.core.flows.FlowInitiator.kt - NewLineAtEndOfFile:FlowLogicRef.kt$net.corda.core.flows.FlowLogicRef.kt - NewLineAtEndOfFile:FlowMatchers.kt$net.corda.testing.internal.matchers.flow.FlowMatchers.kt - NewLineAtEndOfFile:FlowMonitor.kt$net.corda.node.services.statemachine.FlowMonitor.kt - NewLineAtEndOfFile:FlowOverrideTests.kt$net.corda.node.flows.FlowOverrideTests.kt - NewLineAtEndOfFile:FlowRegistrationTest.kt$net.corda.node.internal.FlowRegistrationTest.kt - NewLineAtEndOfFile:FlowStackSnapshot.kt$net.corda.core.flows.FlowStackSnapshot.kt - NewLineAtEndOfFile:FlowTestsUtils.kt$net.corda.core.flows.FlowTestsUtils.kt - NewLineAtEndOfFile:FlowTimeoutException.kt$net.corda.node.services.statemachine.FlowTimeoutException.kt - NewLineAtEndOfFile:FlowVersioningTest.kt$net.corda.node.services.statemachine.FlowVersioningTest.kt - NewLineAtEndOfFile:FoundNode.kt$net.corda.networkbuilder.nodes.FoundNode.kt - NewLineAtEndOfFile:FutureMatchers.kt$net.corda.testing.internal.matchers.future.FutureMatchers.kt - NewLineAtEndOfFile:GenerateHelpers.kt$net.corda.loadtest.tests.GenerateHelpers.kt - NewLineAtEndOfFile:GenerateNodeInfoCli.kt$net.corda.node.internal.subcommands.GenerateNodeInfoCli.kt - NewLineAtEndOfFile:Generator.kt$net.corda.client.mock.Generator.kt - NewLineAtEndOfFile:GetStringConfigFlow.kt$net.corda.configsample.GetStringConfigFlow.kt - NewLineAtEndOfFile:GlobalTestPortAllocation.kt$net.corda.testing.driver.internal.GlobalTestPortAllocation.kt - NewLineAtEndOfFile:GuiUtilitiesKtTest.kt$net.corda.explorer.views.GuiUtilitiesKtTest.kt - NewLineAtEndOfFile:H2ConfigurationTemplate.kt$net.corda.behave.database.configuration.H2ConfigurationTemplate.kt - NewLineAtEndOfFile:H2SecurityTests.kt$net.corda.node.persistence.H2SecurityTests.kt - NewLineAtEndOfFile:H2Service.kt$net.corda.behave.service.database.H2Service.kt - NewLineAtEndOfFile:HandleExceptionUnwrapper.kt$net.corda.djvm.rules.implementation.HandleExceptionUnwrapper.kt - NewLineAtEndOfFile:HibernateColumnConverterTests.kt$net.corda.node.services.persistence.HibernateColumnConverterTests.kt - NewLineAtEndOfFile:HibernateQueryCriteriaParser.kt$net.corda.node.services.vault.HibernateQueryCriteriaParser.kt - NewLineAtEndOfFile:HibernateStatistics.kt$net.corda.nodeapi.internal.persistence.HibernateStatistics.kt - NewLineAtEndOfFile:IOUContract.kt$net.corda.docs.kotlin.tutorial.twoparty.IOUContract.kt - NewLineAtEndOfFile:IOUState.kt$net.corda.docs.kotlin.tutorial.twoparty.IOUState.kt - NewLineAtEndOfFile:Id.kt$net.corda.core.utilities.Id.kt - NewLineAtEndOfFile:IdempotentFlow.kt$net.corda.core.internal.IdempotentFlow.kt - NewLineAtEndOfFile:IdempotentFlowTests.kt$net.corda.node.services.statemachine.IdempotentFlowTests.kt - NewLineAtEndOfFile:IdenticonRenderer.kt$net.corda.explorer.identicon.IdenticonRenderer.kt - NewLineAtEndOfFile:IdentitySyncFlowTests.kt$net.corda.confidential.IdentitySyncFlowTests.kt - NewLineAtEndOfFile:InfrequentlyMutatedCache.kt$net.corda.node.utilities.InfrequentlyMutatedCache.kt - NewLineAtEndOfFile:InfrequentlyMutatedCacheTest.kt$net.corda.node.utilities.InfrequentlyMutatedCacheTest.kt - NewLineAtEndOfFile:InitiatedBy.kt$net.corda.core.flows.InitiatedBy.kt - NewLineAtEndOfFile:InputStreamSerializer.kt$net.corda.serialization.internal.amqp.custom.InputStreamSerializer.kt - NewLineAtEndOfFile:InstallShellExtensionsParser.kt$net.corda.cliutils.InstallShellExtensionsParser.kt - NewLineAtEndOfFile:InstanceInfo.kt$net.corda.networkbuilder.containers.instance.InstanceInfo.kt - NewLineAtEndOfFile:Instances.kt$net.corda.core.crypto.internal.Instances.kt - NewLineAtEndOfFile:InstantSerializer.kt$net.corda.serialization.internal.amqp.custom.InstantSerializer.kt - NewLineAtEndOfFile:Instantiator.kt$net.corda.networkbuilder.containers.instance.Instantiator.kt - NewLineAtEndOfFile:IntegerInstruction.kt$net.corda.djvm.code.instructions.IntegerInstruction.kt - NewLineAtEndOfFile:InteractiveShellIntegrationTest.kt$net.corda.tools.shell.InteractiveShellIntegrationTest.kt - NewLineAtEndOfFile:InterestRatesSwapDemoAPI.kt$net.corda.irs.web.api.InterestRatesSwapDemoAPI.kt - NewLineAtEndOfFile:InternalMockNetworkConfigOverrides.kt$net.corda.testing.node.internal.InternalMockNetworkConfigOverrides.kt - NewLineAtEndOfFile:InternalTestConstants.kt$net.corda.testing.internal.InternalTestConstants.kt - NewLineAtEndOfFile:InvocationContext.kt$net.corda.core.context.InvocationContext.kt - NewLineAtEndOfFile:InvocationHandlerTemplate.kt$net.corda.node.internal.InvocationHandlerTemplate.kt - NewLineAtEndOfFile:IsolatedTask.kt$net.corda.djvm.execution.IsolatedTask.kt - NewLineAtEndOfFile:IssueCash.kt$net.corda.bank.IssueCash.kt - NewLineAtEndOfFile:IssueCashLoggingTests.kt$net.corda.node.logging.IssueCashLoggingTests.kt - NewLineAtEndOfFile:JVMAgentRegistry.kt$net.corda.node.utilities.JVMAgentRegistry.kt - NewLineAtEndOfFile:JarCommand.kt$net.corda.behave.process.JarCommand.kt - NewLineAtEndOfFile:JarSignatureCollector.kt$net.corda.core.internal.JarSignatureCollector.kt - NewLineAtEndOfFile:KMSUtilsTests.kt$net.corda.node.services.keys.KMSUtilsTests.kt - NewLineAtEndOfFile:KeepForDJVM.kt$net.corda.core.KeepForDJVM.kt - NewLineAtEndOfFile:KeyManagementService.kt$net.corda.core.node.services.KeyManagementService.kt - NewLineAtEndOfFile:KeyStoreConfigHelpers.kt$net.corda.nodeapi.internal.KeyStoreConfigHelpers.kt - NewLineAtEndOfFile:KeyStoreGenerator.kt$net.corda.deterministic.data.KeyStoreGenerator.kt - NewLineAtEndOfFile:KotlinUtilsTest.kt$net.corda.core.utilities.KotlinUtilsTest.kt - NewLineAtEndOfFile:LargeTransactionsTest.kt$net.corda.node.services.statemachine.LargeTransactionsTest.kt - NewLineAtEndOfFile:LazyPool.kt$net.corda.core.internal.LazyPool.kt - NewLineAtEndOfFile:LazyStickyPool.kt$net.corda.core.internal.LazyStickyPool.kt - NewLineAtEndOfFile:LedgerTransactionQueryTests.kt$net.corda.core.transactions.LedgerTransactionQueryTests.kt - NewLineAtEndOfFile:LegalNameValidator.kt$net.corda.core.internal.LegalNameValidator.kt - NewLineAtEndOfFile:LegalNameValidatorTest.kt$net.corda.core.internal.LegalNameValidatorTest.kt - NewLineAtEndOfFile:LifeCycle.kt$net.corda.core.internal.LifeCycle.kt - NewLineAtEndOfFile:LifecycleSupport.kt$net.corda.node.internal.LifecycleSupport.kt - NewLineAtEndOfFile:LocalDateSerializer.kt$net.corda.serialization.internal.amqp.custom.LocalDateSerializer.kt - NewLineAtEndOfFile:LocalDateTimeSerializer.kt$net.corda.serialization.internal.amqp.custom.LocalDateTimeSerializer.kt - NewLineAtEndOfFile:LocalPropertyInformation.kt$net.corda.serialization.internal.model.LocalPropertyInformation.kt - NewLineAtEndOfFile:LocalSerializerFactory.kt$net.corda.serialization.internal.amqp.LocalSerializerFactory.kt - NewLineAtEndOfFile:LocalTimeSerializer.kt$net.corda.serialization.internal.amqp.custom.LocalTimeSerializer.kt - NewLineAtEndOfFile:LocalTypeInformationBuilder.kt$net.corda.serialization.internal.model.LocalTypeInformationBuilder.kt - NewLineAtEndOfFile:LocalTypeModelTests.kt$net.corda.serialization.internal.model.LocalTypeModelTests.kt - NewLineAtEndOfFile:LocalVolume.kt$net.corda.networkbuilder.volumes.docker.LocalVolume.kt - NewLineAtEndOfFile:LogSource.kt$net.corda.behave.file.LogSource.kt - NewLineAtEndOfFile:MQSecurityTest.kt$net.corda.services.messaging.MQSecurityTest.kt - NewLineAtEndOfFile:MainView.kt$net.corda.explorer.views.MainView.kt - NewLineAtEndOfFile:MappedSchemasCrossReferenceDetectionTests.kt$net.corda.core.schemas.MappedSchemasCrossReferenceDetectionTests.kt - NewLineAtEndOfFile:MatcherTests.kt$net.corda.testing.internal.MatcherTests.kt - NewLineAtEndOfFile:Matchers.kt$net.corda.testing.internal.matchers.Matchers.kt - NewLineAtEndOfFile:MemberFormatterTest.kt$net.corda.djvm.formatter.MemberFormatterTest.kt - NewLineAtEndOfFile:MerkleTransaction.kt$net.corda.core.transactions.MerkleTransaction.kt - NewLineAtEndOfFile:MerkleTree.kt$net.corda.core.crypto.MerkleTree.kt - NewLineAtEndOfFile:MerkleTreeTest.kt$net.corda.deterministic.crypto.MerkleTreeTest.kt - NewLineAtEndOfFile:Message.kt$net.corda.djvm.messages.Message.kt - NewLineAtEndOfFile:MessageState.kt$net.corda.testMessage.MessageState.kt - NewLineAtEndOfFile:MessageStatus.kt$net.corda.nodeapi.internal.protonwrapper.messages.MessageStatus.kt - NewLineAtEndOfFile:MethodEntry.kt$net.corda.djvm.code.instructions.MethodEntry.kt - NewLineAtEndOfFile:MetricInterceptor.kt$net.corda.node.services.statemachine.interceptors.MetricInterceptor.kt - NewLineAtEndOfFile:MigrationNamedCacheFactory.kt$net.corda.node.migration.MigrationNamedCacheFactory.kt - NewLineAtEndOfFile:MigrationServicesForResolution.kt$net.corda.node.migration.MigrationServicesForResolution.kt - NewLineAtEndOfFile:MissingAttachmentsException.kt$net.corda.core.serialization.MissingAttachmentsException.kt - NewLineAtEndOfFile:MockAttachmentStorage.kt$net.corda.testing.services.MockAttachmentStorage.kt - NewLineAtEndOfFile:MockContractAttachment.kt$net.corda.deterministic.verifier.MockContractAttachment.kt - NewLineAtEndOfFile:MockCordappConfigProvider.kt$net.corda.testing.internal.MockCordappConfigProvider.kt - NewLineAtEndOfFile:MockKeyManagementService.kt$net.corda.testing.node.internal.MockKeyManagementService.kt - NewLineAtEndOfFile:MockNetworkTest.kt$net.corda.testing.node.MockNetworkTest.kt - NewLineAtEndOfFile:MockServices.kt$net.corda.testing.node.MockServices.kt - NewLineAtEndOfFile:MockTransactionStorage.kt$net.corda.testing.node.internal.MockTransactionStorage.kt - NewLineAtEndOfFile:ModelsUtils.kt$net.corda.client.jfx.model.ModelsUtils.kt - NewLineAtEndOfFile:MonitoringSSHClient.kt$net.corda.behave.ssh.MonitoringSSHClient.kt - NewLineAtEndOfFile:MonitoringTests.kt$net.corda.behave.monitoring.MonitoringTests.kt - NewLineAtEndOfFile:MonthDaySerializer.kt$net.corda.serialization.internal.amqp.custom.MonthDaySerializer.kt - NewLineAtEndOfFile:NamedCacheTest.kt$net.corda.core.internal.NamedCacheTest.kt - NewLineAtEndOfFile:NettyWritable.kt$net.corda.nodeapi.internal.protonwrapper.engine.NettyWritable.kt - NewLineAtEndOfFile:Network.kt$net.corda.behave.network.Network.kt - NewLineAtEndOfFile:NetworkBootstrapper.kt$net.corda.nodeapi.internal.network.NetworkBootstrapper.kt - NewLineAtEndOfFile:NetworkBootstrapperBackwardsCompatibilityTest.kt$net.corda.bootstrapper.NetworkBootstrapperBackwardsCompatibilityTest.kt - NewLineAtEndOfFile:NetworkBootstrapperRunnerTests.kt$net.corda.bootstrapper.NetworkBootstrapperRunnerTests.kt - NewLineAtEndOfFile:NetworkMap.kt$net.corda.nodeapi.internal.network.NetworkMap.kt - NewLineAtEndOfFile:NetworkMapServer.kt$net.corda.testing.node.internal.network.NetworkMapServer.kt - NewLineAtEndOfFile:NetworkMapUpdater.kt$net.corda.node.services.network.NetworkMapUpdater.kt - NewLineAtEndOfFile:NetworkParameterOverridesSpec.kt$net.corda.bootstrapper.NetworkParameterOverridesSpec.kt - NewLineAtEndOfFile:NetworkParametersReaderTest.kt$net.corda.node.services.network.NetworkParametersReaderTest.kt - NewLineAtEndOfFile:NetworkParametersResolutionTest.kt$net.corda.core.internal.NetworkParametersResolutionTest.kt - NewLineAtEndOfFile:NetworkTests.kt$net.corda.behave.network.NetworkTests.kt - NewLineAtEndOfFile:NoOperationInstruction.kt$net.corda.djvm.code.instructions.NoOperationInstruction.kt - NewLineAtEndOfFile:Node.kt$net.corda.behave.node.Node.kt - NewLineAtEndOfFile:NodeAdder.kt$net.corda.networkbuilder.nodes.NodeAdder.kt - NewLineAtEndOfFile:NodeAttachmentService.kt$net.corda.node.services.persistence.NodeAttachmentService.kt - NewLineAtEndOfFile:NodeBuildProperties.kt$net.corda.node.utilities.NodeBuildProperties.kt - NewLineAtEndOfFile:NodeConfigurationImpl.kt$net.corda.node.services.config.NodeConfigurationImpl.kt - NewLineAtEndOfFile:NodeConnection.kt$net.corda.loadtest.NodeConnection.kt - NewLineAtEndOfFile:NodeCopier.kt$net.corda.networkbuilder.nodes.NodeCopier.kt - NewLineAtEndOfFile:NodeFinder.kt$net.corda.networkbuilder.nodes.NodeFinder.kt - NewLineAtEndOfFile:NodeFlowManagerTest.kt$net.corda.node.internal.NodeFlowManagerTest.kt - NewLineAtEndOfFile:NodeHandleTests.kt$net.corda.node.services.rpc.NodeHandleTests.kt - NewLineAtEndOfFile:NodeInfoFilesCopierTest.kt$net.corda.nodeapi.internal.network.NodeInfoFilesCopierTest.kt - NewLineAtEndOfFile:NodeInstance.kt$net.corda.networkbuilder.nodes.NodeInstance.kt - NewLineAtEndOfFile:NodeInstanceRequest.kt$net.corda.networkbuilder.nodes.NodeInstanceRequest.kt - NewLineAtEndOfFile:NodeInstantiator.kt$net.corda.networkbuilder.nodes.NodeInstantiator.kt - NewLineAtEndOfFile:NodeMonitorModel.kt$net.corda.client.jfx.model.NodeMonitorModel.kt - NewLineAtEndOfFile:NodeNamedCache.kt$net.corda.node.utilities.NodeNamedCache.kt - NewLineAtEndOfFile:NodePerformanceTests.kt$net.corda.node.NodePerformanceTests.kt - NewLineAtEndOfFile:NodePropertiesStore.kt$net.corda.node.services.api.NodePropertiesStore.kt - NewLineAtEndOfFile:NodePusher.kt$net.corda.networkbuilder.nodes.NodePusher.kt - NewLineAtEndOfFile:NodeRpcOptions.kt$net.corda.node.services.config.rpc.NodeRpcOptions.kt - NewLineAtEndOfFile:NodeRpcSettings.kt$net.corda.demobench.model.NodeRpcSettings.kt - NewLineAtEndOfFile:NodeSchemaServiceTest.kt$net.corda.node.services.schema.NodeSchemaServiceTest.kt - NewLineAtEndOfFile:NodeStartupCliTest.kt$net.corda.node.internal.NodeStartupCliTest.kt - NewLineAtEndOfFile:NodeStartupCompatibilityTest.kt$net.corda.node.internal.NodeStartupCompatibilityTest.kt - NewLineAtEndOfFile:NodeStartupTest.kt$net.corda.node.internal.NodeStartupTest.kt - NewLineAtEndOfFile:NodeStatePersistenceTests.kt$net.corda.node.persistence.NodeStatePersistenceTests.kt - NewLineAtEndOfFile:NodeUniqueIdProvider.kt$net.corda.node.internal.NodeUniqueIdProvider.kt - NewLineAtEndOfFile:NodeVaultService.kt$net.corda.node.services.vault.NodeVaultService.kt - NewLineAtEndOfFile:NonDeterministic.kt$net.corda.djvm.annotations.NonDeterministic.kt - NewLineAtEndOfFile:NonInvalidatingCache.kt$net.corda.node.utilities.NonInvalidatingCache.kt - NewLineAtEndOfFile:NonInvalidatingUnboundCache.kt$net.corda.node.utilities.NonInvalidatingUnboundCache.kt - NewLineAtEndOfFile:NotSerializableExceptions.kt$net.corda.serialization.internal.NotSerializableExceptions.kt - NewLineAtEndOfFile:NotaryChangeTests.kt$net.corda.node.services.NotaryChangeTests.kt - NewLineAtEndOfFile:NotaryCopier.kt$net.corda.networkbuilder.notaries.NotaryCopier.kt - NewLineAtEndOfFile:NotaryExceptionSerializationTest.kt$net.corda.core.serialization.NotaryExceptionSerializationTest.kt - NewLineAtEndOfFile:NotaryLoader.kt$net.corda.node.utilities.NotaryLoader.kt - NewLineAtEndOfFile:NotaryService.kt$net.corda.core.internal.notary.NotaryService.kt - NewLineAtEndOfFile:NotarySpec.kt$net.corda.testing.node.NotarySpec.kt - NewLineAtEndOfFile:NotaryTestContracts.kt$net.corda.verification.NotaryTestContracts.kt - NewLineAtEndOfFile:NotaryWhitelistTests.kt$net.corda.node.services.transactions.NotaryWhitelistTests.kt - NewLineAtEndOfFile:NullKeys.kt$net.corda.core.crypto.NullKeys.kt - NewLineAtEndOfFile:ObjectBuilder.kt$net.corda.serialization.internal.amqp.ObjectBuilder.kt - NewLineAtEndOfFile:ObjectDiffer.kt$net.corda.node.utilities.ObjectDiffer.kt - NewLineAtEndOfFile:ObjectSerializer.kt$net.corda.serialization.internal.amqp.ObjectSerializer.kt - NewLineAtEndOfFile:ObligationTests.kt$net.corda.finance.contracts.asset.ObligationTests.kt - NewLineAtEndOfFile:ObligationUtils.kt$net.corda.finance.workflows.asset.ObligationUtils.kt - NewLineAtEndOfFile:ObservableContextInterface.kt$net.corda.node.services.rpc.ObservableContextInterface.kt - NewLineAtEndOfFile:ObservablesTests.kt$net.corda.node.utilities.ObservablesTests.kt - NewLineAtEndOfFile:OffsetDateTimeSerializer.kt$net.corda.serialization.internal.amqp.custom.OffsetDateTimeSerializer.kt - NewLineAtEndOfFile:OffsetTimeSerializer.kt$net.corda.serialization.internal.amqp.custom.OffsetTimeSerializer.kt - NewLineAtEndOfFile:OpaqueBytesSubSequenceSerializer.kt$net.corda.serialization.internal.amqp.custom.OpaqueBytesSubSequenceSerializer.kt - NewLineAtEndOfFile:OptionalSerializationTests.kt$net.corda.serialization.internal.amqp.OptionalSerializationTests.kt - NewLineAtEndOfFile:OptionalSerializer.kt$net.corda.serialization.internal.amqp.custom.OptionalSerializer.kt - NewLineAtEndOfFile:OracleNodeTearOffTests.kt$net.corda.irs.api.OracleNodeTearOffTests.kt - NewLineAtEndOfFile:OutputListener.kt$net.corda.behave.process.output.OutputListener.kt - NewLineAtEndOfFile:OverridePKSerializerTest.kt$net.corda.serialization.internal.amqp.OverridePKSerializerTest.kt - NewLineAtEndOfFile:P2PFlowsDrainingModeTest.kt$net.corda.node.modes.draining.P2PFlowsDrainingModeTest.kt - NewLineAtEndOfFile:P2PMQSecurityTest.kt$net.corda.services.messaging.P2PMQSecurityTest.kt - NewLineAtEndOfFile:PackageOwnershipVerificationTests.kt$net.corda.core.contracts.PackageOwnershipVerificationTests.kt - NewLineAtEndOfFile:PackageUtils.kt$net.corda.node.logging.PackageUtils.kt - NewLineAtEndOfFile:PartyTest.kt$net.corda.core.identity.PartyTest.kt - NewLineAtEndOfFile:Password.kt$net.corda.node.internal.security.Password.kt - NewLineAtEndOfFile:PasswordTest.kt$net.corda.node.internal.security.PasswordTest.kt - NewLineAtEndOfFile:PathUtilsTest.kt$net.corda.core.internal.PathUtilsTest.kt - NewLineAtEndOfFile:PatternWatch.kt$net.corda.behave.monitoring.PatternWatch.kt - NewLineAtEndOfFile:PeriodSerializer.kt$net.corda.serialization.internal.amqp.custom.PeriodSerializer.kt - NewLineAtEndOfFile:PermissionException.kt$net.corda.client.rpc.PermissionException.kt - NewLineAtEndOfFile:Permissions.kt$net.corda.node.services.Permissions.kt - NewLineAtEndOfFile:PersistentMapTests.kt$net.corda.node.utilities.PersistentMapTests.kt - NewLineAtEndOfFile:PersistentScheduledFlowRepository.kt$net.corda.node.services.events.PersistentScheduledFlowRepository.kt - NewLineAtEndOfFile:PersistentScheduledFlowRepositoryTest.kt$net.corda.node.services.events.PersistentScheduledFlowRepositoryTest.kt - NewLineAtEndOfFile:PersistentStateServiceTests.kt$net.corda.node.services.schema.PersistentStateServiceTests.kt - NewLineAtEndOfFile:PostgreSQLService.kt$net.corda.behave.service.database.PostgreSQLService.kt - NewLineAtEndOfFile:PostgresConfigurationTemplate.kt$net.corda.behave.database.configuration.PostgresConfigurationTemplate.kt - NewLineAtEndOfFile:PostreSQLServiceTests.kt$net.corda.behave.service.PostreSQLServiceTests.kt - NewLineAtEndOfFile:PrivacySaltTest.kt$net.corda.core.contracts.PrivacySaltTest.kt - NewLineAtEndOfFile:PrivacySaltTest.kt$net.corda.deterministic.contracts.PrivacySaltTest.kt - NewLineAtEndOfFile:PrivateKeySerializationTest.kt$net.corda.serialization.internal.PrivateKeySerializationTest.kt - NewLineAtEndOfFile:PrivateKeySerializer.kt$net.corda.serialization.internal.amqp.custom.PrivateKeySerializer.kt - NewLineAtEndOfFile:PrivatePropertyTests.kt$net.corda.serialization.internal.amqp.PrivatePropertyTests.kt - NewLineAtEndOfFile:ProcessUtilities.kt$net.corda.testing.node.internal.ProcessUtilities.kt - NewLineAtEndOfFile:ProcessUtilitiesTests.kt$net.corda.testing.node.internal.ProcessUtilitiesTests.kt - NewLineAtEndOfFile:ProgressTracker.kt$net.corda.core.internal.ProgressTracker.kt - NewLineAtEndOfFile:Properties.kt$net.corda.common.configuration.parsing.internal.Properties.kt - NewLineAtEndOfFile:PropertyTest.kt$net.corda.common.configuration.parsing.internal.PropertyTest.kt - NewLineAtEndOfFile:PropertyValidationTest.kt$net.corda.common.configuration.parsing.internal.PropertyValidationTest.kt - NewLineAtEndOfFile:PublicKeySerializer.kt$net.corda.serialization.internal.amqp.custom.PublicKeySerializer.kt - NewLineAtEndOfFile:PublicKeyToTextConverter.kt$net.corda.node.services.persistence.PublicKeyToTextConverter.kt - NewLineAtEndOfFile:PushedNode.kt$net.corda.networkbuilder.nodes.PushedNode.kt - NewLineAtEndOfFile:QueryCriteriaUtils.kt$net.corda.core.node.services.vault.QueryCriteriaUtils.kt - NewLineAtEndOfFile:QueueProcessor.kt$net.corda.djvm.execution.QueueProcessor.kt - NewLineAtEndOfFile:RPCApi.kt$net.corda.nodeapi.RPCApi.kt - NewLineAtEndOfFile:RPCConcurrencyTests.kt$net.corda.client.rpc.RPCConcurrencyTests.kt - NewLineAtEndOfFile:RPCConnection.kt$net.corda.client.rpc.RPCConnection.kt - NewLineAtEndOfFile:RPCException.kt$net.corda.client.rpc.RPCException.kt - NewLineAtEndOfFile:RPCMQSecurityTest.kt$net.corda.services.messaging.RPCMQSecurityTest.kt - NewLineAtEndOfFile:RPCOps.kt$net.corda.core.messaging.RPCOps.kt - NewLineAtEndOfFile:RPCReturnsObservables.kt$net.corda.core.messaging.RPCReturnsObservables.kt - NewLineAtEndOfFile:RPCSecurityManagerImpl.kt$net.corda.node.internal.security.RPCSecurityManagerImpl.kt - NewLineAtEndOfFile:RPCSecurityManagerTest.kt$net.corda.node.services.RPCSecurityManagerTest.kt - NewLineAtEndOfFile:RPCStabilityTests.kt$net.corda.client.rpc.RPCStabilityTests.kt - NewLineAtEndOfFile:RaftConfig.kt$net.corda.notary.experimental.raft.RaftConfig.kt - NewLineAtEndOfFile:RaftTransactionCommitLog.kt$net.corda.notary.experimental.raft.RaftTransactionCommitLog.kt - NewLineAtEndOfFile:RaftTransactionCommitLogTests.kt$net.corda.notary.experimental.raft.RaftTransactionCommitLogTests.kt - NewLineAtEndOfFile:RandomFailingProxy.kt$net.corda.node.services.rpc.RandomFailingProxy.kt - NewLineAtEndOfFile:ReactiveArtemisConsumer.kt$net.corda.node.internal.artemis.ReactiveArtemisConsumer.kt - NewLineAtEndOfFile:ReceiveAllFlowTests.kt$net.corda.core.flows.ReceiveAllFlowTests.kt - NewLineAtEndOfFile:ReceivedMessage.kt$net.corda.nodeapi.internal.protonwrapper.messages.ReceivedMessage.kt - NewLineAtEndOfFile:ReceivedMessageImpl.kt$net.corda.nodeapi.internal.protonwrapper.messages.impl.ReceivedMessageImpl.kt - NewLineAtEndOfFile:ReferenceInputStateTests.kt$net.corda.core.transactions.ReferenceInputStateTests.kt - NewLineAtEndOfFile:ReferenceValidationSummary.kt$net.corda.djvm.validation.ReferenceValidationSummary.kt - NewLineAtEndOfFile:ReferenceWithLocation.kt$net.corda.djvm.references.ReferenceWithLocation.kt - NewLineAtEndOfFile:RemoteSerializerFactory.kt$net.corda.serialization.internal.amqp.RemoteSerializerFactory.kt - NewLineAtEndOfFile:RemoteTypeCarpenter.kt$net.corda.serialization.internal.model.RemoteTypeCarpenter.kt - NewLineAtEndOfFile:RepeatingBytesInputStream.kt$net.corda.client.rpc.RepeatingBytesInputStream.kt - NewLineAtEndOfFile:ResolveStatePointersTest.kt$net.corda.node.services.transactions.ResolveStatePointersTest.kt - NewLineAtEndOfFile:RestrictedEntityManager.kt$net.corda.nodeapi.internal.persistence.RestrictedEntityManager.kt - NewLineAtEndOfFile:ReturnTypeWrapper.kt$net.corda.djvm.rules.implementation.ReturnTypeWrapper.kt - NewLineAtEndOfFile:RolesAdderOnLogin.kt$net.corda.node.services.rpc.RolesAdderOnLogin.kt - NewLineAtEndOfFile:RpcBrokerConfiguration.kt$net.corda.node.services.rpc.RpcBrokerConfiguration.kt - NewLineAtEndOfFile:RpcClientCordaFutureSerializer.kt$net.corda.client.rpc.internal.serialization.amqp.RpcClientCordaFutureSerializer.kt - NewLineAtEndOfFile:RpcClientObservableDeSerializer.kt$net.corda.client.rpc.internal.serialization.amqp.RpcClientObservableDeSerializer.kt - NewLineAtEndOfFile:RpcExceptions.kt$net.corda.nodeapi.exceptions.RpcExceptions.kt - NewLineAtEndOfFile:RpcHelpers.kt$net.corda.nodeapi.internal.RpcHelpers.kt - NewLineAtEndOfFile:RpcInfo.kt$net.corda.RpcInfo.kt - NewLineAtEndOfFile:RpcMatchers.kt$net.corda.testing.internal.matchers.rpc.RpcMatchers.kt - NewLineAtEndOfFile:RpcServerObservableSerializer.kt$net.corda.node.serialization.amqp.RpcServerObservableSerializer.kt - NewLineAtEndOfFile:RpcServerObservableSerializerTests.kt$net.corda.node.internal.serialization.RpcServerObservableSerializerTests.kt - NewLineAtEndOfFile:RpcSslTest.kt$net.corda.node.services.rpc.RpcSslTest.kt - NewLineAtEndOfFile:RuleViolationError.kt$sandbox.net.corda.djvm.rules.RuleViolationError.kt - NewLineAtEndOfFile:RunCommand.kt$net.corda.djvm.tools.cli.RunCommand.kt - NewLineAtEndOfFile:RxNotificationSerializer.kt$net.corda.serialization.internal.amqp.custom.RxNotificationSerializer.kt - NewLineAtEndOfFile:SSHClient.kt$net.corda.behave.ssh.SSHClient.kt - NewLineAtEndOfFile:SSHDConfiguration.kt$net.corda.tools.shell.SSHDConfiguration.kt - NewLineAtEndOfFile:SSLHelperTest.kt$net.corda.nodeapi.internal.protonwrapper.netty.SSLHelperTest.kt - NewLineAtEndOfFile:SandboxClassRemapper.kt$net.corda.djvm.rewiring.SandboxClassRemapper.kt - NewLineAtEndOfFile:SandboxEnumTest.kt$net.corda.djvm.execution.SandboxEnumTest.kt - NewLineAtEndOfFile:SandboxThrowableTest.kt$net.corda.djvm.execution.SandboxThrowableTest.kt - NewLineAtEndOfFile:ScenarioRunner.kt$net.corda.behave.scenarios.ScenarioRunner.kt - NewLineAtEndOfFile:ScenarioState.kt$net.corda.behave.scenarios.ScenarioState.kt - NewLineAtEndOfFile:SchedulableFlow.kt$net.corda.core.flows.SchedulableFlow.kt - NewLineAtEndOfFile:SchedulerService.kt$net.corda.node.services.api.SchedulerService.kt - NewLineAtEndOfFile:Schema.kt$net.corda.common.configuration.parsing.internal.Schema.kt - NewLineAtEndOfFile:Schema.kt$net.corda.notary.experimental.bftsmart.Schema.kt - NewLineAtEndOfFile:Schema.kt$net.corda.notary.experimental.raft.Schema.kt - NewLineAtEndOfFile:SchemaMigration.kt$net.corda.nodeapi.internal.persistence.SchemaMigration.kt - NewLineAtEndOfFile:SchemaTest.kt$net.corda.common.configuration.parsing.internal.SchemaTest.kt - NewLineAtEndOfFile:SearchField.kt$net.corda.explorer.views.SearchField.kt - NewLineAtEndOfFile:SecureArtemisConfiguration.kt$net.corda.node.internal.artemis.SecureArtemisConfiguration.kt - NewLineAtEndOfFile:SecureHashTest.kt$net.corda.deterministic.crypto.SecureHashTest.kt - NewLineAtEndOfFile:SecureRandomTest.kt$net.corda.deterministic.crypto.SecureRandomTest.kt - NewLineAtEndOfFile:SendableMessage.kt$net.corda.nodeapi.internal.protonwrapper.messages.SendableMessage.kt - NewLineAtEndOfFile:SendableMessageImpl.kt$net.corda.nodeapi.internal.protonwrapper.messages.impl.SendableMessageImpl.kt - NewLineAtEndOfFile:SerializationAnnotations.kt$net.corda.core.serialization.SerializationAnnotations.kt - NewLineAtEndOfFile:SerializationHelper.kt$net.corda.serialization.internal.amqp.SerializationHelper.kt - NewLineAtEndOfFile:SerializationPropertyOrdering.kt$net.corda.serialization.internal.amqp.SerializationPropertyOrdering.kt - NewLineAtEndOfFile:SerializationSchemaTests.kt$net.corda.serialization.internal.amqp.SerializationSchemaTests.kt - NewLineAtEndOfFile:SerializationSupport.kt$net.corda.tools.shell.SerializationSupport.kt - NewLineAtEndOfFile:SerializationWhitelist.kt$net.corda.core.serialization.SerializationWhitelist.kt - NewLineAtEndOfFile:SerializeAsTokenContextImpl.kt$net.corda.serialization.internal.SerializeAsTokenContextImpl.kt - NewLineAtEndOfFile:SerializeAsTokenSerializer.kt$net.corda.node.serialization.kryo.SerializeAsTokenSerializer.kt - NewLineAtEndOfFile:SerializerFactory.kt$net.corda.serialization.internal.amqp.SerializerFactory.kt - NewLineAtEndOfFile:SerializerFactoryBuilder.kt$net.corda.serialization.internal.amqp.SerializerFactoryBuilder.kt - NewLineAtEndOfFile:Service.kt$net.corda.behave.service.Service.kt - NewLineAtEndOfFile:Settings.kt$net.corda.explorer.views.Settings.kt - NewLineAtEndOfFile:SettingsModel.kt$net.corda.explorer.model.SettingsModel.kt - NewLineAtEndOfFile:SettingsModelTest.kt$net.corda.explorer.model.SettingsModelTest.kt - NewLineAtEndOfFile:ShutdownManager.kt$net.corda.testing.node.internal.ShutdownManager.kt - NewLineAtEndOfFile:SignatureConstraintVersioningTests.kt$net.corda.contracts.SignatureConstraintVersioningTests.kt - NewLineAtEndOfFile:SimpleStringSerializer.kt$net.corda.serialization.internal.amqp.custom.SimpleStringSerializer.kt - NewLineAtEndOfFile:SingletonSerializer.kt$net.corda.serialization.internal.amqp.SingletonSerializer.kt - NewLineAtEndOfFile:SourceClassLoaderTest.kt$net.corda.djvm.source.SourceClassLoaderTest.kt - NewLineAtEndOfFile:SourceLocation.kt$net.corda.djvm.analysis.SourceLocation.kt - NewLineAtEndOfFile:Specification.kt$net.corda.common.configuration.parsing.internal.Specification.kt - NewLineAtEndOfFile:SpecificationTest.kt$net.corda.common.configuration.parsing.internal.SpecificationTest.kt - NewLineAtEndOfFile:Ssh.kt$net.corda.behave.scenarios.helpers.Ssh.kt - NewLineAtEndOfFile:SslConfiguration.kt$net.corda.nodeapi.internal.config.SslConfiguration.kt - NewLineAtEndOfFile:StandaloneShellArgsParserTest.kt$net.corda.tools.shell.StandaloneShellArgsParserTest.kt - NewLineAtEndOfFile:StandardConfigValueParsers.kt$net.corda.node.services.config.schema.parsers.StandardConfigValueParsers.kt - NewLineAtEndOfFile:StartableByRPC.kt$net.corda.core.flows.StartableByRPC.kt - NewLineAtEndOfFile:StartableByService.kt$net.corda.core.flows.StartableByService.kt - NewLineAtEndOfFile:Startup.kt$net.corda.behave.scenarios.helpers.Startup.kt - NewLineAtEndOfFile:StartupSteps.kt$net.corda.behave.scenarios.steps.StartupSteps.kt - NewLineAtEndOfFile:StateMachineManagerUtils.kt$net.corda.node.utilities.StateMachineManagerUtils.kt - NewLineAtEndOfFile:StateMachineRunId.kt$net.corda.core.flows.StateMachineRunId.kt - NewLineAtEndOfFile:StateMachineRunIdTest.kt$net.corda.client.jackson.StateMachineRunIdTest.kt - NewLineAtEndOfFile:StateMachineState.kt$net.corda.node.services.statemachine.StateMachineState.kt - NewLineAtEndOfFile:StatePointer.kt$net.corda.core.contracts.StatePointer.kt - NewLineAtEndOfFile:StatePointerSearch.kt$net.corda.core.internal.StatePointerSearch.kt - NewLineAtEndOfFile:StatePointerSearchTests.kt$net.corda.core.internal.StatePointerSearchTests.kt - NewLineAtEndOfFile:StaticConstantRemover.kt$net.corda.djvm.rules.implementation.StaticConstantRemover.kt - NewLineAtEndOfFile:StaticInitialisationOfSerializedObjectTest.kt$net.corda.serialization.internal.amqp.StaticInitialisationOfSerializedObjectTest.kt - NewLineAtEndOfFile:StatusTransitions.kt$io.cryptoblk.core.StatusTransitions.kt - NewLineAtEndOfFile:StatusTransitionsTest.kt$io.cryptoblk.core.StatusTransitionsTest.kt - NewLineAtEndOfFile:StepsProvider.kt$net.corda.behave.scenarios.api.StepsProvider.kt - NewLineAtEndOfFile:StepsProviderTests.kt$net.corda.behave.scenarios.tests.StepsProviderTests.kt - NewLineAtEndOfFile:StreamTests.kt$net.corda.serialization.internal.amqp.StreamTests.kt - NewLineAtEndOfFile:StringBufferSerializer.kt$net.corda.serialization.internal.amqp.custom.StringBufferSerializer.kt - NewLineAtEndOfFile:StringConstantWrapper.kt$net.corda.djvm.rules.implementation.StringConstantWrapper.kt - NewLineAtEndOfFile:StructuresTests.kt$net.corda.core.contracts.StructuresTests.kt - NewLineAtEndOfFile:SwapIdentitiesFlow.kt$net.corda.confidential.SwapIdentitiesFlow.kt - NewLineAtEndOfFile:TLSAuthenticationTests.kt$net.corda.node.utilities.TLSAuthenticationTests.kt - NewLineAtEndOfFile:TableSwitchInstruction.kt$net.corda.djvm.code.instructions.TableSwitchInstruction.kt - NewLineAtEndOfFile:TargetVersionDependentRules.kt$net.corda.core.internal.rules.TargetVersionDependentRules.kt - NewLineAtEndOfFile:TestCommsFlowInitiatorTest.kt$net.corda.configsample.TestCommsFlowInitiatorTest.kt - NewLineAtEndOfFile:TestNoSecurityDataVendingFlow.kt$net.corda.core.flows.TestNoSecurityDataVendingFlow.kt - NewLineAtEndOfFile:TestObservableContext.kt$net.corda.node.internal.serialization.testutils.TestObservableContext.kt - NewLineAtEndOfFile:TestSerializationContext.kt$net.corda.serialization.internal.amqp.testutils.TestSerializationContext.kt - NewLineAtEndOfFile:TestUtils.kt$net.corda.common.configuration.parsing.internal.TestUtils.kt - NewLineAtEndOfFile:TestingNamedCacheFactory.kt$net.corda.testing.internal.TestingNamedCacheFactory.kt - NewLineAtEndOfFile:ThreadContextAdjustingRpcOpsProxy.kt$net.corda.node.internal.rpc.proxies.ThreadContextAdjustingRpcOpsProxy.kt - NewLineAtEndOfFile:ThreadContextAdjustingRpcOpsProxyTest.kt$net.corda.node.internal.rpc.proxies.ThreadContextAdjustingRpcOpsProxyTest.kt - NewLineAtEndOfFile:ThrowExceptionWrapper.kt$net.corda.djvm.rules.implementation.ThrowExceptionWrapper.kt - NewLineAtEndOfFile:ThrowableWrapperFactory.kt$net.corda.djvm.rewiring.ThrowableWrapperFactory.kt - NewLineAtEndOfFile:TimeWindow.kt$net.corda.core.contracts.TimeWindow.kt - NewLineAtEndOfFile:TimedFlowUtils.kt$net.corda.node.utilities.TimedFlowUtils.kt - NewLineAtEndOfFile:ToggleField.kt$net.corda.core.internal.ToggleField.kt - NewLineAtEndOfFile:TopLevelTransition.kt$net.corda.node.services.statemachine.transitions.TopLevelTransition.kt - NewLineAtEndOfFile:TopologicalSortTest.kt$net.corda.core.internal.TopologicalSortTest.kt - NewLineAtEndOfFile:Trace.kt$net.corda.core.context.Trace.kt - NewLineAtEndOfFile:TrackedDelegate.kt$net.corda.client.jfx.model.TrackedDelegate.kt - NewLineAtEndOfFile:TransactionCallbackTest.kt$net.corda.node.services.persistence.TransactionCallbackTest.kt - NewLineAtEndOfFile:TransactionGenerator.kt$net.corda.deterministic.data.TransactionGenerator.kt - NewLineAtEndOfFile:TransactionStorage.kt$net.corda.core.node.services.TransactionStorage.kt - NewLineAtEndOfFile:TransactionUtils.kt$net.corda.core.internal.TransactionUtils.kt - NewLineAtEndOfFile:TransactionVerificationExceptionSerialisationTests.kt$net.corda.core.contracts.TransactionVerificationExceptionSerialisationTests.kt - NewLineAtEndOfFile:TransactionVerifierService.kt$net.corda.core.node.services.TransactionVerifierService.kt - NewLineAtEndOfFile:TransactionWithSignatures.kt$net.corda.core.transactions.TransactionWithSignatures.kt - NewLineAtEndOfFile:TransactionWithSignaturesTest.kt$net.corda.deterministic.transactions.TransactionWithSignaturesTest.kt - NewLineAtEndOfFile:TryBlock.kt$net.corda.djvm.code.instructions.TryBlock.kt - NewLineAtEndOfFile:TutorialContract.kt$net.corda.docs.kotlin.tutorial.contract.TutorialContract.kt - NewLineAtEndOfFile:TutorialFlowStateMachines.kt$net.corda.docs.kotlin.tutorial.flowstatemachines.TutorialFlowStateMachines.kt - NewLineAtEndOfFile:TypeIdentifier.kt$net.corda.serialization.internal.model.TypeIdentifier.kt - NewLineAtEndOfFile:TypeIdentifierTests.kt$net.corda.serialization.internal.model.TypeIdentifierTests.kt - NewLineAtEndOfFile:TypeModellingFingerPrinterTests.kt$net.corda.serialization.internal.amqp.TypeModellingFingerPrinterTests.kt - NewLineAtEndOfFile:TypeNotationGenerator.kt$net.corda.serialization.internal.amqp.TypeNotationGenerator.kt - NewLineAtEndOfFile:Types.kt$net.corda.djvm.code.Types.kt - NewLineAtEndOfFile:TypesafeCordappConfig.kt$net.corda.node.internal.cordapp.TypesafeCordappConfig.kt - NewLineAtEndOfFile:TypesafeCordappConfigTests.kt$net.corda.node.internal.cordapp.TypesafeCordappConfigTests.kt - NewLineAtEndOfFile:UniqueDummyFungibleContract.kt$net.corda.testing.internal.vault.UniqueDummyFungibleContract.kt - NewLineAtEndOfFile:UniqueDummyLinearContract.kt$net.corda.testing.internal.vault.UniqueDummyLinearContract.kt - NewLineAtEndOfFile:UniqueIdentifier.kt$net.corda.core.contracts.UniqueIdentifier.kt - NewLineAtEndOfFile:UniqueIdentifierTest.kt$net.corda.deterministic.contracts.UniqueIdentifierTest.kt - NewLineAtEndOfFile:UpdateBusinessDayFlow.kt$net.corda.irs.flows.UpdateBusinessDayFlow.kt - NewLineAtEndOfFile:User.kt$net.corda.testing.node.User.kt - NewLineAtEndOfFile:Utils.kt$io.cryptoblk.core.Utils.kt - NewLineAtEndOfFile:Utils.kt$net.corda.common.configuration.parsing.internal.Utils.kt - NewLineAtEndOfFile:Utils.kt$net.corda.node.internal.classloading.Utils.kt - NewLineAtEndOfFile:UtilsTest.kt$net.corda.common.configuration.parsing.internal.UtilsTest.kt - NewLineAtEndOfFile:UuidGenerator.kt$net.corda.core.utilities.UuidGenerator.kt - NewLineAtEndOfFile:V1NodeConfigurationSpec.kt$net.corda.node.services.config.schema.v1.V1NodeConfigurationSpec.kt - NewLineAtEndOfFile:Validated.kt$net.corda.common.validation.internal.Validated.kt - NewLineAtEndOfFile:Validator.kt$net.corda.common.validation.internal.Validator.kt - NewLineAtEndOfFile:Vault.kt$net.corda.behave.scenarios.helpers.Vault.kt - NewLineAtEndOfFile:VaultEnumTypesTest.kt$net.corda.core.node.services.VaultEnumTypesTest.kt - NewLineAtEndOfFile:VaultQueryTests.kt$net.corda.node.services.vault.VaultQueryTests.kt - NewLineAtEndOfFile:VaultService.kt$net.corda.core.node.services.VaultService.kt - NewLineAtEndOfFile:VaultStateMigration.kt$net.corda.node.migration.VaultStateMigration.kt - NewLineAtEndOfFile:VersionExtractor.kt$net.corda.common.configuration.parsing.internal.versioned.VersionExtractor.kt - NewLineAtEndOfFile:VersionExtractorTest.kt$net.corda.common.configuration.parsing.internal.versioned.VersionExtractorTest.kt - NewLineAtEndOfFile:VersionInfo.kt$net.corda.node.VersionInfo.kt - NewLineAtEndOfFile:VersionedParsingExampleTest.kt$net.corda.common.configuration.parsing.internal.versioned.VersionedParsingExampleTest.kt - NewLineAtEndOfFile:VersionedSpecificationRegistry.kt$net.corda.common.configuration.parsing.internal.versioned.VersionedSpecificationRegistry.kt - NewLineAtEndOfFile:VirtualCordapps.kt$net.corda.node.internal.cordapp.VirtualCordapps.kt - NewLineAtEndOfFile:Volume.kt$net.corda.networkbuilder.volumes.Volume.kt - NewLineAtEndOfFile:Watch.kt$net.corda.behave.monitoring.Watch.kt - NewLineAtEndOfFile:WebServer.kt$net.corda.webserver.WebServer.kt - NewLineAtEndOfFile:WebServerPluginRegistry.kt$net.corda.webserver.services.WebServerPluginRegistry.kt - NewLineAtEndOfFile:WhitelistBasedTypeModelConfiguration.kt$net.corda.serialization.internal.amqp.WhitelistBasedTypeModelConfiguration.kt - NewLineAtEndOfFile:WithContracts.kt$net.corda.core.flows.mixins.WithContracts.kt - NewLineAtEndOfFile:WithMockNet.kt$net.corda.core.flows.mixins.WithMockNet.kt - NewLineAtEndOfFile:X509EdDSAEngineTest.kt$net.corda.core.internal.X509EdDSAEngineTest.kt - NewLineAtEndOfFile:YearMonthSerializer.kt$net.corda.serialization.internal.amqp.custom.YearMonthSerializer.kt - NewLineAtEndOfFile:YearSerializer.kt$net.corda.serialization.internal.amqp.custom.YearSerializer.kt - NewLineAtEndOfFile:ZoneIdSerializer.kt$net.corda.serialization.internal.amqp.custom.ZoneIdSerializer.kt - NewLineAtEndOfFile:ZonedDateTimeSerializer.kt$net.corda.serialization.internal.amqp.custom.ZonedDateTimeSerializer.kt - NewLineAtEndOfFile:errorAndTerminate.kt$net.corda.node.utilities.errorAndTerminate.kt PackageNaming:MessageState.kt$package net.corda.testMessage PackageNaming:ScheduledState.kt$package net.corda.testMessage ReturnCount:AbstractPartyDescriptor.kt$AbstractPartyDescriptor$override fun <X : Any> unwrap(value: AbstractParty?, type: Class<X>, options: WrapperOptions): X? @@ -11141,21 +6064,14 @@ TopLevelPropertyNaming:TestConstants.kt$/** A test node name **/ @JvmField val DUMMY_BANK_C_NAME = CordaX500Name("Bank C", "Tokyo", "JP") TopLevelPropertyNaming:TestConstants.kt$/** A test notary name **/ @JvmField val DUMMY_NOTARY_NAME = CordaX500Name("Notary Service", "Zurich", "CH") UnreachableCode:FlowRetryTest.kt$RetryFlow$throw ExceptionToCauseFiniteRetry() - VariableNaming:AMQPBridgeTest.kt$AMQPBridgeTest$private val BOB = TestIdentity(BOB_NAME) VariableNaming:AttachmentsClassLoaderSerializationTests.kt$AttachmentsClassLoaderSerializationTests$val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party VariableNaming:AttachmentsClassLoaderSerializationTests.kt$AttachmentsClassLoaderSerializationTests$val MEGA_CORP = TestIdentity(CordaX500Name("MegaCorp", "London", "GB")).party VariableNaming:BootstrapperView.kt$BootstrapperView$val YAML_MAPPER = Constants.getContextMapper() VariableNaming:Cap.kt$Cap$val TEST_TX_TIME_1: Instant get() = Instant.parse("2017-09-02T12:00:00.00Z") VariableNaming:Caplet.kt$Caplet$val TEST_TX_TIME_1: Instant get() = Instant.parse("2017-09-02T12:00:00.00Z") - VariableNaming:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$private lateinit var INTERMEDIATE_CA: CertificateAndKeyPair - VariableNaming:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$private val ROOT_CA = DEV_ROOT_CA VariableNaming:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val ECDSA_ALGORITHM = "SHA256withECDSA" VariableNaming:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val EC_ALGORITHM = "EC" VariableNaming:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests$val EMPTY_CRL = "empty.crl" - VariableNaming:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests.CrlServlet$private val EMPTY_CRL = "empty.crl" - VariableNaming:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests.CrlServlet$private val INTEMEDIATE_CRL = "intermediate.crl" - VariableNaming:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests.CrlServlet$private val NODE_CRL = "node.crl" - VariableNaming:CertificateRevocationListNodeTests.kt$CertificateRevocationListNodeTests.CrlServlet$private val SIGNATURE_ALGORITHM = "SHA256withECDSA" VariableNaming:CompositeKeyTests.kt$CompositeKeyTests$val EdSignature = keyPairEd.sign(SignableData(secureHash, SignatureMetadata(1, Crypto.findSignatureScheme(keyPairEd.public).schemeNumberID))) VariableNaming:CompositeKeyTests.kt$CompositeKeyTests$val K1Signature = keyPairK1.sign(SignableData(secureHash, SignatureMetadata(1, Crypto.findSignatureScheme(keyPairK1.public).schemeNumberID))) VariableNaming:CompositeKeyTests.kt$CompositeKeyTests$val R1Signature = keyPairR1.sign(SignableData(secureHash, SignatureMetadata(1, Crypto.findSignatureScheme(keyPairR1.public).schemeNumberID))) @@ -11213,34 +6129,12 @@ VariableNaming:HibernateConfigurationTest.kt$HibernateConfigurationTest$val _vaultLinearStates = it[1] as VaultSchemaV1.VaultLinearStates VariableNaming:InternalMockNetwork.kt$MessagingServiceSpy$internal var _messagingService: MessagingService? = null set(value) { check(field == null) { "Spy has already been attached to a node" } field = value } VariableNaming:InternalUtilsTest.kt$InternalUtilsTest$val MAX_SIZE = 100 - VariableNaming:KotlinUtilsTest.kt$KotlinUtilsTest$private val KRYO_CHECKPOINT_NOWHITELIST_CONTEXT = CheckpointSerializationContextImpl( javaClass.classLoader, EmptyWhitelist, emptyMap(), true, null) VariableNaming:Literal.kt$ActionBuilder$val This = this - VariableNaming:NetworkBootstrapperTest.kt$NetworkBootstrapperTest$private val ALICE = TestIdentity(ALICE_NAME, 70) - VariableNaming:NetworkBootstrapperTest.kt$NetworkBootstrapperTest$private val BOB = TestIdentity(BOB_NAME, 80) - VariableNaming:NodeInterestRatesTest.kt$NodeInterestRatesTest$private val TEST_DATA = NodeInterestRates.parseFile(""" LIBOR 2016-03-16 1M = 0.678 LIBOR 2016-03-16 2M = 0.685 LIBOR 2016-03-16 1Y = 0.890 LIBOR 2016-03-16 2Y = 0.962 EURIBOR 2016-03-15 1M = 0.123 EURIBOR 2016-03-15 2M = 0.111 """.trimIndent()) VariableNaming:NodeMonitorModel.kt$NodeMonitorModel$val _connection = client.start(username, password) VariableNaming:NodePerformanceTests.kt$NodePerformanceTests$val N = 10000 VariableNaming:NodeVaultService.kt$NodeVaultService.InnerState$val _rawUpdatesPublisher = PublishSubject.create<Vault.Update<ContractState>>()!! VariableNaming:NodeVaultService.kt$NodeVaultService.InnerState$val _updatesInDbTx = _updatesPublisher.wrapWithDatabaseTransaction().asObservable()!! VariableNaming:NodeVaultService.kt$NodeVaultService.InnerState$val _updatesPublisher = PublishSubject.create<Vault.Update<ContractState>>()!! - VariableNaming:Notarise.kt$NotaryDemoClientApi$/** A dummy identity. */ private val BOB_NAME = CordaX500Name("Bob Plc", "Rome", "IT") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$/** * The curve group name. */ private val CURVE_GROUP_NAME_CCP1 = CurveGroupName.of("USD-DSCON-LIBOR3M") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$/** * The first counterparty. */ private val CCP1_ID = StandardId.of("example", "CCP-1") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$/** * The location of the curve calibration groups file for CCP1 and CCP2. */ private val GROUPS_RESOURCE_CCP1 = resourceLocator("example-calibration/curves/groups.csv") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$/** * The location of the curve calibration nodes file for CCP1 and CCP2. */ private val CALIBRATION_RESOURCE_CCP1 = resourceLocator("example-calibration/curves/calibrations.csv") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$/** * The location of the curve calibration settings file for CCP1 and CCP2. */ private val SETTINGS_RESOURCE_CCP1 = resourceLocator("example-calibration/curves/settings.csv") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$/** * The location of the historical fixing file. */ private val FIXINGS_RESOURCE = resourceLocator("example-marketdata/historical-fixings/usd-libor-3m.csv") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$/** * The location of the market quotes file for CCP1 and CCP2. */ private val QUOTES_RESOURCE_CCP1 = resourceLocator("example-calibration/quotes/quotes.csv") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$/** * The second counterparty. */ private val CCP2_ID = StandardId.of("example", "CCP-2") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$/** * The valuation date. */ private val VAL_DATE = LocalDate.of(2015, 7, 21) - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$private val CALIBRATION_RESOURCE_CCP2 = resourceLocator("example-calibration/curves/calibrations-ccp2.csv") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$private val CURVE_GROUP_NAME_CCP2 = CurveGroupName.of("USD-DSCON-LIBOR3M-CCP2") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$private val GROUPS_RESOURCE_CCP2 = resourceLocator("example-calibration/curves/groups-ccp2.csv") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$private val QUOTES_RESOURCE_CCP2 = resourceLocator("example-calibration/quotes/quotes-ccp2.csv") - VariableNaming:OGSwapPricingCcpExample.kt$SwapPricingCcpExample$private val SETTINGS_RESOURCE_CCP2 = resourceLocator("example-calibration/curves/settings-ccp2.csv") - VariableNaming:ObligationTests.kt$ObligationTests$private val Amount<Issued<Currency>>.OBLIGATION: Obligation.State<Currency> get() = Obligation.State(Obligation.Lifecycle.NORMAL, DUMMY_OBLIGATION_ISSUER, token.OBLIGATION_DEF, quantity, NULL_PARTY) - VariableNaming:ObligationTests.kt$ObligationTests$private val Issued<Currency>.OBLIGATION_DEF: Obligation.Terms<Currency> get() = Obligation.Terms(NonEmptySet.of(cashContractBytes.sha256() as SecureHash), NonEmptySet.of(this), TEST_TX_TIME) - VariableNaming:OracleNodeTearOffTests.kt$OracleNodeTearOffTests$private val TEST_DATA = NodeInterestRates.parseFile(""" LIBOR 2016-03-16 1M = 0.678 LIBOR 2016-03-16 2M = 0.685 LIBOR 2016-03-16 1Y = 0.890 LIBOR 2016-03-16 2Y = 0.962 EURIBOR 2016-03-15 1M = 0.123 EURIBOR 2016-03-15 2M = 0.111 """.trimIndent()) VariableNaming:OracleNodeTearOffTests.kt$OracleNodeTearOffTests$val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party VariableNaming:PersistentStateServiceTests.kt$PersistentStateServiceTests$val MEGA_CORP = TestIdentity(CordaX500Name("MegaCorp", "London", "GB")).party VariableNaming:PortfolioApi.kt$PortfolioApi$var IMs: Map<String, InitialMarginTriple>? = null @@ -11253,25 +6147,14 @@ VariableNaming:RollOutTests.kt$RollOutTests$val contract_and2 = arrange { actions { highStreetBank may { "do it" anytime { highStreetBank.owes(acmeCorp, 10.K, USD) } } } actions { acmeCorp may { "do it" anytime { acmeCorp.owes(momAndPop, 10.K, USD) } } } next() } VariableNaming:RollOutTests.kt$RollOutTests$val contract_transfer1 = arrange { highStreetBank.owes(acmeCorp, 10.K, USD) } VariableNaming:RollOutTests.kt$RollOutTests$val contract_transfer2 = arrange { highStreetBank.owes(acmeCorp, 10.K, USD) } - VariableNaming:SSHServerTest.kt$FlowICanRun$private val HELLO_STEP = ProgressTracker.Step("Hello") VariableNaming:ScheduledFlowIntegrationTests.kt$ScheduledFlowIntegrationTests$val N = 23 VariableNaming:ScheduledFlowTests.kt$ScheduledFlowTests$val N = 99 - VariableNaming:SearchField.kt$SearchField$private val ALL = "All" - VariableNaming:SerializationOutputTests.kt$SerializationOutputTests$private val FOO_PROGRAM_ID = "net.corda.serialization.internal.amqp.SerializationOutputTests.FooContract" - VariableNaming:StandaloneShellArgsParserTest.kt$StandaloneShellArgsParserTest$private val CONFIG_FILE = StandaloneShellArgsParserTest::class.java.getResource("/config.conf").toPath() VariableNaming:SwapExample.kt$SwapExample$val VALUATION_DATE = LocalDate.of(2016, 6, 6)!! VariableNaming:Swaption.kt$Swaption$val TEST_TX_TIME_1: Instant get() = Instant.parse("2017-09-02T12:00:00.00Z") - VariableNaming:TLSAuthenticationTests.kt$TLSAuthenticationTests$// Default supported TLS schemes for Corda nodes. private val CORDA_TLS_CIPHER_SUITES = arrayOf( "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256" ) - VariableNaming:TLSAuthenticationTests.kt$TLSAuthenticationTests$// Intermediate CA. private val INTERMEDIATE_X500 = X500Principal("CN=Intermediate_CA_1,O=R3CEV,L=London,C=GB") - VariableNaming:TLSAuthenticationTests.kt$TLSAuthenticationTests$// Password for keys and keystores. private val PASSWORD = "dummypassword" - VariableNaming:TLSAuthenticationTests.kt$TLSAuthenticationTests$// Root CA. private val ROOT_X500 = X500Principal("CN=Root_CA_1,O=R3CEV,L=London,C=GB") - VariableNaming:TLSAuthenticationTests.kt$TLSAuthenticationTests$// TLS client (client2). private val CLIENT_2_X500 = CordaX500Name(commonName = "Client_2", organisation = "R3CEV", locality = "London", country = "GB") - VariableNaming:TLSAuthenticationTests.kt$TLSAuthenticationTests$// TLS server (client1). private val CLIENT_1_X500 = CordaX500Name(commonName = "Client_1", organisation = "R3CEV", locality = "London", country = "GB") VariableNaming:TestCommsFlowInitiatorTest.kt$TestCommsFlowInitiatorTest$val ALICE = TestIdentity(ALICE_NAME, 70) VariableNaming:TestCommsFlowInitiatorTest.kt$TestCommsFlowInitiatorTest$val DUMMY_BANK_A = TestIdentity(DUMMY_BANK_A_NAME, 3) VariableNaming:TestCommsFlowInitiatorTest.kt$TestCommsFlowInitiatorTest$val NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 12) VariableNaming:TopologicalSortTest.kt$TopologicalSortTest$val N = 10 - VariableNaming:TransactionSerializationTests.kt$TransactionSerializationTests$private val TEST_CASH_PROGRAM_ID = "net.corda.core.serialization.TransactionSerializationTests\$TestCash" VariableNaming:TransactionSerializationTests.kt$TransactionSerializationTests$val DUMMY_KEY_2 = generateKeyPair() VariableNaming:VaultQueryTests.kt$VaultQueryParties$val ALICE get() = alice.party VariableNaming:VaultQueryTests.kt$VaultQueryParties$val ALICE_IDENTITY get() = alice.identity @@ -11298,7 +6181,6 @@ VariableNaming:VaultQueryTests.kt$VaultQueryParties$val MINI_CORP get() = miniCorp.party VariableNaming:VaultQueryTests.kt$VaultQueryParties$val MINI_CORP_IDENTITY get() = miniCorp.identity VariableNaming:VaultQueryTests.kt$VaultQueryTestsBase$// Beware: do not use `MyContractClass::class.qualifiedName` as this returns a fully qualified name using "dot" notation for enclosed class val MYCONTRACT_ID = "net.corda.node.services.vault.VaultQueryTestsBase\$MyContractClass" - VariableNaming:VaultQueryTests.kt$VaultQueryTestsBase$private val TODAY = LocalDate.now().atStartOfDay().toInstant(ZoneOffset.UTC) VariableNaming:ZeroCouponBond.kt$ZeroCouponBond$val TEST_TX_TIME_1: Instant get() = Instant.parse("2017-09-02T12:00:00.00Z") WildcardImport:AMQPClient.kt$import io.netty.channel.* WildcardImport:AMQPClientSerializationScheme.kt$import net.corda.serialization.internal.* diff --git a/detekt-config.yml b/detekt-config.yml index 42a4494468..de3824c6da 100644 --- a/detekt-config.yml +++ b/detekt-config.yml @@ -84,7 +84,7 @@ complexity: ComplexMethod: active: true threshold: 10 - ignoreSingleWhenExpression: false + ignoreSingleWhenExpression: true LabeledExpression: active: false LargeClass: @@ -92,7 +92,7 @@ complexity: threshold: 150 LongMethod: active: true - threshold: 20 + threshold: 120 LongParameterList: active: true threshold: 6 @@ -135,7 +135,7 @@ empty-blocks: EmptyForBlock: active: true EmptyFunctionBlock: - active: true + active: false EmptyIfBlock: active: true EmptyInitBlock: @@ -240,7 +240,7 @@ naming: VariableNaming: active: true variablePattern: '[a-z][A-Za-z0-9]*' - privateVariablePattern: '(_)?[a-z][A-Za-z0-9]*' + privateVariablePattern: '(_)?[A-Za-z][_A-Za-z0-9]*' excludeClassPattern: '$^' performance: @@ -321,7 +321,7 @@ style: ignoreEnums: false MaxLineLength: active: true - maxLineLength: 120 + maxLineLength: 140 excludePackageStatements: false excludeImportStatements: false MayBeConst: @@ -331,7 +331,7 @@ style: NestedClassesVisibility: active: false NewLineAtEndOfFile: - active: true + active: false NoTabs: active: false OptionalAbstractKeyword: