Example usage for java.util.concurrent CompletableFuture CompletableFuture

Introduction

In this page you can find the example usage for java.util.concurrent CompletableFuture CompletableFuture.

Prototype

public CompletableFuture() 

Source Link

Document

Creates a new incomplete CompletableFuture.

Usage

From source file:org.apache.hadoop.hbase.client.RawAsyncHBaseAdmin.java

@Override
public CompletableFuture<CacheEvictionStats> clearBlockCache(TableName tableName) {
    CompletableFuture<CacheEvictionStats> future = new CompletableFuture<>();
    addListener(getTableHRegionLocations(tableName), (locations, err) -> {
        if (err != null) {
            future.completeExceptionally(err);
            return;
        }//  w  w w  . ja v a  2  s.com
        Map<ServerName, List<RegionInfo>> regionInfoByServerName = locations.stream()
                .filter(l -> l.getRegion() != null).filter(l -> !l.getRegion().isOffline())
                .filter(l -> l.getServerName() != null).collect(Collectors.groupingBy(l -> l.getServerName(),
                        Collectors.mapping(l -> l.getRegion(), Collectors.toList())));
        List<CompletableFuture<CacheEvictionStats>> futures = new ArrayList<>();
        CacheEvictionStatsAggregator aggregator = new CacheEvictionStatsAggregator();
        for (Map.Entry<ServerName, List<RegionInfo>> entry : regionInfoByServerName.entrySet()) {
            futures.add(clearBlockCache(entry.getKey(), entry.getValue()).whenComplete((stats, err2) -> {
                if (err2 != null) {
                    future.completeExceptionally(unwrapCompletionException(err2));
                } else {
                    aggregator.append(stats);
                }
            }));
        }
        addListener(CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()])),
                (ret, err3) -> {
                    if (err3 != null) {
                        future.completeExceptionally(unwrapCompletionException(err3));
                    } else {
                        future.complete(aggregator.sum());
                    }
                });
    });
    return future;
}

---

From source file:org.apache.hadoop.hbase.client.RawAsyncHBaseAdmin.java

@Override
public CompletableFuture<Void> cloneTableSchema(TableName tableName, TableName newTableName,
        boolean preserveSplits) {
    CompletableFuture<Void> future = new CompletableFuture<>();
    addListener(tableExists(tableName), (exist, err) -> {
        if (err != null) {
            future.completeExceptionally(err);
            return;
        }//from w  w w.java 2s.  c  o  m
        if (!exist) {
            future.completeExceptionally(new TableNotFoundException(tableName));
            return;
        }
        addListener(tableExists(newTableName), (exist1, err1) -> {
            if (err1 != null) {
                future.completeExceptionally(err1);
                return;
            }
            if (exist1) {
                future.completeExceptionally(new TableExistsException(newTableName));
                return;
            }
            addListener(getDescriptor(tableName), (tableDesc, err2) -> {
                if (err2 != null) {
                    future.completeExceptionally(err2);
                    return;
                }
                TableDescriptor newTableDesc = TableDescriptorBuilder.copy(newTableName, tableDesc);
                if (preserveSplits) {
                    addListener(getTableSplits(tableName), (splits, err3) -> {
                        if (err3 != null) {
                            future.completeExceptionally(err3);
                        } else {
                            addListener(splits != null ? createTable(newTableDesc, splits)
                                    : createTable(newTableDesc), (result, err4) -> {
                                        if (err4 != null) {
                                            future.completeExceptionally(err4);
                                        } else {
                                            future.complete(result);
                                        }
                                    });
                        }
                    });
                } else {
                    addListener(createTable(newTableDesc), (result, err5) -> {
                        if (err5 != null) {
                            future.completeExceptionally(err5);
                        } else {
                            future.complete(result);
                        }
                    });
                }
            });
        });
    });
    return future;
}

---

From source file:org.hyperledger.fabric.sdk.Channel.java

/**
 * Send transaction to one of a specified set of orderers with the specified user context.
 * IF there are no event hubs or eventing peers this future returns immediately completed
 * indicating that orderer has accepted the transaction only.
 *
 * @param proposalResponses//from w w  w.ja  va 2  s.c  o m
 * @param transactionOptions
 * @return Future allowing access to the result of the transaction invocation.
 */

