public void TestRegisterAndEmptyInit() { ChaincodeBaseAsync cb = new EmptyChaincode(); ChaincodeInput inp = new ChaincodeInput(); inp.Args.Add(ByteString.CopyFromUtf8("")); ByteString payload = inp.ToByteString(); ChaincodeMessage initMsg = MessageUtil.NewEventMessage(ChaincodeMessage.Types.Type.Init, "testChannel", "0", payload, null); List <IScenarioStep> scenario = new List <IScenarioStep>(); scenario.Add(new RegisterStep()); scenario.Add(new CompleteStep()); server = ChaincodeMockPeer.StartServer(scenario); cb.Start(new string[] { "-a", "127.0.0.1:7052", "-i", "testId" }); CheckScenarioStepEnded(server, 1, Timeout); server.Send(initMsg); CheckScenarioStepEnded(server, 2, Timeout); Assert.AreEqual(server.LastMessageSend.Type, ChaincodeMessage.Types.Type.Init); Assert.AreEqual(server.LastMessageRcvd.Type, ChaincodeMessage.Types.Type.Completed); }
public void TestGetHistoryForKey() { ChaincodeBase cb = new Cb4(); ChaincodeInput ci = new ChaincodeInput(); ci.Args.AddRange(new[] { ByteString.CopyFromUtf8("") }); ByteString initPayload = ci.ToByteString(); ChaincodeMessage initMsg = MessageUtil.NewEventMessage(ChaincodeMessage.Types.Type.Init, "testChannel", "0", initPayload, null); ci = new ChaincodeInput(); ci.Args.AddRange(new[] { ByteString.CopyFromUtf8("invoke"), ByteString.CopyFromUtf8("key1") }); ByteString invokePayload = ci.ToByteString(); ChaincodeMessage invokeMsg = MessageUtil.NewEventMessage(ChaincodeMessage.Types.Type.Transaction, "testChannel", "0", invokePayload, null); List <IScenarioStep> scenario = new List <IScenarioStep>(); scenario.Add(new RegisterStep()); scenario.Add(new CompleteStep()); scenario.Add(new GetHistoryForKeyStep(false, "1", "2")); scenario.Add(new QueryCloseStep()); scenario.Add(new CompleteStep()); server = ChaincodeMockPeer.StartServer(scenario); cb.Start(new string[] { "-a", "127.0.0.1:7052", "-i", "testId" }); CheckScenarioStepEnded(server, 1, Timeout); server.Send(initMsg); CheckScenarioStepEnded(server, 2, Timeout); server.Send(invokeMsg); CheckScenarioStepEnded(server, 5, Timeout); Assert.AreEqual(server.LastMessageSend.Type, ChaincodeMessage.Types.Type.Response); Assert.AreEqual(server.LastMessageRcvd.Type, ChaincodeMessage.Types.Type.Completed); Assert.AreEqual(Protos.Peer.ProposalResponsePackage.Response.Parser.ParseFrom(server.LastMessageRcvd.Payload).Message, "OK response2"); }
public void TestInvokeChaincode() { ChaincodeBase cb = new Cb5(); ChaincodeInput ci = new ChaincodeInput(); ci.Args.AddRange(new[] { ByteString.CopyFromUtf8("") }); ByteString initPayload = ci.ToByteString(); ChaincodeMessage initMsg = MessageUtil.NewEventMessage(ChaincodeMessage.Types.Type.Init, "testChannel", "0", initPayload, null); ci = new ChaincodeInput(); ci.Args.AddRange(new[] { ByteString.CopyFromUtf8("invoke") }); ByteString invokePayload = ci.ToByteString(); ChaincodeMessage invokeMsg = MessageUtil.NewEventMessage(ChaincodeMessage.Types.Type.Transaction, "testChannel", "0", invokePayload, null); List <IScenarioStep> scenario = new List <IScenarioStep>(); scenario.Add(new RegisterStep()); scenario.Add(new CompleteStep()); scenario.Add(new InvokeChaincodeStep()); scenario.Add(new CompleteStep()); server = ChaincodeMockPeer.StartServer(scenario); cb.Start(new string[] { "-a", "127.0.0.1:7052", "-i", "testId" }); CheckScenarioStepEnded(server, 1, Timeout); server.Send(initMsg); CheckScenarioStepEnded(server, 2, Timeout); server.Send(invokeMsg); CheckScenarioStepEnded(server, 4, Timeout); Assert.AreEqual(server.LastMessageSend.Type, ChaincodeMessage.Types.Type.Response); Assert.AreEqual(server.LastMessageRcvd.Type, ChaincodeMessage.Types.Type.Completed); }
public virtual async Task <Response> InvokeChaincodeAsync(string channelId, string txId, string chaincodeName, List <byte[]> args, CancellationToken token = default(CancellationToken)) { try { // create invocation specification of the chaincode to invoke ChaincodeSpec invocationSpec = new ChaincodeSpec { ChaincodeId = new ChaincodeID { Name = chaincodeName }, Input = new ChaincodeInput { Args = { args.Select(ByteString.CopyFrom) } } }; // invoke other chaincode ByteString payload = await InvokeChaincodeSupportAsync(NewInvokeChaincodeMessage(channelId, txId, invocationSpec.ToByteString()), token).ConfigureAwait(false); // response message payload should be yet another chaincode // message (the actual response message) ChaincodeMessage responseMessage = ChaincodeMessage.Parser.ParseFrom(payload); // the actual response message must be of type COMPLETED logger.Debug($"[{txId},-8]{responseMessage.Type} response received from other chaincode."); if (responseMessage.Type == ChaincodeMessage.Types.Type.Completed) { // success return(ToChaincodeResponse(Protos.Peer.ProposalResponsePackage.Response.Parser.ParseFrom(responseMessage.Payload))); } // error return(NewErrorChaincodeResponse(responseMessage.Payload.ToStringUtf8())); } catch (Exception e) { throw new InvalidOperationException(e.Message, e); } }
private Task HandleReadyAsync(ChaincodeMessage message, CancellationToken token) { switch (message.Type) { case ChaincodeMessage.Types.Type.Response: logger.Debug($"[{message.Txid,-8}s] Received RESPONSE: publishing to channel"); return(SendChannelAsync(message, token)); case ChaincodeMessage.Types.Type.Error: logger.Debug($"[{message.Txid,-8}s] Received ERROR: publishing to channel"); return(SendChannelAsync(message, token)); case ChaincodeMessage.Types.Type.Init: logger.Debug($"[{message.Txid,-8}s] Received INIT: invoking chaincode init"); return(HandleInitAsync(message, token)); case ChaincodeMessage.Types.Type.Transaction: logger.Debug($"[{message.Txid,-8}s] Received TRANSACTION: invoking chaincode"); return(HandleTransactionAsync(message, token)); default: logger.Warning($"[{message.Txid,-8}s] Received {message.Type}: cannot handle"); return(Task.FromResult(0)); } }
Chat_sends_an_error_to_the_peer_when_it_is_in_state_established_but_it_does_not_receive_a_ready_response() { var responseMessage = new ChaincodeMessage { Type = ChaincodeMessage.Types.Type.Completed }; var requestStreamMock = new Mock <IClientStreamWriter <ChaincodeMessage> >(); requestStreamMock.Setup(m => m.WriteAsync(null)).Returns(Task.CompletedTask); requestStreamMock.Setup(m => m.WriteAsync(It.Is( (ChaincodeMessage message) => message != null && message.Type == ChaincodeMessage.Types.Type.Error ))).Returns(Task.CompletedTask); var(responseStreamMock, chaincodeSupportClientMock, chaincodeSupportClientFactoryMock, handler) = CreateHandlerMockWithStreamExpectation(responseMessage, requestStreamMock.Object); handler.State = States.Established; await handler.Chat(null); chaincodeSupportClientFactoryMock.VerifyAll(); chaincodeSupportClientMock.VerifyAll(); responseStreamMock.VerifyAll(); requestStreamMock.VerifyAll(); handler.State.Should().Be(States.Established); }
private async Task HandleChaincodeMessageAsync(ChaincodeMessage message, CancellationToken token) { logger.Debug($"[{message.Txid,-8}s] Handling ChaincodeMessage of type: {message.Type}, handler state {State}"); if (message.Type == ChaincodeMessage.Types.Type.Keepalive) { logger.Debug($"[{message.Txid,-8}s] Received KEEPALIVE: nothing to do"); return; } switch (State) { case CCState.CREATED: HandleCreated(message); break; case CCState.ESTABLISHED: HandleEstablished(message); break; case CCState.READY: await HandleReadyAsync(message, token).ConfigureAwait(false); break; default: logger.Warning($"[{message.Txid,-8}s] Received {message.Type}: cannot handle"); break; } }
Chat_handles_the_message_with_message_queue_when_state_is_ready_and_response_is_of_type_response() { var responseMessage = new ChaincodeMessage { Type = ChaincodeMessage.Types.Type.Response }; var messageQueueMock = new Mock <IMessageQueue>(); messageQueueMock.Setup(m => m.HandleMessageResponse(responseMessage)); var messageQueueFactoryMock = new Mock <IMessageQueueFactory>(); messageQueueFactoryMock.Setup(m => m.Create(It.IsAny <global::Thinktecture.HyperledgerFabric.Chaincode.NET.Handler.Handler>())) .Returns(messageQueueMock.Object); var(responseStreamMock, chaincodeSupportClientMock, chaincodeSupportClientFactoryMock, handler) = CreateHandlerMockWithStreamExpectation(responseMessage, null, messageQueueFactoryMock.Object); handler.State = States.Ready; await handler.Chat(null); chaincodeSupportClientFactoryMock.VerifyAll(); chaincodeSupportClientMock.VerifyAll(); responseStreamMock.VerifyAll(); messageQueueFactoryMock.VerifyAll(); messageQueueMock.VerifyAll(); }
Chat_sends_an_error_to_peer_when_it_should_handle_a_transaction_but_input_parameter_is_incorrect() { var responseMessage = new ChaincodeMessage { Type = ChaincodeMessage.Types.Type.Transaction, Payload = "unittest".ToByteString(), ChannelId = "ChannelId", Txid = "TxId" }; var conversationStartMessage = new ChaincodeMessage(); var requestStreamMock = new Mock <IClientStreamWriter <ChaincodeMessage> >(); requestStreamMock.Setup(m => m.WriteAsync(conversationStartMessage)).Returns(Task.CompletedTask); requestStreamMock.Setup(m => m.WriteAsync(It.Is( (ChaincodeMessage message) => message.Type == ChaincodeMessage.Types.Type.Error && message.Txid == "TxId" && message.ChannelId == "ChannelId" && message.Payload == responseMessage.Payload ))).Returns(Task.CompletedTask); var(responseStreamMock, chaincodeSupportClientMock, chaincodeSupportClientFactoryMock, handler) = CreateHandlerMockWithStreamExpectation(responseMessage, requestStreamMock.Object); handler.State = States.Ready; await handler.Chat(conversationStartMessage); chaincodeSupportClientFactoryMock.VerifyAll(); chaincodeSupportClientMock.VerifyAll(); responseStreamMock.VerifyAll(); requestStreamMock.VerifyAll(); }
public async void Start_calls_the_handlers_chat_method() { var options = Options.Create(new ChaincodeSettings { CORE_PEER_ADDRESS = "example.test:9999", CORE_CHAINCODE_ID_NAME = "unittest" }); var message = new ChaincodeMessage { Type = ChaincodeMessage.Types.Type.Register, Payload = new ChaincodeID { Name = "unittest" }.ToByteString() }; var handlerMock = new Mock <IHandler>(); handlerMock.Setup(m => m.Chat(message)).Returns(Task.CompletedTask); var handlerFactoryMock = new Mock <IHandlerFactory>(); handlerFactoryMock.Setup(m => m.Create("example.test", 9999)) .Returns(handlerMock.Object); var shim = new Shim(options, new Mock <ILogger <Shim> >().Object, handlerFactoryMock.Object); var result = await shim.Start(); result.Should().BeSameAs(handlerMock.Object); handlerFactoryMock.VerifyAll(); handlerMock.VerifyAll(); }
public void HandleMessageResponse(ChaincodeMessage response) { var messageTxContextId = response.ChannelId + response.Txid; var message = GetCurrentMessage(messageTxContextId) as dynamic; // TODO: This needs to be done better HandleResponseMessage(message, messageTxContextId, response); }
private Task <T> AskPeerAndListen <T>(ChaincodeMessage message, MessageMethod method) { var taskCompletionSource = new TaskCompletionSource <T>(); var queueMessage = new QueueMessage <T>(message, method, taskCompletionSource); _messageQueue.QueueMessage(queueMessage); return(taskCompletionSource.Task); }
public static string ToJsonString(this ChaincodeMessage message) { try { return(JsonConvert.SerializeObject(message, Formatting.None)); } catch (InvalidProtocolBufferException) { return($"{{ Type: {message.Type}, TxId: {message.Txid} }}"); } }
Chat_sends_an_error_to_peer_when_it_should_handle_a_transaction_but_chaincode_invocation_responded_with_unknown_response_code() { var responseMessage = new ChaincodeMessage { Type = ChaincodeMessage.Types.Type.Transaction, Payload = new ChaincodeInput().ToByteString(), ChannelId = "ChannelId", Txid = "TxId" }; var chaincodeStub = new Mock <IChaincodeStub>().Object; var chaincodeStubFactoryMock = new Mock <IChaincodeStubFactory>(); chaincodeStubFactoryMock.Setup <IChaincodeStub>(m => m.Create(It.IsAny <global::Thinktecture.HyperledgerFabric.Chaincode.NET.Handler.Handler>(), "ChannelId", "TxId", It.IsAny <ChaincodeInput>(), It.IsAny <SignedProposal>())) .Returns(chaincodeStub); var response = new Response { Status = 0 }; var chaincodeMock = new Mock <IChaincode>(); chaincodeMock.Setup(m => m.Invoke(chaincodeStub)) .ReturnsAsync(response); var conversationStartMessage = new ChaincodeMessage(); var requestStreamMock = new Mock <IClientStreamWriter <ChaincodeMessage> >(); requestStreamMock.Setup(m => m.WriteAsync(conversationStartMessage)).Returns(Task.CompletedTask); requestStreamMock.Setup(m => m.WriteAsync(It.Is( (ChaincodeMessage message) => message.Type == ChaincodeMessage.Types.Type.Error && message.Txid == "TxId" && message.ChannelId == "ChannelId" && message.Payload.ToStringUtf8().Contains("has not called success or error") ))).Returns(Task.CompletedTask); var(responseStreamMock, chaincodeSupportClientMock, chaincodeSupportClientFactoryMock, handler) = CreateHandlerMockWithStreamExpectation(responseMessage, requestStreamMock.Object, null, chaincodeStubFactoryMock.Object, chaincodeMock.Object); handler.State = States.Ready; await handler.Chat(conversationStartMessage); chaincodeSupportClientFactoryMock.VerifyAll(); chaincodeSupportClientMock.VerifyAll(); responseStreamMock.VerifyAll(); chaincodeStubFactoryMock.VerifyAll(); chaincodeMock.VerifyAll(); requestStreamMock.VerifyAll(); }
public async void Chat_invokes_the_chaincode_when_it_receives_a_transaction_message() { var responseMessage = new ChaincodeMessage { Type = ChaincodeMessage.Types.Type.Transaction, Payload = new ChaincodeInput().ToByteString(), ChannelId = "ChannelId", Txid = "TxId" }; var chaincodeStub = new Mock <IChaincodeStub>().Object; var chaincodeStubFactoryMock = new Mock <IChaincodeStubFactory>(); chaincodeStubFactoryMock.Setup <IChaincodeStub>(m => m.Create(It.IsAny <global::Thinktecture.HyperledgerFabric.Chaincode.NET.Handler.Handler>(), "ChannelId", "TxId", It.IsAny <ChaincodeInput>(), It.IsAny <SignedProposal>())) .Returns(chaincodeStub); var response = new Response { Status = (int)ResponseCodes.Ok }; var chaincodeMock = new Mock <IChaincode>(); chaincodeMock.Setup(m => m.Invoke(chaincodeStub)) .ReturnsAsync(response); var conversationStartMessage = new ChaincodeMessage(); var requestStreamMock = new Mock <IClientStreamWriter <ChaincodeMessage> >(); requestStreamMock.Setup(m => m.WriteAsync(conversationStartMessage)).Returns(Task.CompletedTask); requestStreamMock.Setup(m => m.WriteAsync(It.Is( (ChaincodeMessage message) => message.Type == ChaincodeMessage.Types.Type.Completed && message.Txid == "TxId" && message.ChannelId == "ChannelId" && message.Payload == response.ToByteString() ))).Returns(Task.CompletedTask); var(responseStreamMock, chaincodeSupportClientMock, chaincodeSupportClientFactoryMock, handler) = CreateHandlerMockWithStreamExpectation(responseMessage, requestStreamMock.Object, null, chaincodeStubFactoryMock.Object, chaincodeMock.Object); handler.State = States.Ready; await handler.Chat(conversationStartMessage); chaincodeSupportClientFactoryMock.VerifyAll(); chaincodeSupportClientMock.VerifyAll(); responseStreamMock.VerifyAll(); chaincodeStubFactoryMock.VerifyAll(); chaincodeMock.VerifyAll(); requestStreamMock.VerifyAll(); }
private void HandleCreated(ChaincodeMessage message) { if (message.Type == ChaincodeMessage.Types.Type.Registered) { State = CCState.ESTABLISHED; logger.Debug($"[{message.Txid,-8}s] Received REGISTERED: moving to established state"); } else { logger.Warning($"[{message.Txid,-8}s] Received {message.Type}: cannot handle"); } }
private static ChaincodeMessage NewEventMessage(ChaincodeMessage.Types.Type type, string channelId, string txId, ByteString payload, ChaincodeEvent evnt) { ChaincodeMessage msg = new ChaincodeMessage { Type = type, ChannelId = channelId, Txid = txId, Payload = payload }; if (evnt != null) { msg.ChaincodeEvent = evnt; } return(msg); }
private void HandleEstablished(ChaincodeMessage message) { if (message.Type == ChaincodeMessage.Types.Type.Ready) { State = CCState.READY; logger.Debug($"[{message.Txid,-8}s] Received READY: ready for invocations"); } else { logger.Warning($"[{message.Txid,-8}s] Received {message.Type}: cannot handle"); } }
private async Task SendChannelAsync(ChaincodeMessage message, CancellationToken token) { using (await _channelLock.LockAsync(token).ConfigureAwait(false)) { string key = GetTxKey(message.ChannelId, message.Txid); if (!responseChannel.ContainsKey(key)) { throw new InvalidOperationException($"[{message.Txid},-8]sendChannel does not exist"); } logger.Debug($"[{message.Txid},-8.8]Before send"); await responseChannel[key].EnqueueAsync(message, token).ConfigureAwait(false); logger.Debug($"[{message.Txid},-8]After send"); } }
private ChaincodeMessage NewErrorMessage(ChaincodeMessage message, States state) { var errorString = $"[{message.ChannelId}-{message.Txid}] Chaincode Handler FSM cannot " + $"handle message ({message.Type}, with payload size {message.Payload.Length} " + $"while in state {state}"; return(new ChaincodeMessage { Type = ChaincodeMessage.Types.Type.Error, Payload = errorString.ToByteString(), Txid = message.Txid, ChannelId = message.ChannelId }); }
/** * * @return Chaincode response packed as payload inside COMPLETE message packed as payload inside RESPONSE message */ public List <ChaincodeMessage> Next() { ByteString chaincodeResponse = new Protos.Peer.ProposalResponsePackage.Response { Status = (int)Protos.Common.Status.Success, Message = "OK" }.ToByteString(); ByteString completePayload = new ChaincodeMessage { Type = ChaincodeMessage.Types.Type.Completed, ChannelId = orgMsg.ChannelId, Txid = orgMsg.Txid, Payload = chaincodeResponse }.ToByteString(); List <ChaincodeMessage> list = new List <ChaincodeMessage>(); list.Add(new ChaincodeMessage { Type = ChaincodeMessage.Types.Type.Response, ChannelId = orgMsg.ChannelId, Txid = orgMsg.Txid, Payload = completePayload }); return(list); }
/** * Check incoming message * If message type is PUT_STATE and payload equal to passed in constructor * @param msg message from chaincode * @return */ public bool Expected(ChaincodeMessage msg) { orgMsg = msg; PutState putMsg; try { putMsg = PutState.Parser.ParseFrom(msg.Payload); } catch (InvalidProtocolBufferException) { return(false); } return(val.Equals(putMsg.Value.ToStringUtf8()) && msg.Type == ChaincodeMessage.Types.Type.PutState); }
public async void Chat_switches_state_from_created_to_established_when_it_receives_a_registered_response() { var responseMessage = new ChaincodeMessage { Type = ChaincodeMessage.Types.Type.Registered }; var(responseStreamMock, chaincodeSupportClientMock, chaincodeSupportClientFactoryMock, handler) = CreateHandlerMockWithStreamExpectation(responseMessage); await handler.Chat(null); chaincodeSupportClientFactoryMock.VerifyAll(); chaincodeSupportClientMock.VerifyAll(); responseStreamMock.VerifyAll(); handler.State.Should().Be(States.Established); }
public void TestStateValidationParameter() { ChaincodeBase cb = new Cb8(); ChaincodeInput ci = new ChaincodeInput(); ci.Args.AddRange(new[] { ByteString.CopyFromUtf8("init") }); ByteString initPayload = ci.ToByteString(); ChaincodeMessage initMsg = MessageUtil.NewEventMessage(ChaincodeMessage.Types.Type.Init, "testChannel", "0", initPayload, null); StateBasedEndorsement sbe = new StateBasedEndorsement(null); sbe.AddOrgs(RoleType.RoleTypePeer, "Org1"); sbe.AddOrgs(RoleType.RoleTypeMember, "Org2"); List <IScenarioStep> scenario = new List <IScenarioStep>(); scenario.Add(new RegisterStep()); scenario.Add(new CompleteStep()); scenario.Add(new GetStateMetadataStep(sbe)); scenario.Add(new PutStateMetadataStep(sbe)); scenario.Add(new CompleteStep()); server = ChaincodeMockPeer.StartServer(scenario); cb.Start(new string[] { "-a", "127.0.0.1:7052", "-i", "testId" }); CheckScenarioStepEnded(server, 1, Timeout); server.Send(initMsg); CheckScenarioStepEnded(server, 2, Timeout); Assert.AreEqual(server.LastMessageSend.Type, ChaincodeMessage.Types.Type.Init); Assert.AreEqual(server.LastMessageRcvd.Type, ChaincodeMessage.Types.Type.Completed); Assert.AreEqual(Protos.Peer.ProposalResponsePackage.Response.Parser.ParseFrom(server.LastMessageRcvd.Payload).Message, "OK response1"); ci = new ChaincodeInput(); ci.Args.AddRange(new[] { ByteString.CopyFromUtf8("invoke"), ByteString.CopyFromUtf8("a") }); ByteString invokePayload = ci.ToByteString(); ChaincodeMessage invokeMsg = MessageUtil.NewEventMessage(ChaincodeMessage.Types.Type.Transaction, "testChannel", "0", invokePayload, null); server.Send(invokeMsg); CheckScenarioStepEnded(server, 5, Timeout); Assert.AreEqual(server.LastMessageSend.Type, ChaincodeMessage.Types.Type.Response); Assert.AreEqual(server.LastMessageRcvd.Type, ChaincodeMessage.Types.Type.Completed); Assert.AreEqual(Protos.Peer.ProposalResponsePackage.Response.Parser.ParseFrom(server.LastMessageRcvd.Payload).Message, "OK response2"); }
private void HandleResponseMessage <T>( QueueMessage <T> message, string messageTxContextId, ChaincodeMessage response ) { try { var parsedResponse = _handler.ParseResponse(response, message.Method); message.Success((T)parsedResponse); } catch (Exception ex) { message.Fail(ex); } RemoveCurrentAndSendNextMessage(messageTxContextId); }
/** * Check incoming message * If message type is PUT_STATE_METADATA and payload match to passed in constructor * @param msg message from chaincode * @return */ public bool Expected(ChaincodeMessage msg) { orgMsg = msg; PutStateMetadata psm; try { psm = PutStateMetadata.Parser.ParseFrom(msg.Payload); } catch (InvalidProtocolBufferException) { return(false); } StateBasedEndorsement msgSbe = new StateBasedEndorsement(psm.Metadata.Value.ToByteArray()); return(msg.Type == ChaincodeMessage.Types.Type.PutStateMetadata && ChaincodeStub.VALIDATION_PARAMETER.Equals(psm.Metadata.Metakey) && msgSbe.ListOrgs().Count == val.ListOrgs().Count); }
public object ParseResponse(ChaincodeMessage response, MessageMethod messageMethod) { if (response.Type == ChaincodeMessage.Types.Type.Response) { _logger.LogInformation( $"[{response.ChannelId}-{response.Txid}] Received {messageMethod} successful response"); switch (messageMethod) { case MessageMethod.GetStateByRange: case MessageMethod.GetQueryResult: return(new StateQueryIterator(this, response.ChannelId, response.Txid, QueryResponse.Parser.ParseFrom(response.Payload))); case MessageMethod.GetHistoryForKey: return(new HistoryQueryIterator(this, response.ChannelId, response.Txid, QueryResponse.Parser.ParseFrom(response.Payload))); case MessageMethod.QueryStateNext: case MessageMethod.QueryStateClose: return(QueryResponse.Parser.ParseFrom(response.Payload)); case MessageMethod.InvokeChaincode: return(ChaincodeMessage.Parser.ParseFrom(response.Payload)); default: return(response.Payload); } } if (response.Type == ChaincodeMessage.Types.Type.Error) { _logger.LogInformation( $"[{response.ChannelId}-{response.Txid}] Received {messageMethod} error response"); throw new Exception(response.Payload.ToStringUtf8()); } var errorMessage = $"[{response.ChannelId}-{response.Txid}] Received incorrect chaincode " + $"in response to the {messageMethod} call: " + $"type={response.Type}, expecting \"RESPONSE\""; _logger.LogInformation(errorMessage); throw new Exception(errorMessage); }
public async void Directly_sends_a_single_message() { var handlerMock = new Mock <IHandler>(); var streamMock = new Mock <IClientStreamWriter <ChaincodeMessage> >(); handlerMock.SetupGet(m => m.WriteStream).Returns(streamMock.Object); var sut = new MessageQueue(handlerMock.Object, new Mock <ILogger <MessageQueue> >().Object); var chaincodeMessage = new ChaincodeMessage { Txid = "bar", ChannelId = "foo" }; await sut.QueueMessage(new QueueMessage(chaincodeMessage, 0)); streamMock.Verify(m => m.WriteAsync(chaincodeMessage), Times.Once); }
private async Task <ByteString> InvokeChaincodeSupportAsync(ChaincodeMessage message, CancellationToken token) { string channelId = message.ChannelId; string txId = message.Txid; try { // create a new response channel AsyncProducerConsumerQueue <ChaincodeMessage> respChannel = AquireResponseChannelForTx(channelId, txId); // send the message await QueueOutboundChaincodeMessageAsync(message, token).ConfigureAwait(false); // wait for response ChaincodeMessage response = await ReceiveChannelAsync(respChannel, token).ConfigureAwait(false); logger.Debug($"[{txId},-8]{response.Type} response received."); // handle response switch (response.Type) { case ChaincodeMessage.Types.Type.Response: logger.Debug($"[{txId},-8]Successful response received."); return(response.Payload); case ChaincodeMessage.Types.Type.Error: string error = $"[{txId},-8]Unsuccessful response received."; logger.Error(error); throw new InvalidOperationException(error); default: string error2 = $"[{txId},-8]Unexpected {response.Type} response received. Expected {ChaincodeMessage.Types.Type.Response} or {ChaincodeMessage.Types.Type.Error}."; logger.Error(error2); throw new InvalidOperationException(error2); } } finally { ReleaseResponseChannelForTx(channelId, txId); } }
// handleTransaction Handles request to execute a transaction. private void InternalHandleTransaction(ChaincodeMessage message, CancellationToken token, Func <IChaincodeStub, CancellationToken, Task <Response> > action) { Task.Run(async() => { try { // Get the function and args from Payload ChaincodeInput input = ChaincodeInput.Parser.ParseFrom(message.Payload); // Mark as a transaction (allow put/del state) MarkIsTransaction(message.ChannelId, message.Txid, true); // Create the ChaincodeStub which the chaincode can use to // callback IChaincodeStub stub = new ChaincodeStub(message.ChannelId, message.Txid, this, input.Args.ToList(), message.Proposal); // Call chaincode's init Response result = await action(stub, token).ConfigureAwait(false); if (result.Status >= Status.INTERNAL_SERVER_ERROR) { // Send ERROR with entire result.Message as payload logger.Error($"[{message.Txid},-8]Init failed. Sending {ChaincodeMessage.Types.Type.Error}"); await QueueOutboundChaincodeMessageAsync(NewErrorEventMessage(message.ChannelId, message.Txid, result.Message, stub.Event), token).ConfigureAwait(false); } else { // Send COMPLETED with entire result as payload logger.Debug($"[{message.Txid},-8]Init succeeded. Sending {ChaincodeMessage.Types.Type.Completed}"); await QueueOutboundChaincodeMessageAsync(NewCompletedEventMessage(message.ChannelId, message.Txid, result, stub.Event), token).ConfigureAwait(false); } } catch (Exception e) { logger.Error(e, $"[{message.Txid},-8]Init failed. Sending {ChaincodeMessage.Types.Type.Error}"); await QueueOutboundChaincodeMessageAsync(NewErrorEventMessage(message.ChannelId, message.Txid, e), token).ConfigureAwait(false); } finally { // delete isTransaction entry DeleteIsTransaction(message.ChannelId, message.Txid); } }, token); }