Example usage for com.google.common.util.concurrent JdkFutureAdapters listenInPoolThread

List of usage examples for com.google.common.util.concurrent JdkFutureAdapters listenInPoolThread

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.util.concurrent.*
  5. JdkFutureAdapters
  6. listenInPoolThread

Introduction

In this page you can find the example usage for com.google.common.util.concurrent JdkFutureAdapters listenInPoolThread.

Prototype

public static <V> ListenableFuture<V> listenInPoolThread(Future<V> future)

Source Link

Document

Assigns a thread to the given Future to provide ListenableFuture functionality.

Usage

From source file:org.opendaylight.openflowplugin.applications.bulk.o.matic.SalBulkFlowServiceImpl.java

@Override
public Future<RpcResult<Void>> addFlowsRpc(AddFlowsRpcInput input) {
    List<ListenableFuture<RpcResult<AddFlowOutput>>> bulkResults = new ArrayList<>();

    for (BulkFlowBaseContentGrouping bulkFlow : input.getBulkFlowItem()) {
        AddFlowInputBuilder flowInputBuilder = new AddFlowInputBuilder((Flow) bulkFlow);
        final NodeRef nodeRef = bulkFlow.getNode();
        flowInputBuilder.setNode(nodeRef);
        flowInputBuilder.setTableId(bulkFlow.getTableId());
        Future<RpcResult<AddFlowOutput>> rpcAddFlowResult = flowService.addFlow(flowInputBuilder.build());
        bulkResults.add(JdkFutureAdapters.listenInPoolThread(rpcAddFlowResult));
    }/* www. ja va 2 s  . c o  m*/
    return handleResultFuture(Futures.allAsList(bulkResults));
}

From source file:org.opendaylight.openflowplugin.impl.services.batch.FlatBatchGroupAdapters.java

/**
 * shortcut for {@link #convertBatchGroupResult(int)} with conversion {@link ListenableFuture}
 *
 * @param <T>                     exact type of batch flow output
 * @param resultUpdateGroupFuture batch group rpc-result (add/remove/update)
 * @param currentOffset           offset of current batch plan step with respect to entire chain of steps
 * @return ListenableFuture with converted result {@link ProcessFlatBatchOutput}
 *//*from   w w w  .  j  a  v  a2s. co m*/
public static <T extends BatchGroupOutputListGrouping> ListenableFuture<RpcResult<ProcessFlatBatchOutput>> convertGroupBatchFutureForChain(
        final Future<RpcResult<T>> resultUpdateGroupFuture, final int currentOffset) {
    return Futures.transform(JdkFutureAdapters.listenInPoolThread(resultUpdateGroupFuture),
            FlatBatchGroupAdapters.<T>convertBatchGroupResult(currentOffset));
}

From source file:org.opendaylight.openflowplugin.impl.services.batch.FlatBatchMeterAdapters.java

/**
 * shortcut for {@link #convertBatchMeterResult(int)} with conversion {@link ListenableFuture}
 *
 * @param <T>                     exact type of batch flow output
 * @param resultUpdateMeterFuture batch group rpc-result (add/remove/update)
 * @param currentOffset           offset of current batch plan step with respect to entire chain of steps
 * @return ListenableFuture with converted result {@link ProcessFlatBatchOutput}
 *///from ww  w. j av  a 2  s .  c o  m
public static <T extends BatchMeterOutputListGrouping> ListenableFuture<RpcResult<ProcessFlatBatchOutput>> convertMeterBatchFutureForChain(
        final Future<RpcResult<T>> resultUpdateMeterFuture, final int currentOffset) {
    return Futures.transform(JdkFutureAdapters.listenInPoolThread(resultUpdateMeterFuture),
            FlatBatchMeterAdapters.<T>convertBatchMeterResult(currentOffset));
}

From source file:org.opendaylight.openflowplugin.impl.services.SalFlowsBatchServiceImpl.java

