public PrivateDataIT()
{
chaincodeID = new ChaincodeID();
chaincodeID.Name = CHAIN_CODE_NAME;
chaincodeID.Version = CHAIN_CODE_VERSION;
chaincodeID.Path = CHAIN_CODE_PATH;
}
public static async Task <Handler> CreateAsync(ChaincodeID chaincodeId, IChaincodeAsync chaincode, CancellationToken token = default(CancellationToken))
{
Handler h = new Handler();
h.chaincode = chaincode;
h.State = CCState.CREATED;
await h.QueueOutboundChaincodeMessageAsync(NewRegisterChaincodeMessage(chaincodeId), token).ConfigureAwait(false);
return(h);
}
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");
}
public async Task <IHandler> Start()
{
var url = ParseUrl(_chaincodeSettings.PeerAddress);
// TODO: TLS Stuff?
var handler = _handlerFactory.Create(url.Host, url.Port);
var chaincodeId = new ChaincodeID {
Name = _chaincodeSettings.ChaincodeIdName
};
_logger.LogInformation("Registering with peer " +
$"{url.Host}:{url.Port} as chaincode " +
$"{_chaincodeSettings.ChaincodeIdName}");
await handler.Chat(new ChaincodeMessage
{
Type = ChaincodeMessage.Types.Type.Register,
Payload = chaincodeId.ToByteString()
});
return(handler);
}
private static ChaincodeMessage NewRegisterChaincodeMessage(ChaincodeID chaincodeId)
{
return(new ChaincodeMessage {
Type = ChaincodeMessage.Types.Type.Register, Payload = chaincodeId.ToByteString()
});
}
[Ignore] //Hostnames reported by service discovery won't work unless you edit hostfile
public void Setup()
{
//Persistence is not part of SDK. Sample file store is for demonstration purposes only!
// MUST be replaced with more robust application implementation (Database, LDAP)
Util.COut("\n\n\nRUNNING: %s.\n", "ServiceDiscoveryIT");
SampleStore sampleStore = new SampleStore(sampleStoreFile);
// SampleUser peerAdmin = sampleStore.getMember("admin", "peerOrg1");
SampleUser user1 = sampleStore.GetMember("user1", "peerOrg1");
HFClient client = HFClient.Create();
testConfig.GetIntegrationTestsSampleOrg("peerOrg1");
client.CryptoSuite = Factory.GetCryptoSuite();
client.UserContext = user1;
Properties properties = testConfig.GetPeerProperties("peer0.org1.example.com");
string protocol = testConfig.IsRunningFabricTLS() ? "grpcs:" : "grpc:";
Properties sdprops = new Properties();
//Create initial discovery peer.
Peer discoveryPeer = client.NewPeer("peer0.org1.example.com", protocol + "//localhost:7051", properties);
Channel foo = client.NewChannel("foo"); //create channel that will be discovered.
foo.AddPeer(discoveryPeer, PeerOptions.CreatePeerOptions().SetPeerRoles(PeerRole.SERVICE_DISCOVERY, PeerRole.LEDGER_QUERY, PeerRole.EVENT_SOURCE, PeerRole.CHAINCODE_QUERY));
// Need to provide client TLS certificate and key files when running mutual tls.
if (testConfig.IsRunningFabricTLS())
{
sdprops.Add("org.hyperledger.fabric.sdk.discovery.default.clientCertFile", "fixture/sdkintegration/e2e-2Orgs/v1.2/crypto-config/peerOrganizations/org1.example.com/users/[email protected]/tls/client.crt".Locate());
sdprops.Add("org.hyperledger.fabric.sdk.discovery.default.clientKeyFile", "fixture/sdkintegration/e2e-2Orgs/v1.2/crypto-config/peerOrganizations/org1.example.com/users/[email protected]/tls/client.key".Locate());
// Need to do host name override for true tls in testing environment
sdprops.Add("org.hyperledger.fabric.sdk.discovery.endpoint.hostnameOverride.localhost:7050", "orderer.example.com");
sdprops.Add("org.hyperledger.fabric.sdk.discovery.endpoint.hostnameOverride.localhost:7051", "peer0.org1.example.com");
sdprops.Add("org.hyperledger.fabric.sdk.discovery.endpoint.hostnameOverride.localhost:7056", "peer1.org1.example.com");
}
else
{
sdprops.Add("org.hyperledger.fabric.sdk.discovery.default.protocol", "grpc:");
}
foo.ServiceDiscoveryProperties = sdprops;
string channel = foo.Serialize();
// Next 3 lines are for testing purposes only!
foo.Shutdown(false);
foo = client.DeSerializeChannel(channel);
foo.Initialize(); // initialize the channel.
List <string> expect = new List <string>()
{
protocol + "//orderer.example.com:7050"
}; //discovered orderer
foreach (Orderer orderer in foo.Orderers)
{
expect.Remove(orderer.Url);
}
Assert.IsTrue(expect.Count == 0);
List <string> discoveredChaincodeNames = foo.GetDiscoveredChaincodeNames();
Assert.IsTrue(discoveredChaincodeNames.Contains(CHAIN_CODE_NAME));
ChaincodeID chaincodeID = new ChaincodeID();
chaincodeID.Name = CHAIN_CODE_NAME;
///////////////
// Send transaction proposal to all peers
TransactionProposalRequest transactionProposalRequest = client.NewTransactionProposalRequest();
transactionProposalRequest.SetChaincodeID(chaincodeID);
transactionProposalRequest.SetChaincodeLanguage(CHAIN_CODE_LANG);
transactionProposalRequest.SetFcn("move");
transactionProposalRequest.SetProposalWaitTime(testConfig.GetProposalWaitTime());
transactionProposalRequest.SetArgs("a", "b", "1");
//Send proposal request discovering the what endorsers (peers) are needed.
List <ProposalResponse> transactionPropResp = foo.SendTransactionProposalToEndorsers(transactionProposalRequest, DiscoveryOptions.CreateDiscoveryOptions().SetEndorsementSelector(ServiceDiscovery.ENDORSEMENT_SELECTION_RANDOM).SetForceDiscovery(true));
Assert.IsFalse(transactionPropResp.Count == 0);
transactionProposalRequest = client.NewTransactionProposalRequest();
transactionProposalRequest.SetChaincodeID(chaincodeID);
transactionProposalRequest.SetChaincodeLanguage(CHAIN_CODE_LANG);
transactionProposalRequest.SetFcn("move");
transactionProposalRequest.SetProposalWaitTime(testConfig.GetProposalWaitTime());
transactionProposalRequest.SetArgs("a", "b", "1");
//Send proposal request discovering the what endorsers (peers) are needed.
transactionPropResp = foo.SendTransactionProposalToEndorsers(transactionProposalRequest, DiscoveryOptions.CreateDiscoveryOptions().IgnoreEndpoints("blah.blah.blah.com:90", "blah.com:80",
// aka peer0.org1.example.com our discovery peer. Lets ignore it in endorsers selection and see if other discovered peer endorses.
"peer0.org1.example.com:7051")
// if chaincode makes additional chaincode calls or uses collections you should add them with setServiceDiscoveryChaincodeInterests
// .setServiceDiscoveryChaincodeInterests(Channel.ServiceDiscoveryChaincodeCalls.createServiceDiscoveryChaincodeCalls("someOtherChaincodeName").addCollections("collection1", "collection2"))
);
Assert.AreEqual(transactionPropResp.Count, 1);
ProposalResponse proposalResponse = transactionPropResp.First();
Peer peer = proposalResponse.Peer;
Assert.AreEqual(protocol + "//peer1.org1.example.com:7056", peer.Url); // not our discovery peer but the discovered one.
string expectedTransactionId = null;
StringBuilder evenTransactionId = new StringBuilder();
foreach (ProposalResponse response in transactionPropResp)
{
expectedTransactionId = response.TransactionID;
if (response.Status != ChaincodeResponse.ChaincodeResponseStatus.SUCCESS || !response.IsVerified)
{
Assert.Fail("Failed status bad endorsement");
}
}
//Send it to the orderer that was discovered.
try
{
TransactionEvent transactionEvent = foo.SendTransaction(transactionPropResp);
evenTransactionId.Length = 0;
evenTransactionId.Append(transactionEvent.TransactionID);
}
catch (TransactionEventException e)
{
TransactionEvent te = e.TransactionEvent;
if (te != null)
{
throw new System.Exception($"Transaction with txid {te.TransactionID} failed. {e.Message}");
}
}
catch (System.Exception e)
{
throw new System.Exception($"Test failed with {e.Message} exception {e}");
}
Assert.AreEqual(expectedTransactionId, evenTransactionId.ToString());
Util.COut("That's all folks!");
}
public static T SetChaincodeID <T>(this T request, ChaincodeID chaincodeid) where T : TransactionRequest
{
request.ChaincodeID = chaincodeid;
return(request);
}
private void QueryChaincodeForExpectedValue(HFClient client, Channel channel, string expect, ChaincodeID chaincdeID)
{
Util.COut("Now query chaincode {0} on channel {1} for the value of b expecting to see: {2}", chaincdeID, channel.Name, expect);
List <ProposalResponse> queryProposals;
QueryByChaincodeRequest queryByChaincodeRequest = client.NewQueryProposalRequest();
queryByChaincodeRequest.SetFcn("query");
queryByChaincodeRequest.ChaincodeID = chaincdeID;
Dictionary <string, byte[]> tmap = new Dictionary <string, byte[]>();
tmap["B"] = "b".ToBytes(); // test using bytes as args. End2end uses Strings.
queryByChaincodeRequest.TransientMap = tmap;
queryProposals = channel.QueryByChaincode(queryByChaincodeRequest);
foreach (ProposalResponse proposalResponse in queryProposals)
{
if (!proposalResponse.IsVerified || proposalResponse.Status != ChaincodeResponse.ChaincodeResponseStatus.SUCCESS)
{
Assert.Fail($"Failed query proposal from peer {proposalResponse.Peer.Name} status: {proposalResponse.Status}. Messages: {proposalResponse.Message}. Was verified : {proposalResponse.IsVerified}");
}
else
{
string payload = proposalResponse.ProtoProposalResponse.Response.Payload.ToStringUtf8();
Util.COut("Query payload of b from peer {0} returned {1}", proposalResponse.Peer.Name, payload);
Assert.AreEqual(expect, payload, $"Failed compare on channel {channel.Name} chaincode id {chaincdeID} expected value:'{expect}', but got:'{payload}'");
}
}
}
// ReSharper disable once UnusedMethodReturnValue.Local
private TransactionEvent MoveAmount(HFClient client, Channel channel, ChaincodeID chaincdeID, string moveAmount, IUser user)
{
List <ProposalResponse> successful = new List <ProposalResponse>();
List <ProposalResponse> failed = new List <ProposalResponse>();
///////////////
// Send transaction proposal to all peers
TransactionProposalRequest transactionProposalRequest = client.NewTransactionProposalRequest();
transactionProposalRequest.SetChaincodeID(chaincdeID);
transactionProposalRequest.SetFcn("move");
// Private data needs to be sent via Transient field to prevent identifiable
//information being sent to the orderer.
Dictionary <string, byte[]> transientMap = new Dictionary <string, byte[]>();
transientMap["A"] = "a".ToBytes(); //test using bytes .. end2end uses Strings.
transientMap["B"] = "b".ToBytes();
transientMap["moveAmount"] = moveAmount.ToBytes();
transactionProposalRequest.TransientMap = transientMap;
transactionProposalRequest.SetProposalWaitTime(testConfig.GetProposalWaitTime());
if (user != null)
{
// specific user use that
transactionProposalRequest.SetUserContext(user);
}
Util.COut("sending transaction proposal to all peers with arguments: move(a,b,%s)", moveAmount);
List <ProposalResponse> invokePropResp = channel.SendTransactionProposal(transactionProposalRequest);
foreach (ProposalResponse response in invokePropResp)
{
if (response.Status == ChaincodeResponse.ChaincodeResponseStatus.SUCCESS)
{
Util.COut("Successful transaction proposal response Txid: %s from peer %s", response.TransactionID, response.Peer.Name);
successful.Add(response);
}
else
{
failed.Add(response);
}
}
Util.COut("Received %d transaction proposal responses for moveAmount. Successful+verified: %d . Failed: %d", invokePropResp.Count, successful.Count, failed.Count);
if (failed.Count > 0)
{
ProposalResponse firstTransactionProposalResponse = failed.First();
throw new ProposalException($"Not enough endorsers for invoke(move a,b,{moveAmount}):{firstTransactionProposalResponse.Status} endorser error:{firstTransactionProposalResponse.Message}. Was verified:{firstTransactionProposalResponse.IsVerified}");
}
Util.COut("Successfully received transaction proposal responses.");
////////////////////////////
// Send transaction to orderer
Util.COut("Sending chaincode transaction(move a,b,%s) to orderer.", moveAmount);
if (user != null)
{
return(channel.SendTransaction(successful, user));
}
return(channel.SendTransaction(successful));
}
// ReSharper disable once UnusedMethodReturnValue.Local
private TransactionEvent SetAmount(HFClient client, Channel channel, ChaincodeID chaincdeID, int delta, IUser user)
{
List <ProposalResponse> successful = new List <ProposalResponse>();
List <ProposalResponse> failed = new List <ProposalResponse>();
///////////////
// Send transaction proposal to all peers
TransactionProposalRequest transactionProposalRequest = client.NewTransactionProposalRequest();
transactionProposalRequest.SetChaincodeID(chaincdeID);
transactionProposalRequest.SetFcn("set");
Dictionary <string, byte[]> transientMap = new Dictionary <string, byte[]>();
transientMap["A"] = "a".ToBytes(); // test using bytes as args. End2end uses Strings.
transientMap["AVal"] = "500".ToBytes();
transientMap["B"] = "b".ToBytes();
string arg3 = "" + (200 + delta);
transientMap["BVal"] = arg3.ToBytes();
transactionProposalRequest.TransientMap = transientMap;
transactionProposalRequest.SetProposalWaitTime(testConfig.GetProposalWaitTime());
if (user != null)
{
// specific user use that
transactionProposalRequest.SetUserContext(user);
}
List <ProposalResponse> invokePropResp = channel.SendTransactionProposal(transactionProposalRequest);
foreach (ProposalResponse response in invokePropResp)
{
if (response.Status == ChaincodeResponse.ChaincodeResponseStatus.SUCCESS)
{
Util.COut("Successful transaction proposal response Txid: %s from peer %s", response.TransactionID, response.Peer.Name);
successful.Add(response);
}
else
{
failed.Add(response);
}
}
Util.COut("Received %d transaction proposal responses for setAmount. Successful+verified: %d . Failed: %d", invokePropResp.Count, successful.Count, failed.Count);
if (failed.Count > 0)
{
ProposalResponse firstTransactionProposalResponse = failed.First();
throw new ProposalException($"Not enough endorsers for set(move a,b,{0}):{firstTransactionProposalResponse.Status} endorser error:{firstTransactionProposalResponse.Message}. Was verified:{firstTransactionProposalResponse.IsVerified}");
}
Util.COut("Successfully received transaction proposal responses for setAmount. Now sending to orderer.");
////////////////////////////
// Send transaction to orderer
if (user != null)
{
return(channel.SendTransaction(successful, user));
}
return(channel.SendTransaction(successful));
}
public void TestHandlerStates()
{
CancellationToken token = default(CancellationToken);
ChaincodeBaseAsync cb = new EmptyChaincode();
ChaincodeID chaincodeId = new ChaincodeID {
Name = "mycc"
};
Handler handler = Handler.CreateAsync(chaincodeId, cb).RunAndUnwrap();
ChaincodeMessage msgReg = new ChaincodeMessage {
Type = ChaincodeMessage.Types.Type.Registered
};
// Correct message
handler.OnChaincodeMessageAsync(msgReg, token).RunAndUnwrap();
Assert.AreEqual(CCState.ESTABLISHED, handler.State, "Not correct handler state");
ChaincodeMessage msgReady = new ChaincodeMessage {
Type = ChaincodeMessage.Types.Type.Ready
};
// Correct message
handler.OnChaincodeMessageAsync(msgReady, token).RunAndUnwrap();
Assert.AreEqual(CCState.READY, handler.State, "Not correct handler state");
handler = Handler.CreateAsync(chaincodeId, cb).RunAndUnwrap();
// Incorrect message
handler.OnChaincodeMessageAsync(msgReady, token).RunAndUnwrap();
Assert.AreEqual(CCState.CREATED, handler.State, "Not correct handler state");
// Correct message
handler.OnChaincodeMessageAsync(msgReg, token).RunAndUnwrap();
Assert.AreEqual(CCState.ESTABLISHED, handler.State, "Not correct handler state");
// Incorrect message
handler.OnChaincodeMessageAsync(msgReg, token).RunAndUnwrap();
Assert.AreEqual(CCState.ESTABLISHED, handler.State, "Not correct handler state");
handler.OnChaincodeMessageAsync(msgReady, token).RunAndUnwrap();
Assert.AreEqual(CCState.READY, handler.State, "Not correct handler state");
// Unrelated message, do nothing
ChaincodeMessage unkonwnMessage = new ChaincodeMessage {
Type = ChaincodeMessage.Types.Type.PutState, ChannelId = "mychannel", Txid = "q", Payload = ByteString.CopyFromUtf8("")
};
handler.OnChaincodeMessageAsync(unkonwnMessage, token).RunAndUnwrap();
Assert.AreEqual(CCState.READY, handler.State, "Not correct handler state");
// KEEPALIVE message, do nothing
ChaincodeMessage keepAliveMessage = new ChaincodeMessage {
Type = ChaincodeMessage.Types.Type.Keepalive, ChannelId = "mychannel", Txid = "q", Payload = ByteString.CopyFromUtf8("")
};
handler.OnChaincodeMessageAsync(keepAliveMessage, token).RunAndUnwrap();
Assert.AreEqual(CCState.READY, handler.State, "Not correct handler state");
ChaincodeMessage errorMsg = new ChaincodeMessage {
Type = ChaincodeMessage.Types.Type.Error, ChannelId = "mychannel", Txid = "q", Payload = ByteString.CopyFromUtf8("")
};
// Error message, except exception, no open communication
try
{
handler.OnChaincodeMessageAsync(errorMsg, token).RunAndUnwrap();
Assert.Fail("Expecting InvalidOperationException");
}
catch (InvalidOperationException)
{
//Ignore
}
Assert.AreEqual(CCState.READY, handler.State, "Not correct handler state");
}