public CompletableFuture<TransactionEvent> sendTransaction(Collection<ProposalResponse> proposalResponses,
        TransactionOptions transactionOptions) {
    try {

        if (null == transactionOptions) {
            throw new InvalidArgumentException("Parameter transactionOptions can't be null");
        }
        checkChannelState();
        User userContext = transactionOptions.userContext != null ? transactionOptions.userContext
                : client.getUserContext();
        userContextCheck(userContext);
        if (null == proposalResponses) {
            throw new InvalidArgumentException("sendTransaction proposalResponses was null");
        }

        List<Orderer> orderers = transactionOptions.orderers != null ? transactionOptions.orderers
                : new ArrayList<>(getOrderers());

        // make certain we have our own copy
        final List<Orderer> shuffeledOrderers = new ArrayList<>(orderers);

        if (transactionOptions.shuffleOrders) {
            Collections.shuffle(shuffeledOrderers);
        }

        if (config.getProposalConsistencyValidation()) {
            HashSet<ProposalResponse> invalid = new HashSet<>();
            int consistencyGroups = SDKUtils.getProposalConsistencySets(proposalResponses, invalid).size();

            if (consistencyGroups != 1 || !invalid.isEmpty()) {
                throw new IllegalArgumentException(format(
                        "The proposal responses have %d inconsistent groups with %d that are invalid."
                                + " Expected all to be consistent and none to be invalid.",
                        consistencyGroups, invalid.size()));

            }

        }

        List<FabricProposalResponse.Endorsement> ed = new LinkedList<>();
        FabricProposal.Proposal proposal = null;
        ByteString proposalResponsePayload = null;
        String proposalTransactionID = null;
        TransactionContext transactionContext = null;

        for (ProposalResponse sdkProposalResponse : proposalResponses) {
            ed.add(sdkProposalResponse.getProposalResponse().getEndorsement());
            if (proposal == null) {
                proposal = sdkProposalResponse.getProposal();
                proposalTransactionID = sdkProposalResponse.getTransactionID();
                if (proposalTransactionID == null) {
                    throw new InvalidArgumentException("Proposals with missing transaction ID");
                }
                proposalResponsePayload = sdkProposalResponse.getProposalResponse().getPayload();
                if (proposalResponsePayload == null) {
                    throw new InvalidArgumentException("Proposals with missing payload.");
                }
                transactionContext = sdkProposalResponse.getTransactionContext();
                if (transactionContext == null) {
                    throw new InvalidArgumentException("Proposals with missing transaction context.");
                }
            } else {
                final String transactionID = sdkProposalResponse.getTransactionID();
                if (transactionID == null) {
                    throw new InvalidArgumentException("Proposals with missing transaction id.");
                }
                if (!proposalTransactionID.equals(transactionID)) {
                    throw new InvalidArgumentException(
                            format("Proposals with different transaction IDs %s,  and %s",
                                    proposalTransactionID, transactionID));
                }
            }
        }

        TransactionBuilder transactionBuilder = TransactionBuilder.newBuilder();

        Payload transactionPayload = transactionBuilder.chaincodeProposal(proposal).endorsements(ed)
                .proposalResponsePayload(proposalResponsePayload).build();

        Envelope transactionEnvelope = createTransactionEnvelope(transactionPayload, transactionContext);

        NOfEvents nOfEvents = transactionOptions.nOfEvents;

        if (nOfEvents == null) {
            nOfEvents = NOfEvents.createNofEvents();
            Collection<Peer> eventingPeers = getEventingPeers();
            boolean anyAdded = false;
            if (!eventingPeers.isEmpty()) {
                anyAdded = true;
                nOfEvents.addPeers(eventingPeers);
            }
            Collection<EventHub> eventHubs = getEventHubs();
            if (!eventHubs.isEmpty()) {
                anyAdded = true;
                nOfEvents.addEventHubs(getEventHubs());
            }

            if (!anyAdded) {
                nOfEvents = NOfEvents.createNoEvents();
            }

        } else if (nOfEvents != NOfEvents.nofNoEvents) {
            StringBuilder issues = new StringBuilder(100);
            Collection<Peer> eventingPeers = getEventingPeers();
            nOfEvents.unSeenPeers().forEach(peer -> {
                if (peer.getChannel() != this) {
                    issues.append(format("Peer %s added to NOFEvents does not belong this channel. ",
                            peer.getName()));

                } else if (!eventingPeers.contains(peer)) {
                    issues.append(format("Peer %s added to NOFEvents is not a eventing Peer in this channel. ",
                            peer.getName()));
                }

            });
            nOfEvents.unSeenEventHubs().forEach(eventHub -> {
                if (!eventHubs.contains(eventHub)) {
                    issues.append(format("Eventhub %s added to NOFEvents does not belong this channel. ",
                            eventHub.getName()));
                }

            });

            if (nOfEvents.unSeenEventHubs().isEmpty() && nOfEvents.unSeenPeers().isEmpty()) {
                issues.append("NofEvents had no Eventhubs added or Peer eventing services.");
            }
            String foundIssues = issues.toString();
            if (!foundIssues.isEmpty()) {
                throw new InvalidArgumentException(foundIssues);
            }
        }

        final boolean replyonly = nOfEvents == NOfEvents.nofNoEvents
                || (getEventHubs().isEmpty() && getEventingPeers().isEmpty());

        CompletableFuture<TransactionEvent> sret;
        if (replyonly) { //If there are no eventhubs to complete the future, complete it
            // immediately but give no transaction event
            logger.debug(format(
                    "Completing transaction id %s immediately no event hubs or peer eventing services found in channel %s.",
                    proposalTransactionID, name));
            sret = new CompletableFuture<>();
        } else {
            sret = registerTxListener(proposalTransactionID, nOfEvents, transactionOptions.failFast);
        }

        logger.debug(format("Channel %s sending transaction to orderer(s) with TxID %s ", name,
                proposalTransactionID));
        boolean success = false;
        Exception lException = null; // Save last exception to report to user .. others are just logged.

        BroadcastResponse resp = null;
        Orderer failed = null;
        for (Orderer orderer : shuffeledOrderers) {
            if (failed != null) {
                logger.warn(format("Channel %s  %s failed. Now trying %s.", name, failed, orderer));
            }
            failed = orderer;
            try {

                if (null != diagnosticFileDumper) {
                    logger.trace(format("Sending to channel %s, orderer: %s, transaction: %s", name,
                            orderer.getName(), diagnosticFileDumper
                                    .createDiagnosticProtobufFile(transactionEnvelope.toByteArray())));
                }

                resp = orderer.sendTransaction(transactionEnvelope);
                lException = null; // no longer last exception .. maybe just failed.
                if (resp.getStatus() == Status.SUCCESS) {
                    success = true;
                    break;
                } else {
                    logger.warn(format("Channel %s %s failed. Status returned %s", name, orderer,
                            getRespData(resp)));
                }
            } catch (Exception e) {
                String emsg = format("Channel %s unsuccessful sendTransaction to orderer %s (%s)", name,
                        orderer.getName(), orderer.getUrl());
                if (resp != null) {

                    emsg = format("Channel %s unsuccessful sendTransaction to orderer %s (%s).  %s", name,
                            orderer.getName(), orderer.getUrl(), getRespData(resp));
                }

                logger.error(emsg);
                lException = new Exception(emsg, e);

            }

        }

        if (success) {
            logger.debug(format("Channel %s successful sent to Orderer transaction id: %s", name,
                    proposalTransactionID));
            if (replyonly) {
                sret.complete(null); // just say we're done.
            }
            return sret;
        } else {

            String emsg = format(
                    "Channel %s failed to place transaction %s on Orderer. Cause: UNSUCCESSFUL. %s", name,
                    proposalTransactionID, getRespData(resp));

            unregisterTxListener(proposalTransactionID);

            CompletableFuture<TransactionEvent> ret = new CompletableFuture<>();
            ret.completeExceptionally(
                    lException != null ? new Exception(emsg, lException) : new Exception(emsg));
            return ret;
        }
    } catch (Exception e) {

        CompletableFuture<TransactionEvent> future = new CompletableFuture<>();
        future.completeExceptionally(e);
        return future;

    }

}

---

From source file:org.hyperledger.fabric.sdk.Channel.java

/**
 * Register a transactionId that to get notification on when the event is seen in the block chain.
 *
 * @param txid/*from   w  w  w. j a va  2 s.  c o m*/
 * @param nOfEvents
 * @return
 */

private CompletableFuture<TransactionEvent> registerTxListener(String txid, NOfEvents nOfEvents,
        boolean failFast) {

    CompletableFuture<TransactionEvent> future = new CompletableFuture<>();

    new TL(txid, future, nOfEvents, failFast);

    return future;

}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• »