@Override
public Future<RpcResult<UpdateFlowsBatchOutput>> updateFlowsBatch(final UpdateFlowsBatchInput input) {
    LOG.trace("Updating flows @ {} : {}", PathUtil.extractNodeId(input.getNode()),
            input.getBatchUpdateFlows().size());
    final ArrayList<ListenableFuture<RpcResult<UpdateFlowOutput>>> resultsLot = new ArrayList<>();
    for (BatchUpdateFlows batchFlow : input.getBatchUpdateFlows()) {
        final UpdateFlowInput updateFlowInput = new UpdateFlowInputBuilder(input)
                .setOriginalFlow(new OriginalFlowBuilder(batchFlow.getOriginalBatchedFlow()).build())
                .setUpdatedFlow(new UpdatedFlowBuilder(batchFlow.getUpdatedBatchedFlow()).build())
                .setFlowRef(createFlowRef(input.getNode(), batchFlow)).setNode(input.getNode()).build();
        resultsLot.add(JdkFutureAdapters.listenInPoolThread(salFlowService.updateFlow(updateFlowInput)));
    }//from w ww. j av a  2s  .  c  om

    final ListenableFuture<RpcResult<List<BatchFailedFlowsOutput>>> commonResult = Futures.transform(
            Futures.successfulAsList(resultsLot),
            FlowUtil.<UpdateFlowOutput>createCumulatingFunction(input.getBatchUpdateFlows()));

    ListenableFuture<RpcResult<UpdateFlowsBatchOutput>> updateFlowsBulkFuture = Futures.transform(commonResult,
            FlowUtil.FLOW_UPDATE_TRANSFORM);

    if (input.isBarrierAfter()) {
        updateFlowsBulkFuture = BarrierUtil.chainBarrier(updateFlowsBulkFuture, input.getNode(),
                transactionService, FlowUtil.FLOW_UPDATE_COMPOSING_TRANSFORM);
    }

    return updateFlowsBulkFuture;
}

From source file:org.opendaylight.openflowplugin.impl.services.SalMetersBatchServiceImpl.java

@Override
public Future<RpcResult<RemoveMetersBatchOutput>> removeMetersBatch(final RemoveMetersBatchInput input) {
    LOG.trace("Removing meters @ {} : {}", PathUtil.extractNodeId(input.getNode()),
            input.getBatchRemoveMeters().size());
    final ArrayList<ListenableFuture<RpcResult<RemoveMeterOutput>>> resultsLot = new ArrayList<>();
    for (BatchRemoveMeters addMeter : input.getBatchRemoveMeters()) {
        final RemoveMeterInput removeMeterInput = new RemoveMeterInputBuilder(addMeter)
                .setMeterRef(createMeterRef(input.getNode(), addMeter)).setNode(input.getNode()).build();
        resultsLot.add(JdkFutureAdapters.listenInPoolThread(salMeterService.removeMeter(removeMeterInput)));
    }//from w  ww.  j  a v  a 2s.  c  om

    final ListenableFuture<RpcResult<List<BatchFailedMetersOutput>>> commonResult = Futures.transform(
            Futures.allAsList(resultsLot),
            MeterUtil.<RemoveMeterOutput>createCumulativeFunction(input.getBatchRemoveMeters()));

    ListenableFuture<RpcResult<RemoveMetersBatchOutput>> removeMetersBulkFuture = Futures
            .transform(commonResult, MeterUtil.METER_REMOVE_TRANSFORM);

    if (input.isBarrierAfter()) {
        removeMetersBulkFuture = BarrierUtil.chainBarrier(removeMetersBulkFuture, input.getNode(),
                transactionService, MeterUtil.METER_REMOVE_COMPOSING_TRANSFORM);
    }

    return removeMetersBulkFuture;
}

From source file:org.opendaylight.openflowplugin.impl.services.SalGroupsBatchServiceImpl.java

