Use Fabric Gateway client API in high-throughput (#1338)

The high-throughput sample used the deprecated Go SDK. This change
updates the sample to use the currently supported Fabric Gateway client
API and adds some automated testing to ensure the sample works
correctly.

Signed-off-by: Mark S. Lewis <Mark.S.Lewis@outlook.com>

Author: bestbeforetoday

.github/workflows/test-high-throughput.yaml

@@ -0,0 +1,44 @@
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+name: Test High Throughput
+run-name: ${{ github.actor }} is running the High Throughput tests
+
+on:
+  workflow_dispatch:
+  push:
+    branches: ["main", "release-2.5"]
+  pull_request:
+    branches: ["main", "release-2.5"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  basic:
+    runs-on: ${{ github.repository == 'hyperledger/fabric-samples' && 'fabric-ubuntu-22.04' || 'ubuntu-22.04' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up test network runtime
+        uses: ./.github/actions/test-network-setup
+
+      - name: Start Fabric
+        working-directory: high-throughput
+        run: ./startFabric.sh
+
+      - name: Test High Throughput
+        working-directory: high-throughput/application-go
+        run: |
+          go run . manyUpdates testvar1 100 +
+          go run . prune testvar1
+          go run . get testvar1
+          go run . update testvar2 100 +
+          go run . manyUpdatesTraditional testvar2 100 +
+          go run . delete testvar2
+
+      - name: Stop Fabric
+        working-directory: high-throughput
+        run: ./networkDown.sh

high-throughput/README.md

@@ -7,6 +7,7 @@
 # High-Throughput Network
 
 ## Purpose
+
 This network is used to understand how to properly design the chaincode data model when handling thousands of transactions per second which all
 update the same asset in the ledger. A naive implementation would use a single key to represent the data for the asset, and the chaincode would
 then attempt to update this key every time a transaction involving it comes in. However, when many transactions all come in at once, in the time
@@ -17,6 +18,7 @@ which are aggregated when the value must be retrieved. In this way, no single ro
 is considered.
 
 ## Use Case
+
 The primary use case for this chaincode data model design is for applications in which a particular asset has an associated amount that is
 frequently added to or removed from. For example, with a bank or credit card account, money is either paid to or paid out of it, and the amount
 of money in the account is the result of all of these additions and subtractions aggregated together. A typical person's bank account may not be
@@ -94,18 +96,21 @@ and assumed to be correct and at minimal risk to either company simply due to Am
 must be verified before approval and admittance to the chain.
 
 ## How
+
 This sample provides the chaincode and scripts required to run a high-throughput application on the Fabric test network.
 
 ### Start the network
 
 You can use the `startFabric.sh` script to create an instance of the Fabric test network with a single channel named `mychannel`. The script then deploys the `high-throughput` chaincode to the channel by installing it on the test network peers and committing the chaincode definition to the channel.
 
 Change back into the `high-throughput` directory in `fabic-samples`. Start the network and deploy the chaincode by issuing the following command:
+
 ```
 ./startFabric.sh
 ```
 
 If successful, you will see messages of the Fabric test network being created and the chaincode being deployed, followed by the execution time of the script:
+
 ```
 Total setup execution time : 81 secs ...
 ```
@@ -115,60 +120,71 @@ The `high-throughput` chaincode is now ready to receive invocations.
 ### Invoke the chaincode
 
 You can invoke the `high-througput` chaincode using a Go application in the `application-go` folder. The Go application will allow us to submit many transactions to the network concurrently. Navigate to the application:
+
 ```
 cd application-go
 ```
 
 #### Update
-The format for update is: `go run app.go update name value operation` where `name` is the name of the variable to update, `value` is the value to add to the variable, and `operation` is either `+` or `-` depending on what type of operation you'd like to add to the variable.
 
-Example: `go run app.go update myvar 100 +`
+The format for update is: `go run . update name value operation` where `name` is the name of the variable to update, `value` is the value to add to the variable, and `operation` is either `+` or `-` depending on what type of operation you'd like to add to the variable.
+
+Example: `go run . update myvar 100 +`
 
 #### Query
-You can query the value of a variable by running `go run app.go get name` where `name` is the name of the variable to get.
 
-Example: `go run app.go get myvar`
+You can query the value of a variable by running `go run . get name` where `name` is the name of the variable to get.
+
+Example: `go run . get myvar`
 
 #### Prune
+
 Pruning takes all the deltas generated for a variable and combines them all into a single row, deleting all previous rows. This helps cleanup the ledger when many updates have been performed.
 
-The format for pruning is: `go run app.go prune name` where `name` is the name of the variable to prune.
+The format for pruning is: `go run . prune name` where `name` is the name of the variable to prune.
 
-Example: `go run app.go prune myvar`
+Example: `go run . prune myvar`
 
 #### Delete
-The format for delete is: `go run app.go delete name` where `name` is the name of the variable to delete.
 
-Example: `go run app.go delete myvar`
+The format for delete is: `go run . delete name` where `name` is the name of the variable to delete.
+
+Example: `go run . delete myvar`
 
 ### Test the Network
 
-The application provides two methods that demonstrate the advantages of this system by submitting many concurrent transactions to the smart contract: `manyUpdates` and `manyUpdatesTraditional`. The first function accepts the same arguments as `update-invoke.sh` but runs the invocation 1000 times in parallel. The final value, therefore, should be the given update value * 1000.
+The application provides two methods that demonstrate the advantages of this system by submitting many concurrent transactions to the smart contract: `manyUpdates` and `manyUpdatesTraditional`. The first function accepts the same arguments as `update-invoke.sh` but runs the invocation 1000 times in parallel. The final value, therefore, should be the given update value \* 1000.
 
 The second function, `manyUpdatesTraditional`, submits 1000 transactions that attempt to update the same key in the world state 1000 times.
 
 Run the following command to create and update `testvar1` a 1000 times:
+
 ```
-go run app.go manyUpdates testvar1 100 +
+go run . manyUpdates testvar1 100 +
 ```
 
 The application will query the variable after submitting the transaction. The result should be `100000`.
 
 We will now see what happens when you try to run 1000 concurrent updates using a traditional transaction. Run the following command to create a variable named `testvar2`:
+
 ```
-go run app.go update testvar2 100 +
+go run . update testvar2 100 +
 ```
+
 The variable will have a value of 100:
+
 ```
 2020/10/27 18:01:45 Value of variable testvar2 :  100
 ```
 
 Now lets try to update `testvar2` 1000 times in parallel:
+
 ```
-go run app.go manyUpdatesTraditional testvar2 100 +
+go run . manyUpdatesTraditional testvar2 100 +
 ```
 
 When the program ends, you may see that none of the updates succeeded.
+
 ```
 2020/10/27 18:03:15 Final value of variable testvar2 :  100
 ```
@@ -177,7 +193,6 @@ The transactions failed because multiple transactions in each block updated the
 
 You can can examine the peer logs to view the messages generated by the rejected blocks:
 
-
 ```
 docker logs peer0.org1.example.com
 ```

high-throughput/application-go/app.go

@@ -9,7 +9,10 @@ package main
 import (
 	"log"
 	"os"
+	"time"
 
+	"github.com/hyperledger/fabric-gateway/pkg/client"
+	"github.com/hyperledger/fabric-gateway/pkg/hash"
 	f "github.com/hyperledger/fabric-samples/high-throughput/application-go/functions"
 )
 
@@ -32,36 +35,56 @@ func main() {
 		sign = os.Args[4]
 	}
 
+	clientConnection := newGrpcConnection()
+	defer clientConnection.Close()
+
+	gateway, err := client.Connect(
+		newIdentity(),
+		client.WithSign(newSign()),
+		client.WithHash(hash.SHA256),
+		client.WithClientConnection(clientConnection),
+		client.WithEvaluateTimeout(5*time.Second),
+		client.WithEndorseTimeout(15*time.Second),
+		client.WithSubmitTimeout(5*time.Second),
+		client.WithCommitStatusTimeout(1*time.Minute),
+	)
+	if err != nil {
+		panic(err)
+	}
+	defer gateway.Close()
+
+	contract := gateway.GetNetwork("mychannel").GetContract("bigdatacc")
+
 	// Handle different functions
 	if function == "update" {
-		result, err := f.Update(function, variableName, change, sign)
+		result, err := f.Update(contract, function, variableName, change, sign)
 		if err != nil {
 			log.Fatalf("error: %v", err)
 		}
 		log.Println("Value of variable", string(variableName), ": ", string(result))
 
 	} else if function == "delete" || function == "prune" || function == "delstandard" {
-		result, err := f.DeletePrune(function, variableName)
+		result, err := f.DeletePrune(contract, function, variableName)
 		if err != nil {
 			log.Fatalf("error: %v", err)
 		}
 		log.Println(string(result))
 	} else if function == "get" || function == "getstandard" {
-		result, err := f.Query(function, variableName)
+		result, err := f.Query(contract, function, variableName)
 		if err != nil {
 			log.Fatalf("error: %v", err)
 		}
 		log.Println("Value of variable", string(variableName), ": ", string(result))
 	} else if function == "manyUpdates" {
 		log.Println("submitting 1000 concurrent updates...")
-		result, err := f.ManyUpdates("update", variableName, change, sign)
+		result, err := f.ManyUpdates(contract, "update", variableName, change, sign)
 		if err != nil {
 			log.Fatalf("error: %v", err)
 		}
 		log.Println("Final value of variable", string(variableName), ": ", string(result))
 	} else if function == "manyUpdatesTraditional" {
 		log.Println("submitting 1000 concurrent updates...")
-		result, err := f.ManyUpdates("putstandard", variableName, change, sign)
+		result, err := f.ManyUpdates(contract, "putstandard", variableName, change, sign)
 		if err != nil {
 			log.Fatalf("error: %v", err)
 		}

high-throughput/application-go/connect.go

@@ -0,0 +1,114 @@
+/*
+Copyright 2025 IBM All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package main
+
+import (
+	"crypto/x509"
+	"fmt"
+	"os"
+	"path"
+
+	"github.com/hyperledger/fabric-gateway/pkg/identity"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+)
+
+const (
+	mspID        = "Org1MSP"
+	cryptoPath   = "../../test-network/organizations/peerOrganizations/org1.example.com"
+	certPath     = cryptoPath + "/users/User1@org1.example.com/msp/signcerts"
+	keyPath      = cryptoPath + "/users/User1@org1.example.com/msp/keystore"
+	tlsCertPath  = cryptoPath + "/peers/peer0.org1.example.com/tls/ca.crt"
+	peerEndpoint = "dns:///localhost:7051"
+	gatewayPeer  = "peer0.org1.example.com"
+)
+
+// newGrpcConnection creates a gRPC connection to the Gateway server.
+func newGrpcConnection() *grpc.ClientConn {
+	certificatePEM, err := os.ReadFile(tlsCertPath)
+	if err != nil {
+		panic(fmt.Errorf("failed to read TLS certificate file: %w", err))
+	}
+
+	certificate, err := identity.CertificateFromPEM(certificatePEM)
+	if err != nil {
+		panic(err)
+	}
+
+	certPool := x509.NewCertPool()
+	certPool.AddCert(certificate)
+	transportCredentials := credentials.NewClientTLSFromCert(certPool, gatewayPeer)
+
+	connection, err := grpc.NewClient(peerEndpoint, grpc.WithTransportCredentials(transportCredentials))
+	if err != nil {
+		panic(fmt.Errorf("failed to create gRPC connection: %w", err))
+	}
+
+	return connection
+}
+
+// newIdentity creates a client identity for this Gateway connection using an X.509 certificate.
+func newIdentity() *identity.X509Identity {
+	certificatePEM, err := readFirstFile(certPath)
+	if err != nil {
+		panic(fmt.Errorf("failed to read certificate file: %w", err))
+	}
+
+	certificate, err := identity.CertificateFromPEM(certificatePEM)
+	if err != nil {
+		panic(err)
+	}
+
+	id, err := identity.NewX509Identity(mspID, certificate)
+	if err != nil {
+		panic(err)
+	}
+
+	return id
+}
+
+func loadCertificate(filename string) (*x509.Certificate, error) {
+	certificatePEM, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read certificate file: %w", err)
+	}
+	return identity.CertificateFromPEM(certificatePEM)
+}
+
+// newSign creates a function that generates a digital signature from a message digest using a private key.
+func newSign() identity.Sign {
+	privateKeyPEM, err := readFirstFile(keyPath)
+	if err != nil {
+		panic(fmt.Errorf("failed to read private key file: %w", err))
+	}
+
+	privateKey, err := identity.PrivateKeyFromPEM(privateKeyPEM)
+	if err != nil {
+		panic(err)
+	}
+
+	sign, err := identity.NewPrivateKeySign(privateKey)
+	if err != nil {
+		panic(err)
+	}
+
+	return sign
+}
+
+func readFirstFile(dirPath string) ([]byte, error) {
+	dir, err := os.Open(dirPath)
+	if err != nil {
+		return nil, err
+	}
+
+	fileNames, err := dir.Readdirnames(1)
+	if err != nil {
+		return nil, err
+	}
+
+	return os.ReadFile(path.Join(dirPath, fileNames[0]))
+}