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 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 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 void TestProposalBuilderWithOutMetaInf()
{
InstallProposalBuilder installProposalBuilder = InstallProposalBuilder.Create();
installProposalBuilder.ChaincodeLanguage(TransactionRequest.Type.GO_LANG);
installProposalBuilder.ChaincodePath("github.com/example_cc");
installProposalBuilder.ChaincodeSource(SAMPLE_GO_CC.Locate());
installProposalBuilder.ChaincodeName("example_cc.go");
installProposalBuilder.ChaincodeVersion("1");
Channel channel = hfclient.NewChannel("testProposalBuilderWithOutMetaInf");
TransactionContext transactionContext = new TransactionContext(channel, TestUtils.TestUtils.GetMockUser("rick", "rickORG"), Factory.Instance.GetCryptoSuite());
installProposalBuilder.Context(transactionContext);
Proposal proposal = installProposalBuilder.Build(); // Build it get the proposal. Then unpack it to see if it's what we expect.
ChaincodeProposalPayload chaincodeProposalPayload = ChaincodeProposalPayload.Parser.ParseFrom(proposal.Payload);
ChaincodeInvocationSpec chaincodeInvocationSpec = ChaincodeInvocationSpec.Parser.ParseFrom(chaincodeProposalPayload.Input);
ChaincodeSpec chaincodeSpec = chaincodeInvocationSpec.ChaincodeSpec;
ChaincodeInput input = chaincodeSpec.Input;
ChaincodeDeploymentSpec chaincodeDeploymentSpec = ChaincodeDeploymentSpec.Parser.ParseFrom(input.Args[1]);
ByteString codePackage = chaincodeDeploymentSpec.CodePackage;
List <string> tarBytesToEntryArrayList = TestUtils.TestUtils.TarBytesToEntryArrayList(codePackage.ToByteArray());
List <string> expect = new List <string>()
{
"src/github.com/example_cc/example_cc.go"
};
CollectionAssert.AreEquivalent(expect, tarBytesToEntryArrayList, "Tar in Install Proposal's codePackage does not have expected entries. ");
}
public void Parses_arguments_correctly_when_function_name_and_parameters_are_set()
{
var input = new ChaincodeInput();
input.Args.AddRange(new List <ByteString>
{
"invoke".ToByteString(),
"key".ToByteString(),
"value".ToByteString()
});
var sut = CreateChaincodeStub(null, "ChannelId", "TxId", input, CreateValidSignedProposal());
sut.Args.Should().HaveCount(3);
sut.Args.Should().HaveElementAt(0, "invoke");
sut.Args.Should().HaveElementAt(1, "key");
sut.Args.Should().HaveElementAt(2, "value");
var fap = sut.GetFunctionAndParameters();
fap.Function.Should().Be("invoke");
fap.Parameters.Should().HaveCount(2);
fap.Parameters.Should().HaveElementAt(0, "key");
fap.Parameters.Should().HaveElementAt(1, "value");
}
private ChaincodeStub CreateChaincodeStub(
IHandler handler,
string channelId,
string txId,
ChaincodeInput chaincodeInput,
SignedProposal signedProposal
)
{
return(new ChaincodeStub(handler, channelId, txId, chaincodeInput, signedProposal,
new NullLogger <ChaincodeStub>()));
}
public IChaincodeStub Create(
IHandler handler,
string channelId,
string txId,
ChaincodeInput chaincodeInput,
SignedProposal signedProposal
)
{
using (var scope = _serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
return(new ChaincodeStub(handler, channelId, txId, chaincodeInput, signedProposal,
scope.ServiceProvider.GetRequiredService <ILogger <ChaincodeStub> >()));
}
}
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");
}
public ChaincodeStub(
IHandler handler,
string channelId,
string txId,
ChaincodeInput chaincodeInput,
SignedProposal signedProposal,
ILogger <ChaincodeStub> logger
)
{
_handler = handler;
ChannelId = channelId;
TxId = txId;
_logger = logger;
Args = chaincodeInput.Args.Select(entry => entry.ToStringUtf8()).ToList();
DecodedSignedProposal = ValidateSignedProposal(signedProposal);
}
public void Parses_arguments_correctly_when_function_name()
{
var input = new ChaincodeInput();
input.Args.AddRange(new List <ByteString> {
"invoke".ToByteString()
});
var sut = CreateChaincodeStub(null, "ChannelId", "TxId", input, CreateValidSignedProposal());
sut.Args.Should().HaveCount(1);
sut.Args.Should().Contain("invoke");
var fap = sut.GetFunctionAndParameters();
fap.Function.Should().Be("invoke");
fap.Parameters.Should().BeEmpty();
}
// 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);
}
public void TestStreamShutdown()
{
ChaincodeBase cb = new Cb7();
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);
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);
server.Stop();
server = null;
}
public async Task <Response> HandleInvokeChaincode(
string chaincodeName,
IEnumerable <ByteString> args,
string channelId,
string txId
)
{
var chaincodeId = new ChaincodeID {
Name = chaincodeName
};
var inputArgs = new RepeatedField <ByteString>().Concat(args);
var chaincodeInput = new ChaincodeInput();
chaincodeInput.Args.AddRange(inputArgs);
var payload = new ChaincodeSpec
{
ChaincodeId = chaincodeId,
Input = chaincodeInput
};
var response = await CreateMessageAndListen <ChaincodeMessage>(MessageMethod.InvokeChaincode,
ChaincodeMessage.Types.Type.InvokeChaincode, payload, channelId, txId);
if (response.Type == ChaincodeMessage.Types.Type.Completed)
{
return(Response.Parser.ParseFrom(response.Payload));
}
if (response.Type == ChaincodeMessage.Types.Type.Error)
{
throw new Exception(response.Payload.ToStringUtf8());
}
throw new Exception("Something went somewhere horribly wrong");
}
private async Task HandleMessage(ChaincodeMessage message, HandleMessageAction action)
{
ChaincodeMessage nextMessage = null;
ChaincodeInput input = null;
try
{
input = ChaincodeInput.Parser.ParseFrom(message.Payload);
}
catch
{
_logger.LogError(
$"{message.ChannelId}-{message.Txid} Incorrect payload format. Sending ERROR message back to peer");
nextMessage = new ChaincodeMessage
{
Txid = message.Txid,
ChannelId = message.ChannelId,
Type = ChaincodeMessage.Types.Type.Error,
Payload = message.Payload
};
}
if (input == null)
{
await WriteStream.WriteAsync(nextMessage);
return;
}
IChaincodeStub stub = null;
try
{
stub = _chaincodeStubFactory.Create(this, message.ChannelId, message.Txid, input,
message.Proposal);
}
catch (Exception ex)
{
_logger.LogError($"Failed to construct a chaincode stub instance for the INIT message: {ex}");
nextMessage = new ChaincodeMessage
{
Type = ChaincodeMessage.Types.Type.Error,
Payload = ex.ToString().ToByteString(),
Txid = message.Txid,
ChannelId = message.ChannelId
};
}
if (stub == null)
{
await WriteStream.WriteAsync(nextMessage);
return;
}
Response response;
if (action == HandleMessageAction.Init)
{
response = await _chaincode.Init(stub);
}
else
{
response = await _chaincode.Invoke(stub);
}
if (response.Status == 0)
{
var errorMessage = $"[{message.ChannelId}-{message.Txid}] Calling chaincode {action} " +
"has not called success or error";
_logger.LogError(errorMessage);
response = Shim.Error(errorMessage);
}
_logger.LogInformation($"[{message.ChaincodeEvent}]-{message.Txid} Calling chaincode {action}, " +
$"response status {response.Status}");
if (response.Status >= (int)ResponseCodes.Error)
{
_logger.LogError($"[{message.ChannelId}-{message.Txid}] Calling chaincode {action} " +
$"returned error response {response.Message}. " +
"Sending ERROR message back to peer");
nextMessage = new ChaincodeMessage
{
Type = ChaincodeMessage.Types.Type.Error,
Payload = response.Message.ToByteString(),
Txid = message.Txid,
ChannelId = message.ChannelId
};
}
else
{
_logger.LogInformation($"[{message.ChannelId}-{message.Txid}] Calling chaincode {action} " +
"succeeded. Sending COMPLETED message back to peer");
nextMessage = new ChaincodeMessage
{
Type = ChaincodeMessage.Types.Type.Completed,
Payload = response.ToByteString(),
Txid = message.Txid,
ChannelId = message.ChannelId,
ChaincodeEvent = stub.ChaincodeEvent
};
}
await WriteStream.WriteAsync(nextMessage);
}
public static ChaincodeDeploymentSpec CreateDeploymentSpec(ChaincodeSpec.Types.Type ccType, string name, string chaincodePath,
string chaincodeVersion, List <string> args,
byte[] codePackage)
{
Protos.Peer.ChaincodeID chaincodeID = new Protos.Peer.ChaincodeID
{
Name = name,
Version = chaincodeVersion
};
if (chaincodePath != null)
{
chaincodeID.Path = chaincodePath;
}
if (args == null)
{
args = new List <string>();
}
// build chaincodeInput
List <ByteString> argList = args.Select(ByteString.CopyFromUtf8).ToList();
ChaincodeInput chaincodeInput = new ChaincodeInput();
chaincodeInput.Args.AddRange(argList);
// Construct the ChaincodeSpec
ChaincodeSpec chaincodeSpec = new ChaincodeSpec {
ChaincodeId = chaincodeID, Input = chaincodeInput, Type = ccType
};
if (isDebugLevel)
{
StringBuilder sb = new StringBuilder(1000);
sb.Append("ChaincodeDeploymentSpec chaincode cctype: ")
.Append(ccType.ToString())
.Append(", name:")
.Append(chaincodeID.Name)
.Append(", path: ")
.Append(chaincodeID.Path)
.Append(", version: ")
.Append(chaincodeID.Version);
string sep = "";
sb.Append(" args(");
foreach (ByteString x in argList)
{
sb.Append(sep).Append("\"").Append(x.ToStringUtf8().LogString()).Append("\"");
sep = ", ";
}
sb.Append(")");
logger.Debug(sb.ToString());
}
ChaincodeDeploymentSpec spec = new ChaincodeDeploymentSpec {
ChaincodeSpec = chaincodeSpec, ExecEnv = ChaincodeDeploymentSpec.Types.ExecutionEnvironment.Docker
};
if (codePackage != null)
{
spec.CodePackage = ByteString.CopyFrom(codePackage);
}
return(spec);
}
private ChaincodeInvocationSpec CreateChaincodeInvocationSpec(Protos.Peer.ChaincodeID ccodeID, ChaincodeSpec.Types.Type langType)
{
List <ByteString> allArgs = new List <ByteString>();
if (argList != null && argList.Count > 0)
{
// If we already have an argList then the Builder subclasses have already set the arguments
// for chaincodeInput. Accept the list and pass it on to the chaincodeInput builder
// TODO need to clean this logic up so that common protobuf struct builds are in one place
allArgs = argList;
}
else if (request != null)
{
// if argList is empty and we have a Request, build the chaincodeInput args array from the Request args and argbytes lists
allArgs.Add(ByteString.CopyFromUtf8(request.Fcn));
List <string> args = request.Args;
if (args != null && args.Count > 0)
{
foreach (string arg in args)
{
allArgs.Add(ByteString.CopyFromUtf8(arg));
}
}
// TODO currently assume that chaincodeInput args are strings followed by byte[].
// Either agree with Fabric folks that this will always be the case or modify all Builders to expect
// a List of Objects and determine if each list item is a string or a byte array
List <byte[]> argBytes = request.ArgsBytes;
if (argBytes != null && argBytes.Count > 0)
{
foreach (byte[] arg in argBytes)
{
allArgs.Add(ByteString.CopyFrom(arg));
}
}
}
if (IS_DEBUG_LEVEL)
{
StringBuilder logout = new StringBuilder(1000);
logout.Append($"ChaincodeInvocationSpec type: {langType.ToString()}, chaincode name: {ccodeID.Name}, chaincode path: {ccodeID.Path}, chaincode version: {ccodeID.Version}");
string sep = "";
logout.Append(" args(");
foreach (ByteString x in allArgs)
{
logout.Append(sep).Append("\"").Append(x.ToStringUtf8().LogString()).Append("\"");
sep = ", ";
}
logout.Append(")");
logger.Debug(logout.ToString);
}
ChaincodeInput chaincodeInput = new ChaincodeInput();
chaincodeInput.Args.AddRange(allArgs);
ChaincodeSpec chaincodeSpec = new ChaincodeSpec {
Type = langType, ChaincodeId = ccodeID, Input = chaincodeInput
};
return(new ChaincodeInvocationSpec {
ChaincodeSpec = chaincodeSpec
});
}