@Override
public Future<RpcResult<RemoveGroupsBatchOutput>> removeGroupsBatch(final RemoveGroupsBatchInput input) {
    LOG.trace("Removing groups @ {} : {}", PathUtil.extractNodeId(input.getNode()),
            input.getBatchRemoveGroups().size());
    final ArrayList<ListenableFuture<RpcResult<RemoveGroupOutput>>> resultsLot = new ArrayList<>();
    for (BatchRemoveGroups addGroup : input.getBatchRemoveGroups()) {
        final RemoveGroupInput removeGroupInput = new RemoveGroupInputBuilder(addGroup)
                .setGroupRef(createGroupRef(input.getNode(), addGroup)).setNode(input.getNode()).build();
        resultsLot.add(JdkFutureAdapters.listenInPoolThread(salGroupService.removeGroup(removeGroupInput)));
    }/*from  w w  w  .jav a 2 s . co m*/

    final ListenableFuture<RpcResult<List<BatchFailedGroupsOutput>>> commonResult = Futures.transform(
            Futures.allAsList(resultsLot),
            GroupUtil.<RemoveGroupOutput>createCumulatingFunction(input.getBatchRemoveGroups()));

    ListenableFuture<RpcResult<RemoveGroupsBatchOutput>> removeGroupsBulkFuture = Futures
            .transform(commonResult, GroupUtil.GROUP_REMOVE_TRANSFORM);

    if (input.isBarrierAfter()) {
        removeGroupsBulkFuture = BarrierUtil.chainBarrier(removeGroupsBulkFuture, input.getNode(),
                transactionService, GroupUtil.GROUP_REMOVE_COMPOSING_TRANSFORM);
    }

    return removeGroupsBulkFuture;
}

From source file:org.opendaylight.genius.alivenessmonitor.protocols.internal.AlivenessProtocolHandlerARP.java

@Override
public void startMonitoringTask(MonitoringInfo monitorInfo) {
    if (arpService == null) {
        LOG.debug("ARP Service not available to send the packet");
        return;//w ww .j a v a  2 s  .c  om
    }
    EndpointType source = monitorInfo.getSource().getEndpointType();
    final String sourceInterface = Preconditions.checkNotNull(getInterfaceName(source),
            "Source interface is required to send ARP Packet for monitoring");

    final String srcIp = Preconditions.checkNotNull(getIpAddress(source),
            "Source Ip address is required to send ARP Packet for monitoring");
    final Optional<PhysAddress> srcMacAddressOptional = getMacAddress(source);
    if (srcMacAddressOptional.isPresent()) {
        PhysAddress srcMacAddress = srcMacAddressOptional.get();
        EndpointType target = monitorInfo.getDestination().getEndpointType();
        final String targetIp = Preconditions.checkNotNull(getIpAddress(target),
                "Target Ip address is required to send ARP Packet for monitoring");
        if (LOG.isTraceEnabled()) {
            LOG.trace("sendArpRequest interface {}, senderIPAddress {}, targetAddress {}", sourceInterface,
                    srcIp, targetIp);
        }
        InterfaceAddressBuilder interfaceAddressBuilder = new InterfaceAddressBuilder()
                .setInterface(sourceInterface).setIpAddress(IpAddressBuilder.getDefaultInstance(srcIp));
        if (srcMacAddress != null) {
            interfaceAddressBuilder.setMacaddress(srcMacAddress);
        }
        List<InterfaceAddress> addresses = Collections.singletonList(interfaceAddressBuilder.build());
        SendArpRequestInput input = new SendArpRequestInputBuilder().setInterfaceAddress(addresses)
                .setIpaddress(IpAddressBuilder.getDefaultInstance(targetIp)).build();
        Future<RpcResult<Void>> future = arpService.sendArpRequest(input);
        final String msgFormat = String.format("Send ARP Request on interface %s to destination %s",
                sourceInterface, targetIp);
        Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future),
                new FutureCallback<RpcResult<Void>>() {
                    @Override
                    public void onFailure(Throwable error) {
                        LOG.error("Error - {}", msgFormat, error);
                    }

                    @Override
                    public void onSuccess(RpcResult<Void> result) {
                        if (result != null && !result.isSuccessful()) {
                            LOG.warn("Rpc call to {} failed {}", msgFormat, getErrorText(result.getErrors()));
                        } else {
                            LOG.debug("Successful RPC Result - {}", msgFormat);
                        }
                    }
                });
    }
}

