func GenerateUUID(t *testing.T) string {
uuid, err := util.GenerateUUID()
if err != nil {
t.Fatalf("Error generating UUI - Error: %s\n %s", err, getCallerInfo())
}
return uuid
}
// Invoke or query a chaincode.
func invoke(ctx context.Context, spec *pb.ChaincodeSpec, typ pb.Transaction_Type) (string, []byte, error) {
chaincodeInvocationSpec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec}
// Now create the Transactions message and send to Peer.
uuid := util.GenerateUUID()
transaction, err := pb.NewChaincodeExecute(chaincodeInvocationSpec, uuid, typ)
if err != nil {
return uuid, nil, fmt.Errorf("Error invoking chaincode: %s ", err)
}
var retval []byte
var execErr error
if typ == pb.Transaction_CHAINCODE_QUERY {
retval, execErr = Execute(ctx, GetChain(DefaultChain), transaction)
} else {
ledger, _ := ledger.GetLedger()
ledger.BeginTxBatch("1")
retval, execErr = Execute(ctx, GetChain(DefaultChain), transaction)
if err != nil {
return uuid, nil, fmt.Errorf("Error invoking chaincode: %s ", err)
}
ledger.CommitTxBatch("1", []*pb.Transaction{transaction}, nil, nil)
}
return uuid, retval, execErr
}
func generateUUID(t *testing.T) string {
uuid, err := util.GenerateUUID()
if err != nil {
t.Fatalf("Error generating UUID: %s", err)
}
return uuid
}
func (d *Devops) invokeOrQuery(ctx context.Context, chaincodeInvocationSpec *pb.ChaincodeInvocationSpec, invoke bool) (*pb.Response, error) {
if chaincodeInvocationSpec.ChaincodeSpec.ChaincodeID.Name == "" {
return nil, fmt.Errorf("name not given for invoke/query")
}
// Now create the Transactions message and send to Peer.
uuid, uuidErr := util.GenerateUUID()
if uuidErr != nil {
devopsLogger.Error(fmt.Sprintf("Error generating UUID: %s", uuidErr))
return nil, uuidErr
}
var transaction *pb.Transaction
var err error
transaction, err = d.createExecTx(chaincodeInvocationSpec, uuid, invoke)
if err != nil {
return nil, err
}
if devopsLogger.IsEnabledFor(logging.DEBUG) {
devopsLogger.Debug("Sending invocation transaction (%s) to validator", transaction.Uuid)
}
resp := d.coord.ExecuteTransaction(transaction)
if resp.Status == pb.Response_FAILURE {
err = fmt.Errorf(string(resp.Msg))
}
return resp, err
}
func (node *nodeImpl) getTLSCertificateFromTLSCA(id, affiliation string) (interface{}, []byte, error) {
node.log.Info("getTLSCertificate...")
priv, err := utils.NewECDSAKey()
if err != nil {
node.log.Error("Failed generating key: %s", err)
return nil, nil, err
}
uuid, err := util.GenerateUUID()
if err != nil {
node.log.Error("Failed generating uuid: %s", err)
return nil, nil, err
}
// Prepare the request
pubraw, _ := x509.MarshalPKIXPublicKey(&priv.PublicKey)
now := time.Now()
timestamp := google_protobuf.Timestamp{int64(now.Second()), int32(now.Nanosecond())}
req := &obcca.TLSCertCreateReq{
×tamp,
&obcca.Identity{Id: id + "-" + uuid},
&obcca.Password{Pw: ""},
&obcca.PublicKey{
Type: obcca.CryptoType_ECDSA,
Key: pubraw,
}, nil}
rawreq, _ := proto.Marshal(req)
r, s, err := ecdsa.Sign(rand.Reader, priv, utils.Hash(rawreq))
if err != nil {
panic(err)
}
R, _ := r.MarshalText()
S, _ := s.MarshalText()
req.Sig = &obcca.Signature{obcca.CryptoType_ECDSA, R, S}
pbCert, err := node.callTLSCACreateCertificate(context.Background(), req)
if err != nil {
node.log.Error("Failed requesting tls certificate: %s", err)
return nil, nil, err
}
node.log.Info("Verifing tls certificate...")
tlsCert, err := utils.DERToX509Certificate(pbCert.Cert)
certPK := tlsCert.PublicKey.(*ecdsa.PublicKey)
utils.VerifySignCapability(priv, certPK)
node.log.Info("Verifing tls certificate...done!")
return priv, pbCert.Cert, nil
}
func createConfidentialECertHDeployTransaction(t *testing.T) (*obc.Transaction, *obc.Transaction, error) {
uuid, err := util.GenerateUUID()
if err != nil {
return nil, nil, err
}
cds := &obc.ChaincodeDeploymentSpec{
ChaincodeSpec: &obc.ChaincodeSpec{
Type: obc.ChaincodeSpec_GOLANG,
ChaincodeID: &obc.ChaincodeID{Path: "Contract001"},
CtorMsg: nil,
ConfidentialityLevel: obc.ConfidentialityLevel_CONFIDENTIAL,
},
EffectiveDate: nil,
CodePackage: nil,
}
otx, err := obc.NewChaincodeDeployTransaction(cds, uuid)
if err != nil {
return nil, nil, err
}
handler, err := deployer.GetEnrollmentCertificateHandler()
if err != nil {
return nil, nil, err
}
txHandler, err := handler.GetTransactionHandler()
if err != nil {
return nil, nil, err
}
tx, err := txHandler.NewChaincodeDeployTransaction(cds, uuid)
// Check binding consistency
binding, _ := txHandler.GetBinding()
if !reflect.DeepEqual(binding, utils.Hash(append(handler.GetCertificate(), tx.Nonce...))) {
t.Fatal("Binding is malformed!")
}
// Check confidentiality level
if tx.ConfidentialityLevel != cds.ChaincodeSpec.ConfidentialityLevel {
t.Fatal("Failed setting confidentiality level")
}
// Check metadata
if !reflect.DeepEqual(cds.ChaincodeSpec.Metadata, tx.Metadata) {
t.Fatal("Failed copying metadata")
}
return otx, tx, err
}
func (d *Devops) invokeOrQuery(ctx context.Context, chaincodeInvocationSpec *pb.ChaincodeInvocationSpec, invoke bool) (*pb.Response, error) {
if chaincodeInvocationSpec.ChaincodeSpec.ChaincodeID.Name == "" {
return nil, fmt.Errorf("name not given for invoke/query")
}
// Now create the Transactions message and send to Peer.
uuid, uuidErr := util.GenerateUUID()
if uuidErr != nil {
devopsLogger.Error(fmt.Sprintf("Error generating UUID: %s", uuidErr))
return nil, uuidErr
}
var transaction *pb.Transaction
var err error
var sec crypto.Client
if viper.GetBool("security.enabled") {
if devopsLogger.IsEnabledFor(logging.DEBUG) {
devopsLogger.Debug("Initializing secure devops using context %s", chaincodeInvocationSpec.ChaincodeSpec.SecureContext)
}
sec, err = crypto.InitClient(chaincodeInvocationSpec.ChaincodeSpec.SecureContext, nil)
defer crypto.CloseClient(sec)
// remove the security context since we are no longer need it down stream
chaincodeInvocationSpec.ChaincodeSpec.SecureContext = ""
if nil != err {
return nil, err
}
}
transaction, err = d.createExecTx(chaincodeInvocationSpec, uuid, invoke, sec)
if err != nil {
return nil, err
}
if devopsLogger.IsEnabledFor(logging.DEBUG) {
devopsLogger.Debug("Sending invocation transaction (%s) to validator", transaction.Uuid)
}
resp := d.coord.ExecuteTransaction(transaction)
if resp.Status == pb.Response_FAILURE {
err = fmt.Errorf(string(resp.Msg))
} else {
if !invoke && nil != sec && viper.GetBool("security.privacy") {
if resp.Msg, err = sec.DecryptQueryResult(transaction, resp.Msg); nil != err {
devopsLogger.Debug("Failed decrypting query transaction result %s", string(resp.Msg[:]))
//resp = &pb.Response{Status: pb.Response_FAILURE, Msg: []byte(err.Error())}
}
}
}
return resp, err
}
func createConfidentialTCertHQueryTransaction(t *testing.T) (*obc.Transaction, *obc.Transaction, error) {
uuid, err := util.GenerateUUID()
if err != nil {
return nil, nil, err
}
cis := &obc.ChaincodeInvocationSpec{
ChaincodeSpec: &obc.ChaincodeSpec{
Type: obc.ChaincodeSpec_GOLANG,
ChaincodeID: &obc.ChaincodeID{Path: "Contract001"},
CtorMsg: nil,
ConfidentialityLevel: obc.ConfidentialityLevel_CONFIDENTIAL,
},
}
otx, err := obc.NewChaincodeExecute(cis, uuid, obc.Transaction_CHAINCODE_QUERY)
if err != nil {
return nil, nil, err
}
handler, err := invoker.GetTCertificateHandlerNext()
if err != nil {
return nil, nil, err
}
txHandler, err := handler.GetTransactionHandler()
if err != nil {
return nil, nil, err
}
tx, err := txHandler.NewChaincodeQuery(cis, uuid)
// Check binding consistency
binding, _ := txHandler.GetBinding()
if !reflect.DeepEqual(binding, utils.Hash(append(handler.GetCertificate(), tx.Nonce...))) {
t.Fatal("Binding is malformed!")
}
// Check confidentiality level
if tx.ConfidentialityLevel != cis.ChaincodeSpec.ConfidentialityLevel {
t.Fatal("Failed setting confidentiality level")
}
// Check metadata
if !reflect.DeepEqual(cis.ChaincodeSpec.Metadata, tx.Metadata) {
t.Fatal("Failed copying metadata")
}
return otx, tx, err
}
func createPublicQueryTransaction() (*pb.Transaction, error) {
uuid, err := util.GenerateUUID()
if err != nil {
return nil, err
}
tx, err := invoker.NewChaincodeQuery(
&pb.ChaincodeInvocationSpec{
ChaincodeSpec: &pb.ChaincodeSpec{
Type: pb.ChaincodeSpec_GOLANG,
ChaincodeID: &pb.ChaincodeID{Path: "Contract001"},
CtorMsg: nil,
},
},
uuid,
)
return tx, err
}
func TestParallelInitClose(t *testing.T) {
// TODO: complete this
conf := utils.NodeConfiguration{Type: "client", Name: "userthread"}
RegisterClient(conf.Name, nil, conf.GetEnrollmentID(), conf.GetEnrollmentPWD())
done := make(chan bool)
n := 10
for i := 0; i < n; i++ {
go func() {
for i := 0; i < 5; i++ {
client, err := InitClient(conf.Name, nil)
if err != nil {
t.Log("Init failed")
}
cis := &obc.ChaincodeInvocationSpec{
ChaincodeSpec: &obc.ChaincodeSpec{
Type: obc.ChaincodeSpec_GOLANG,
ChaincodeID: &obc.ChaincodeID{Path: "Contract001"},
CtorMsg: nil,
ConfidentialityLevel: obc.ConfidentialityLevel_CONFIDENTIAL,
},
}
for i := 0; i < 20; i++ {
uuid := util.GenerateUUID()
client.NewChaincodeExecute(cis, uuid)
}
err = CloseClient(client)
if err != nil {
t.Log("Close failed")
}
}
done <- true
}()
}
for i := 0; i < n; i++ {
log.Info("Waiting")
<-done
log.Info("+1")
}
log.Info("Test Finished!")
//
}
// Invoke or query a chaincode.
func invoke(ctx context.Context, spec *pb.ChaincodeSpec, typ pb.Transaction_Type) (string, []byte, error) {
chaincodeInvocationSpec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec}
// Now create the Transactions message and send to Peer.
uuid, uuidErr := util.GenerateUUID()
if uuidErr != nil {
return "", nil, uuidErr
}
transaction, err := pb.NewChaincodeExecute(chaincodeInvocationSpec, uuid, typ)
if err != nil {
return uuid, nil, fmt.Errorf("Error deploying chaincode: %s ", err)
}
retval, err := Execute(ctx, GetChain(DefaultChain), transaction, nil)
return uuid, retval, err
}
func createConfidentialQueryTransaction() (*pb.Transaction, error) {
uuid, err := util.GenerateUUID()
if err != nil {
return nil, err
}
tx, err := invoker.NewChaincodeQuery(
&pb.ChaincodeInvocationSpec{
ChaincodeSpec: &pb.ChaincodeSpec{
Type: pb.ChaincodeSpec_GOLANG,
ChaincodeID: &pb.ChaincodeID{Path: "Contract001"},
CtorMsg: nil,
ConfidentialityLevel: pb.ConfidentialityLevel_CONFIDENTIAL,
},
},
uuid,
)
return tx, err
}
func createPublicQueryTransaction(t *testing.T) (*obc.Transaction, *obc.Transaction, error) {
uuid := util.GenerateUUID()
cis := &obc.ChaincodeInvocationSpec{
ChaincodeSpec: &obc.ChaincodeSpec{
Type: obc.ChaincodeSpec_GOLANG,
ChaincodeID: &obc.ChaincodeID{Path: "Contract001"},
CtorMsg: nil,
ConfidentialityLevel: obc.ConfidentialityLevel_PUBLIC,
},
}
otx, err := obc.NewChaincodeExecute(cis, uuid, obc.Transaction_CHAINCODE_QUERY)
if err != nil {
return nil, nil, err
}
tx, err := invoker.NewChaincodeQuery(cis, uuid)
return otx, tx, err
}
func BenchmarkTransactionCreation(b *testing.B) {
b.StopTimer()
b.ResetTimer()
cis := &obc.ChaincodeInvocationSpec{
ChaincodeSpec: &obc.ChaincodeSpec{
Type: obc.ChaincodeSpec_GOLANG,
ChaincodeID: &obc.ChaincodeID{Path: "Contract001"},
CtorMsg: nil,
ConfidentialityLevel: obc.ConfidentialityLevel_CONFIDENTIAL,
},
}
invoker.GetTCertificateHandlerNext()
for i := 0; i < b.N; i++ {
uuid := util.GenerateUUID()
b.StartTimer()
invoker.NewChaincodeExecute(cis, uuid)
b.StopTimer()
}
}
func createPublicDeployTransaction() (*pb.Transaction, error) {
uuid, err := util.GenerateUUID()
if err != nil {
return nil, err
}
tx, err := deployer.NewChaincodeDeployTransaction(
&pb.ChaincodeDeploymentSpec{
ChaincodeSpec: &pb.ChaincodeSpec{
Type: pb.ChaincodeSpec_GOLANG,
ChaincodeID: &pb.ChaincodeID{Path: "Contract001"},
CtorMsg: nil,
},
EffectiveDate: nil,
CodePackage: nil,
},
uuid,
)
return tx, err
}
func createPublicDeployTransaction(t *testing.T) (*obc.Transaction, *obc.Transaction, error) {
uuid := util.GenerateUUID()
cds := &obc.ChaincodeDeploymentSpec{
ChaincodeSpec: &obc.ChaincodeSpec{
Type: obc.ChaincodeSpec_GOLANG,
ChaincodeID: &obc.ChaincodeID{Path: "Contract001"},
CtorMsg: nil,
ConfidentialityLevel: obc.ConfidentialityLevel_PUBLIC,
},
EffectiveDate: nil,
CodePackage: nil,
}
otx, err := obc.NewChaincodeDeployTransaction(cds, uuid)
if err != nil {
return nil, nil, err
}
tx, err := deployer.NewChaincodeDeployTransaction(cds, uuid)
return otx, tx, err
}
func createConfidentialExecuteTransaction(t *testing.T) (*obc.Transaction, *obc.Transaction, error) {
uuid, err := util.GenerateUUID()
if err != nil {
return nil, nil, err
}
cis := &obc.ChaincodeInvocationSpec{
ChaincodeSpec: &obc.ChaincodeSpec{
Type: obc.ChaincodeSpec_GOLANG,
ChaincodeID: &obc.ChaincodeID{Path: "Contract001"},
CtorMsg: nil,
ConfidentialityLevel: obc.ConfidentialityLevel_CONFIDENTIAL,
},
}
otx, err := obc.NewChaincodeExecute(cis, uuid, obc.Transaction_CHAINCODE_EXECUTE)
if err != nil {
return nil, nil, err
}
tx, err := invoker.NewChaincodeExecute(cis, uuid)
return otx, tx, err
}
func buildTestTx() (*protos.Transaction, string) {
uuid, _ := util.GenerateUUID()
return protos.NewTransaction(protos.ChaincodeID{Path: "testUrl"}, uuid, "anyfunction", []string{"param1, param2"}), uuid
}
func constructDummyTx(tb testing.TB) *protos.Transaction {
uuid := util.GenerateUUID()
tx, err := protos.NewTransaction(protos.ChaincodeID{Path: "dummyChaincodeId"}, uuid, "dummyFunction", []string{"dummyParamValue1, dummyParamValue2"})
testutil.AssertNil(tb, err)
return tx
}
func buildTestTx(t *testing.T) (*protos.Transaction, string) {
uuid, _ := util.GenerateUUID()
tx, err := protos.NewTransaction(protos.ChaincodeID{Path: "testUrl"}, uuid, "anyfunction", []string{"param1, param2"})
testutil.AssertNil(t, err)
return tx, uuid
}
func generateUUID(t *testing.T) string {
return util.GenerateUUID()
}
func requestTLSCertificate(t *testing.T) {
var opts []grpc.DialOption
creds, err := credentials.NewClientTLSFromFile(viper.GetString("server.tls.certfile"), "tlsca")
if err != nil {
t.Logf("Failed creating credentials for TLS-CA client: %s", err)
t.Fail()
}
opts = append(opts, grpc.WithTransportCredentials(creds))
sockP, err := grpc.Dial(viper.GetString("peer.pki.tlsca.paddr"), opts...)
if err != nil {
t.Logf("Failed dialing in: %s", err)
t.Fail()
}
defer sockP.Close()
tlscaP := obcca.NewTLSCAPClient(sockP)
// Prepare the request
id := "peer"
priv, err := utils.NewECDSAKey()
if err != nil {
t.Logf("Failed generating key: %s", err)
t.Fail()
}
uuid, err := util.GenerateUUID()
if err != nil {
t.Logf("Failed generating uuid: %s", err)
t.Fail()
}
pubraw, _ := x509.MarshalPKIXPublicKey(&priv.PublicKey)
now := time.Now()
timestamp := google_protobuf.Timestamp{int64(now.Second()), int32(now.Nanosecond())}
req := &obcca.TLSCertCreateReq{
×tamp,
&obcca.Identity{Id: id + "-" + uuid},
&obcca.PublicKey{
Type: obcca.CryptoType_ECDSA,
Key: pubraw,
}, nil}
rawreq, _ := proto.Marshal(req)
r, s, err := ecdsa.Sign(rand.Reader, priv, utils.Hash(rawreq))
if err != nil {
t.Logf("Failed signing the request: %s", err)
t.Fail()
}
R, _ := r.MarshalText()
S, _ := s.MarshalText()
req.Sig = &obcca.Signature{obcca.CryptoType_ECDSA, R, S}
resp, err := tlscaP.CreateCertificate(context.Background(), req)
if err != nil {
t.Logf("Failed requesting tls certificate: %s", err)
t.Fail()
}
storePrivateKeyInClear("tls_peer.priv", priv, t)
storeCert("tls_peer.cert", resp.Cert.Cert, t)
storeCert("tls_peer.ca", resp.RootCert.Cert, t)
}
func GenerateUUID(t *testing.T) string {
uuid := util.GenerateUUID()
return uuid
}
