From bc6332c13ee5b4becbfc7b37a3855e52627cd829 Mon Sep 17 00:00:00 2001 From: Nex Date: Wed, 12 Sep 2018 00:39:26 +0800 Subject: [PATCH] Update AccountingChainClient --- .../bdchain/api/AccountingChainClient.java | 165 ++++++++++++++++++ src/main/java/bdchain/api/Utils.java | 16 ++ 2 files changed, 181 insertions(+) create mode 100644 src/main/java/bdchain/api/AccountingChainClient.java create mode 100644 src/main/java/bdchain/api/Utils.java diff --git a/src/main/java/bdchain/api/AccountingChainClient.java b/src/main/java/bdchain/api/AccountingChainClient.java new file mode 100644 index 0000000..78f0997 --- /dev/null +++ b/src/main/java/bdchain/api/AccountingChainClient.java @@ -0,0 +1,165 @@ +package bdchain.api; + +import bdchain.api.grpc.*; +import bdchain.api.grpc.AccountingChainGrpc.AccountingChainBlockingStub; +import com.google.protobuf.ByteString; +import io.grpc.ManagedChannel; +import io.grpc.ManagedChannelBuilder; +import io.grpc.StatusRuntimeException; + +import java.util.concurrent.TimeUnit; +import java.util.logging.Level; +import java.util.logging.Logger; + +// import bdchain.api.grpc.AccountingChainGrpc.AccountingChainStub; + +public class AccountingChainClient { + + private static final Logger logger = Logger.getLogger(AccountingChainClient.class.getName()); + + private final ManagedChannel channel; + private final AccountingChainBlockingStub blockingStub; + // private final AccountingChainStub asyncStub; + + /** Construct client for accessing AccountingChain server at {@code host:port}. */ + public AccountingChainClient(String host, int port) { + this(ManagedChannelBuilder.forAddress(host, port).usePlaintext()); + } + + /** Construct client for accessing AccountingChain server using the existing channel. */ + public AccountingChainClient(ManagedChannelBuilder channelBuilder) { + channel = channelBuilder.build(); + blockingStub = AccountingChainGrpc.newBlockingStub(channel); + // asyncStub = AccountingChainGrpc.newStub(channel); + } + + public void shutdown() throws InterruptedException { + channel.shutdown().awaitTermination(5, TimeUnit.SECONDS); + } + + public BlockNumberResponse blockNumber(String ledger) { + + info("*** blockNumber: ledger={0}", ledger); + + BlockNumberRequest request = BlockNumberRequest.newBuilder().setLedger(ledger).build(); + + try { + return blockingStub.blockNumber(request); + } catch (StatusRuntimeException e) { + warning("RPC failed: {0}", e.getStatus()); + return null; + } + } + + public Block getBlockByNumber(String ledger, long number, boolean fullTransaction) { + + info( + "*** getBlockByNumber: ledger={0} number={1} fullTransaction={2}", + ledger, number, fullTransaction); + + GetBlockByNumberRequest request = + GetBlockByNumberRequest.newBuilder() + .setLedger(ledger) + .setNumber(number) + .setFullTransaction(fullTransaction) + .build(); + + try { + return blockingStub.getBlockByNumber(request); + } catch (StatusRuntimeException e) { + warning("RPC failed: {0}", e.getStatus()); + return null; + } + } + + public Block getBlockByHash(String ledger, String hash, boolean fullTransaction) { + + info( + "*** getBlockByHash: ledger={0} hash={1} fullTransaction={2}", + ledger, hash, fullTransaction); + + GetBlockByHashRequest request = + GetBlockByHashRequest.newBuilder() + .setLedger(ledger) + .setHash(ByteString.copyFrom(Utils.hexStringToByteArray(hash))) + .setFullTransaction(fullTransaction) + .build(); + + try { + return blockingStub.getBlockByHash(request); + } catch (StatusRuntimeException e) { + warning("RPC failed: {0}", e.getStatus()); + return null; + } + } + + public Block getTransactionByHash(String ledger, String hash) { + + info("*** getTransactionByHash: ledger={0} hash={1}", ledger, hash); + + GetTransactionByHashRequest request = + GetTransactionByHashRequest.newBuilder() + .setLedger(ledger) + .setHash(ByteString.copyFrom(Utils.hexStringToByteArray(hash))) + .build(); + + try { + return blockingStub.getTransactionByHash(request); + } catch (StatusRuntimeException e) { + warning("RPC failed: {0}", e.getStatus()); + return null; + } + } + + public Transaction getTransactionByBlockNumberAndIndex( + String ledger, long block_number, int index) { + + info( + "*** getTransactionByBlockNumberAndIndex: ledger={0} block_number={1} index={2}", + ledger, block_number, index); + + GetTransactionByBlockNumberAndIndexRequest request = + GetTransactionByBlockNumberAndIndexRequest.newBuilder() + .setLedger(ledger) + .setBlockNumber(block_number) + .setIndex(index) + .build(); + + try { + return blockingStub.getTransactionByBlockNumberAndIndex(request); + } catch (StatusRuntimeException e) { + warning("RPC failed: {0}", e.getStatus()); + return null; + } + } + + public Transaction getTransactionByBlockHashAndIndex( + String ledger, String block_hash, int index) { + + info( + "*** getTransactionByBlockHashAndIndex: ledger={0} block_hash={1} index={2}", + ledger, block_hash, index); + + GetTransactionByBlockHashAndIndexRequest request = + GetTransactionByBlockHashAndIndexRequest.newBuilder() + .setLedger(ledger) + .setBlockHash(ByteString.copyFrom(Utils.hexStringToByteArray(block_hash))) + .setIndex(index) + .build(); + + try { + return blockingStub.getTransactionByBlockHashAndIndex(request); + } catch (StatusRuntimeException e) { + warning("RPC failed: {0}", e.getStatus()); + return null; + } + } + + private void info(String msg, Object... params) { + logger.log(Level.INFO, msg, params); + } + + private void warning(String msg, Object... params) { + logger.log(Level.WARNING, msg, params); + } +} diff --git a/src/main/java/bdchain/api/Utils.java b/src/main/java/bdchain/api/Utils.java new file mode 100644 index 0000000..a800415 --- /dev/null +++ b/src/main/java/bdchain/api/Utils.java @@ -0,0 +1,16 @@ +package bdchain.api; + +public class Utils { + public static byte[] hexStringToByteArray(String s) { + if (s.startsWith("0x")) { + s = s.substring(2); + } + int len = s.length(); + byte[] data = new byte[len / 2]; + for (int i = 0; i < len; i += 2) { + data[i / 2] = + (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16)); + } + return data; + } +}