From source file:org.opendaylight.openflowplugin.applications.bulk.o.matic.SalBulkFlowServiceImpl.java

@Override
public Future<RpcResult<Void>> removeFlowsRpc(RemoveFlowsRpcInput input) {
    List<ListenableFuture<RpcResult<RemoveFlowOutput>>> bulkResults = new ArrayList<>();

    for (BulkFlowBaseContentGrouping bulkFlow : input.getBulkFlowItem()) {
        RemoveFlowInputBuilder flowInputBuilder = new RemoveFlowInputBuilder((Flow) bulkFlow);
        final NodeRef nodeRef = bulkFlow.getNode();
        flowInputBuilder.setNode(nodeRef);
        flowInputBuilder.setTableId(bulkFlow.getTableId());
        Future<RpcResult<RemoveFlowOutput>> rpcAddFlowResult = flowService.removeFlow(flowInputBuilder.build());
        bulkResults.add(JdkFutureAdapters.listenInPoolThread(rpcAddFlowResult));
    }//w w w .j  a v a 2 s  . com
    return handleResultFuture(Futures.allAsList(bulkResults));
}

From source file:org.opendaylight.openflowplugin.impl.statistics.StatisticsGatheringUtils.java

public static ListenableFuture<Boolean> gatherStatistics(final StatisticsGatherer statisticsGatheringService,
        final DeviceContext deviceContext, final MultipartType type) {
    final String deviceId = deviceContext.getPrimaryConnectionContext().getNodeId().toString();
    EventIdentifier wholeProcessEventIdentifier = null;
    if (MultipartType.OFPMPFLOW.equals(type)) {
        wholeProcessEventIdentifier = new EventIdentifier(type.toString(), deviceId);
        EventsTimeCounter.markStart(wholeProcessEventIdentifier);
    }/*w w w  . j  av  a  2  s . c o  m*/
    EventIdentifier ofpQueuToRequestContextEventIdentifier = new EventIdentifier(
            QUEUE2_REQCTX + type.toString(), deviceId);
    final ListenableFuture<RpcResult<List<MultipartReply>>> statisticsDataInFuture = JdkFutureAdapters
            .listenInPoolThread(statisticsGatheringService
                    .getStatisticsOfType(ofpQueuToRequestContextEventIdentifier, type));
    return transformAndStoreStatisticsData(statisticsDataInFuture, deviceContext, wholeProcessEventIdentifier,
            type);
}

From source file:org.opendaylight.controller.md.statistics.manager.impl.StatRpcMsgManagerImpl.java

@Override
public <T extends TransactionAware, D extends DataObject> void registrationRpcFutureCallBack(
        final Future<RpcResult<T>> future, final D inputObj, final NodeRef nodeRef) {

    Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future),
            new FutureCallback<RpcResult<? extends TransactionAware>>() {

                @Override//from   w  w w . jav a  2 s .  c om
                public void onSuccess(final RpcResult<? extends TransactionAware> result) {
                    final TransactionId id = result.getResult().getTransactionId();
                    if (id == null) {
                        LOG.warn("No protocol support");
                    } else {
                        final NodeKey nodeKey = nodeRef.getValue().firstKeyOf(Node.class, NodeKey.class);
                        final String cacheKey = buildCacheKey(id, nodeKey.getId());
                        final TransactionCacheContainer<? super TransactionAware> container = new TransactionCacheContainerImpl<>(
                                id, inputObj, nodeKey.getId());
                        txCache.put(cacheKey, container);
                    }
                }

                @Override
                public void onFailure(final Throwable t) {
                    LOG.warn("Response Registration for Statistics RPC call fail!", t);
                }

            });
}