Java off-chain data store sample using Fabric Gateway

Also minor implementation changes to TypeScript sample for better consistency between implementations. Signed-off-by: Mark S. Lewis <mark_lewis@uk.ibm.com>
hyperledger · May 20, 2022 · 512bd67 · 512bd67
1 parent 05791d3
commit 512bd67
Show file tree

Hide file tree

Showing 40 changed files with 1,925 additions and 57 deletions.
diff --git a/ci/scripts/run-test-network-basic.sh b/ci/scripts/run-test-network-basic.sh
@@ -123,3 +123,14 @@ SIMULATED_FAILURE_COUNT=1 npm start getAllAssets transact getAllAssets listen
 SIMULATED_FAILURE_COUNT=1 npm start listen
 popd
 stopNetwork
+
+# Run off-chain data Java application
+createNetwork
+print "Initializing Typescript off-chain data application"
+pushd ../off_chain_data/application-java
+rm -f app/checkpoint.json app/store.log
+print "Running the output app"
+SIMULATED_FAILURE_COUNT=1 ./gradlew run --quiet --args='getAllAssets transact getAllAssets listen'
+SIMULATED_FAILURE_COUNT=1 ./gradlew run --quiet --args=listen
+popd
+stopNetwork
diff --git a/off_chain_data/README.md b/off_chain_data/README.md
@@ -16,11 +16,17 @@ This sample uses the block event listening capability of the [Fabric Gateway cli
 
 The client application provides several "commands" that can be invoked using the command-line:
 
-- **getAllAssets**: Retrieve the current details of all assets recorded on the ledger. See `application-typescript/src/getAllAssets.ts`.
-- **listen**: Listen for block events, and use them to replicate ledger updates in an off-chain data store. See `application-typescript/src/listen.ts`.
-- **transact**: Submit a set of transactions to create, modify and delete assets. See `application-typescript/src/transact.ts`.
-
-To keep the sample code concise, the **listen** command writes ledger updates to an output file named `store.log` in the current working directory. A real implementation could write ledger updates directly to an off-chain data store of choice. You can inspect the information captured in this file as you run the sample.
+- **getAllAssets**: Retrieve the current details of all assets recorded on the ledger. See:
+  - TypeScript: `application-typescript/src/getAllAssets.ts`
+  - Java: `application-java/app/src/main/java/GetAllAssets.java`
+- **listen**: Listen for block events, and use them to replicate ledger updates in an off-chain data store. See:
+  - TypeScript: `application-typescript/src/listen.ts`
+  - Java: `application-java/app/src/main/java/Transact.java`
+- **transact**: Submit a set of transactions to create, modify and delete assets. See:
+  - TypeScript: `application-typescript/src/transact.ts`
+  - Java: `application-java/app/src/main/java/Transact.java`
+
+To keep the sample code concise, the **listen** command writes ledger updates to an output file named `store.log` in the current working directory (which for the Java sample is the `application-java/app` directory). A real implementation could write ledger updates directly to an off-chain data store of choice. You can inspect the information captured in this file as you run the sample.
 
 Note that the **listen** command is is restartable and will resume event listening after the last successfully processed block / transaction. This is achieved using a checkpointer to persist the current listening position. Checkpoint state is persisted to a file named `checkpoint.json` in the current working directory. If no checkpoint state is present, event listening begins from the start of the ledger (block number zero).
 
@@ -58,6 +64,10 @@ The Fabric test network is used to deploy and run this sample. Follow these step
    cd application-typescript
    npm install
    npm start transact listen
+
+   # To run the Java sample application
+   cd application-java
+   ./gradlew run --quiet --args='transact listen'
    ```
 
 1. Interrupt the listener process using **Control-C**.
@@ -68,6 +78,10 @@ The Fabric test network is used to deploy and run this sample. Follow these step
    # To run the TypeScript sample application
    cd application-typescript
    npm --silent start getAllAssets
+
+   # To run the Java sample application
+   cd application-java
+   ./gradlew run --quiet --args=getAllAssets
    ```
 
 1. Make some more ledger updates, then observe listener resume capability (from the `off_chain_data` folder). Note from the transaction IDs recorded to the console that the listener resumes from exactly after the last successfully processed transaction.
@@ -78,6 +92,12 @@ The Fabric test network is used to deploy and run this sample. Follow these step
    npm start transact
    SIMULATED_FAILURE_COUNT=5 npm start listen
    npm start listen
+
+   # To run the Java sample application
+   cd application-java
+   ./gradlew run --quiet --args=transact
+   SIMULATED_FAILURE_COUNT=5 ./gradlew run --quiet --args=listen
+   ./gradlew run --quiet --args=listen
    ```
 
 1. Interrupt the listener process using **Control-C**.

diff --git a/off_chain_data/application-java/.gitignore b/off_chain_data/application-java/.gitignore
@@ -0,0 +1,12 @@
+# Ignore Gradle project-specific cache directory
+.gradle
+
+# Ignore Gradle build output directory
+build
+
+# IntelliJ IDEA files
+.idea
+
+# Files generated by the application at runtime
+checkpoint.json
+store.log
diff --git a/off_chain_data/application-java/app/build.gradle b/off_chain_data/application-java/app/build.gradle
@@ -0,0 +1,38 @@
+/*
+ * Copyright IBM Corp. All Rights Reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+plugins {
+    id 'application' // Support for building a CLI application in Java.
+    id 'checkstyle'
+}
+
+repositories {
+    mavenCentral()
+    maven {
+        url 'https://hyperledger-fabric.jfrog.io/artifactory/fabric-maven'
+    }
+}
+
+dependencies {
+//    implementation 'com.google.guava:guava:30.1.1-jre'
+    implementation 'io.grpc:grpc-netty-shaded:1.46.0'
+    implementation 'org.hyperledger.fabric:fabric-gateway:1.0.2-dev-20220518-1'
+    implementation 'com.google.code.gson:gson:2.9.0'
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(11)
+    }
+}
+
+checkstyle {
+    toolVersion '10.2'
+}
+
+application {
+    mainClass = 'App'
+}
diff --git a/off_chain_data/application-java/app/src/main/java/App.java b/off_chain_data/application-java/app/src/main/java/App.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright IBM Corp. All Rights Reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import java.io.PrintStream;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import io.grpc.ManagedChannel;
+
+public final class App {
+    private static final long SHUTDOWN_TIMEOUT_SECONDS = 3;
+    private static final Map<String, Command> COMMANDS = Map.ofEntries(
+            Map.entry("getAllAssets", new GetAllAssets()),
+            Map.entry("transact", new Transact()),
+            Map.entry("listen", new Listen())
+    );
+
+    private final List<String> commandNames;
+    private final PrintStream out = System.out;
+
+    App(final String[] args) {
+        commandNames = List.of(args);
+    }
+
+    public void run() throws Exception {
+        List<Command> commands = getCommands();
+        ManagedChannel grpcChannel = Connections.newGrpcConnection();
+        try {
+            for (Command command : commands) {
+                command.run(grpcChannel);
+            }
+        } finally {
+            grpcChannel.shutdownNow().awaitTermination(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+        }
+    }
+
+    private List<Command> getCommands() {
+        List<Command> commands = commandNames.stream()
+                .map(name -> {
+                    Command command = COMMANDS.get(name);
+                    if (command == null) {
+                        printUsage();
+                        throw new IllegalArgumentException("Unknown command: " + name);
+                    }
+                    return command;
+                })
+                .collect(Collectors.toList());
+
+        if (commands.isEmpty()) {
+            printUsage();
+            throw new IllegalArgumentException("Missing command");
+        }
+
+        return commands;
+    }
+
+    private void printUsage() {
+        out.println("Arguments: <command1> [<command2> ...]");
+        out.println("Available commands: " + COMMANDS.keySet());
+    }
+
+    public static void main(final String[] args) {
+        try {
+            new App(args).run();
+        } catch (ExpectedException e) {
+            e.printStackTrace(System.out);
+        } catch (Exception e) {
+            System.err.print("\nUnexpected application error: ");
+            e.printStackTrace();
+            System.exit(1);
+        }
+    }
+}
diff --git a/off_chain_data/application-java/app/src/main/java/Asset.java b/off_chain_data/application-java/app/src/main/java/Asset.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright IBM Corp. All Rights Reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Object representation of an asset. Note that the private member variable names don't follow the normal Java naming
+ * convention as they map to the JSON format expected by the smart contract.
+ */
+public final class Asset {
+    private final String ID; // checkstyle:ignore-line:MemberName
+    private String Color; // checkstyle:ignore-line:MemberName
+    private int Size; // checkstyle:ignore-line:MemberName
+    private String Owner; // checkstyle:ignore-line:MemberName
+    private int AppraisedValue; // checkstyle:ignore-line:MemberName
+
+    public Asset(final String id) {
+        this.ID = id;
+    }
+
+    public String getId() {
+        return ID;
+    }
+
+    public String getColor() {
+        return Color;
+    }
+
+    public void setColor(final String color) {
+        this.Color = color;
+    }
+
+    public int getSize() {
+        return Size;
+    }
+
+    public void setSize(final int size) {
+        this.Size = size;
+    }
+
+    public String getOwner() {
+        return Owner;
+    }
+
+    public void setOwner(final String owner) {
+        this.Owner = owner;
+    }
+
+    public int getAppraisedValue() {
+        return AppraisedValue;
+    }
+
+    public void setAppraisedValue(final int appraisedValue) {
+        this.AppraisedValue = appraisedValue;
+    }
+}
diff --git a/off_chain_data/application-java/app/src/main/java/AssetTransferBasic.java b/off_chain_data/application-java/app/src/main/java/AssetTransferBasic.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright IBM Corp. All Rights Reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+import com.google.gson.Gson;
+import org.hyperledger.fabric.client.CommitException;
+import org.hyperledger.fabric.client.CommitStatusException;
+import org.hyperledger.fabric.client.Contract;
+import org.hyperledger.fabric.client.EndorseException;
+import org.hyperledger.fabric.client.SubmitException;
+
+public final class AssetTransferBasic {
+    private static final Gson GSON = new Gson();
+    private final Contract contract;
+
+    public AssetTransferBasic(final Contract contract) {
+        this.contract = contract;
+    }
+
+    public void createAsset(final Asset asset) throws EndorseException, CommitException, SubmitException, CommitStatusException {
+        contract.submitTransaction(
+                "CreateAsset",
+                asset.getId(),
+                asset.getColor(),
+                Integer.toString(asset.getSize()),
+                asset.getOwner(),
+                Integer.toString(asset.getAppraisedValue())
+        );
+    }
+
+    public String transferAsset(final String id, final String newOwner) throws EndorseException, CommitException, SubmitException, CommitStatusException {
+        byte[] resultBytes = contract.submitTransaction("TransferAsset", id, newOwner);
+        return new String(resultBytes, StandardCharsets.UTF_8);
+    }
+
+    public void deleteAsset(final String id) throws EndorseException, CommitException, SubmitException, CommitStatusException {
+        contract.submitTransaction("DeleteAsset", id);
+    }
+
+    public List<Asset> getAllAssets() throws EndorseException, CommitException, SubmitException, CommitStatusException {
+        byte[] resultBytes = contract.submitTransaction("GetAllAssets");
+        String resultJson = new String(resultBytes, StandardCharsets.UTF_8);
+        Asset[] assets = GSON.fromJson(resultJson, Asset[].class);
+        return assets != null ? List.of(assets) : List.of();
+    }
+}
diff --git a/off_chain_data/application-java/app/src/main/java/BlockProcessor.java b/off_chain_data/application-java/app/src/main/java/BlockProcessor.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright IBM Corp. All Rights Reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import org.hyperledger.fabric.client.Checkpointer;
+import parser.Block;
+import parser.Transaction;
+
+public final class BlockProcessor {
+    private final Block block;
+    private final Checkpointer checkpointer;
+    private final Store store;
+
+    public BlockProcessor(final Block block, final Checkpointer checkpointer, final Store store) {
+        this.block = block;
+        this.checkpointer = checkpointer;
+        this.store = store;
+    }
+
+    public void process() {
+        long blockNumber = block.getNumber();
+        System.out.println("\nReceived block " + Long.toUnsignedString(blockNumber));
+
+        try {
+            List<Transaction> validTransactions = getNewTransactions().stream()
+                    .filter(Transaction::isValid)
+                    .collect(Collectors.toList());
+
+            for (Transaction transaction : validTransactions) {
+                new TransactionProcessor(transaction, blockNumber, store).process();
+
+                String transactionId = transaction.getChannelHeader().getTxId();
+                checkpointer.checkpointTransaction(blockNumber, transactionId);
+            }
+
+            checkpointer.checkpointBlock(blockNumber);
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+
+    private List<Transaction> getNewTransactions() throws InvalidProtocolBufferException {
+        List<Transaction> transactions = block.getTransactions();
+
+        Optional<String> lastTransactionId = checkpointer.getTransactionId();
+        if (lastTransactionId.isEmpty()) {
+            // No previously processed transactions within this block so all are new
+            return transactions;
+        }
+
+        List<String> transactionIds = new ArrayList<>();
+        for (Transaction transaction : transactions) {
+            transactionIds.add(transaction.getChannelHeader().getTxId());
+        }
+
+        // Ignore transactions up to the last processed transaction ID
+        int lastProcessedIndex = transactionIds.indexOf(lastTransactionId.get());
+        if (lastProcessedIndex < 0) {
+            throw new IllegalArgumentException("Checkpoint transaction ID " + lastTransactionId + " not found in block "
+                    + Long.toUnsignedString(block.getNumber()) + " containing transactions: " + transactionIds);
+        }
+
+        return transactions.subList(lastProcessedIndex + 1, transactions.size());
+    }
+}