Example usage for com.google.common.util.concurrent AsyncFunction AsyncFunction

List of usage examples for com.google.common.util.concurrent AsyncFunction AsyncFunction

Introduction

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

Prototype

AsyncFunction

Source Link

Usage

From source file:com.microsoftopentechnologies.intellij.helpers.o365.Office365RestAPIManager.java

private ListenableFuture<Application> createServicePrincipalForApp(final Application application)
        throws ParseException {
    ServicePrincipal servicePrincipal = new ServicePrincipal();
    servicePrincipal.setappId(application.getappId());
    ;//  w  ww . java2  s  .co m
    servicePrincipal.setaccountEnabled(true);

    return Futures.transform(getDirectoryClient().getservicePrincipals().add(servicePrincipal),
            new AsyncFunction<ServicePrincipal, Application>() {
                @Override
                public ListenableFuture<Application> apply(ServicePrincipal servicePrincipal) throws Exception {
                    return Futures.immediateFuture(application);
                }
            });
}

From source file:org.opendaylight.faas.fabric.general.FabricServiceAPIProvider.java

@Override
public Future<RpcResult<Void>> delAcl(DelAclInput input) {
    String aclName = input.getAclName();
    FabricId fabricId = input.getFabricId();
    NodeId ldev = input.getLogicalDevice();
    TpId tpid = input.getLogicalPort();//  w  w  w. ja v  a 2  s.  c  om

    final FabricInstance fabricObj = FabricInstanceCache.INSTANCE.retrieveFabric(fabricId);
    if (fabricObj == null) {
        return Futures.immediateFailedFuture(
                new IllegalArgumentException(String.format("fabric %s does not exist", fabricId)));
    }

    InstanceIdentifier<FabricAcl> aclIId = null;

    if (tpid != null) {
        aclIId = MdSalUtils.createLogicPortIId(fabricId, ldev, tpid).augmentation(LogicalPortAugment.class)
                .child(LportAttribute.class).child(FabricAcl.class, new FabricAclKey(aclName));
    } else {
        aclIId = MdSalUtils.createNodeIId(fabricId, ldev).augmentation(LogicalSwitchAugment.class)
                .child(LswAttribute.class).child(FabricAcl.class, new FabricAclKey(aclName));
    }
    final InstanceIdentifier<FabricAcl> tgtAclIId = aclIId;

    WriteTransaction trans = dataBroker.newWriteOnlyTransaction();
    trans.delete(LogicalDatastoreType.OPERATIONAL, aclIId);

    return Futures.transform(trans.submit(), new AsyncFunction<Void, RpcResult<Void>>() {

        @Override
        public ListenableFuture<RpcResult<Void>> apply(Void submitResult) throws Exception {
            fabricObj.notifyAclUpdated(tgtAclIId, true);
            return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
        }
    }, executor);
}

From source file:org.opendaylight.faas.fabric.general.FabricServiceAPIProvider.java

@Override
public Future<RpcResult<Void>> addPortFunction(AddPortFunctionInput input) {
    final PortFunction function = input.getPortFunction();
    FabricId fabricId = input.getFabricId();
    TpId tpid = input.getLogicalPort();//from   w  w  w.ja va  2 s . c  o  m
    NodeId ldev = input.getLogicalDevice();

    final FabricInstance fabricObj = FabricInstanceCache.INSTANCE.retrieveFabric(fabricId);
    if (fabricObj == null) {
        return Futures.immediateFailedFuture(
                new IllegalArgumentException(String.format("fabric %s does not exist", fabricId)));
    }

    final InstanceIdentifier<PortFunction> fncIId = MdSalUtils.createLogicPortIId(fabricId, ldev, tpid)
            .augmentation(LogicalPortAugment.class).child(LportAttribute.class).child(PortFunction.class);

    WriteTransaction trans = dataBroker.newWriteOnlyTransaction();
    trans.merge(LogicalDatastoreType.OPERATIONAL, fncIId, function, false);

    return Futures.transform(trans.submit(), new AsyncFunction<Void, RpcResult<Void>>() {

        @Override
        public ListenableFuture<RpcResult<Void>> apply(Void submitResult) throws Exception {
            fabricObj.notifyPortFuncUpdated(fncIId, function, false);
            return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
        }
    }, executor);
}

From source file:com.microsoftopentechnologies.intellij.helpers.o365.Office365RestAPIManager.java

@Override
public ListenableFuture<List<ServicePrincipal>> getO365ServicePrincipalsForApp(
        @NotNull final Application application) throws ParseException {
    return requestWithToken(new RequestCallback<List<ServicePrincipal>>() {
        @Override// www.ja  v a 2s. c om
        public ListenableFuture<List<ServicePrincipal>> execute() throws ParseException {
            @SuppressWarnings("unchecked")
            ListenableFuture<List<ServicePrincipal>>[] futures = new ListenableFuture[] {
                    getServicePrincipalsForApp(application), getServicePrincipalsForO365() };

            final String[] filterAppIds = new String[] { ServiceAppIds.SHARE_POINT, ServiceAppIds.EXCHANGE,
                    ServiceAppIds.AZURE_ACTIVE_DIRECTORY };

            return Futures.transform(Futures.allAsList(futures),
                    new AsyncFunction<List<List<ServicePrincipal>>, List<ServicePrincipal>>() {
                        @Override
                        public ListenableFuture<List<ServicePrincipal>> apply(
                                List<List<ServicePrincipal>> lists) throws Exception {
                            // According to Guava documentation for allAsList, the list of results is in the
                            // same order as the input list. So first we get the service principals for the app
                            // filtered for O365 and Graph service principals.
                            final List<ServicePrincipal> servicePrincipalsForApp = Lists.newArrayList(
                                    Iterables.filter(lists.get(0), new Predicate<ServicePrincipal>() {
                                        @Override
                                        public boolean apply(final ServicePrincipal servicePrincipal) {
                                            // we are only interested in O365 and Graph service principals
                                            return Iterators.any(Iterators.forArray(filterAppIds),
                                                    new Predicate<String>() {
                                                        @Override
                                                        public boolean apply(String appId) {
                                                            return appId.equals(servicePrincipal.getappId());
                                                        }
                                                    });
                                        }
                                    }));

                            // next we get the O365/graph service principals
                            final List<ServicePrincipal> servicePrincipalsForO365 = lists.get(1);

                            // then we add service principals from servicePrincipalsForO365 to servicePrincipalsForApp
                            // where the service principal is not available in the latter
                            Iterable<ServicePrincipal> servicePrincipalsToBeAdded = Iterables
                                    .filter(servicePrincipalsForO365, new Predicate<ServicePrincipal>() {
                                        @Override
                                        public boolean apply(ServicePrincipal servicePrincipal) {
                                            return !servicePrincipalsForApp.contains(servicePrincipal);
                                        }
                                    });
                            Iterables.addAll(servicePrincipalsForApp, servicePrincipalsToBeAdded);

                            // assign the appid to the service principal and reset permissions on new service principals;
                            // we do Lists.newArrayList calls below to create a copy of the service lists because Lists.transform
                            // invokes the transformation function lazily and this causes problems for us; we force immediate
                            // evaluation of our transfomer by copying the elements to a new list
                            List<ServicePrincipal> servicePrincipals = Lists
                                    .newArrayList(Lists.transform(servicePrincipalsForApp,
                                            new Function<ServicePrincipal, ServicePrincipal>() {
                                                @Override
                                                public ServicePrincipal apply(
                                                        ServicePrincipal servicePrincipal) {
                                                    if (!servicePrincipal.getappId()
                                                            .equals(application.getappId())) {
                                                        servicePrincipal.setappId(application.getappId());
                                                        servicePrincipal.setoauth2Permissions(
                                                                Lists.newArrayList(Lists.transform(
                                                                        servicePrincipal.getoauth2Permissions(),
                                                                        new Function<OAuth2Permission, OAuth2Permission>() {
                                                                            @Override
                                                                            public OAuth2Permission apply(
                                                                                    OAuth2Permission oAuth2Permission) {
                                                                                oAuth2Permission
                                                                                        .setisEnabled(false);
                                                                                return oAuth2Permission;
                                                                            }
                                                                        })));
                                                    }

                                                    return servicePrincipal;
                                                }
                                            }));

                            return Futures.immediateFuture(servicePrincipals);
                        }
                    });
        }
    });
}

From source file:org.opendaylight.centinel.impl.CentinelStreamImpl.java

@Override
public Future<RpcResult<PauseStreamOutput>> pauseStream(final PauseStreamInput input) {
    final ReadWriteTransaction tx = dataProvider.newReadWriteTransaction();
    final SettableFuture<RpcResult<PauseStreamOutput>> futureResult = SettableFuture.create();
    boolean idMatches = false;
    if (input.getStreamID() == null || input.getStreamID().isEmpty() || input.getStreamID().trim().isEmpty()) {
        LOG.debug("STREAM ID CANNOT BE NULL");
        return Futures.immediateFailedCheckedFuture(
                new TransactionCommitFailedException("invalid-input", streamIdcannotbenullError()));
    }/*from  w  ww.  j  av  a 2  s.  c o  m*/
    final PauseStreamOutputBuilder pauseStreamOutputBuilder = new PauseStreamOutputBuilder();
    pauseStreamOutputBuilder.setDisabled("true");
    ListenableFuture<Optional<StreamRecord>> readFutureOperational = tx.read(LogicalDatastoreType.OPERATIONAL,
            streamRecordId);

    ListenableFuture<Optional<StreamRecord>> readFutureConfigure = tx.read(LogicalDatastoreType.CONFIGURATION,
            streamRecordId);

    String configId = null;
    String opStreamId = null;

    try {
        Optional<StreamRecord> record = readFutureOperational.get();
        if (record.isPresent()) {
            StreamRecord operationalRecord = readFutureOperational.get().get();
            List<StreamList> streamRulesList = new ArrayList<StreamList>();

            if (!operationalRecord.getStreamList().isEmpty()) {

                streamRulesList = operationalRecord.getStreamList();
                Iterator<StreamList> iterator = streamRulesList.iterator();

                while (iterator.hasNext()) {

                    StreamList operationalObject = iterator.next();

                    if (operationalObject.getStreamID().equals(input.getStreamID())) {
                        configId = operationalObject.getConfigID();
                        opStreamId = operationalObject.getStreamID();
                        idMatches = true;

                    }
                }
                if (!idMatches) {
                    return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException(
                            "invalid-input", RpcResultBuilder.newError(ErrorType.APPLICATION, "invalid-input",
                                    "Invalid Stream id or The stream is not present in operational data store")));

                }

            }
        } else {
            return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("invalid-input",
                    RpcResultBuilder.newError(ErrorType.APPLICATION, "invalid-input",
                            "Record is not present in operational data store")));
        }
    }

    catch (InterruptedException | ExecutionException e) {

        futureResult.set(RpcResultBuilder.<PauseStreamOutput>failed()
                .withRpcErrors(((TransactionCommitFailedException) e).getErrorList()).build());
        return futureResult;

    }

    final String confID = configId;
    final String opStrmId = opStreamId;

    final ListenableFuture<Void> commitFuture = Futures.transform(readFutureConfigure,
            new AsyncFunction<Optional<StreamRecord>, Void>() {

                @Override
                public ListenableFuture<Void> apply(final Optional<StreamRecord> streamRulesRecord)
                        throws Exception {

                    List<StreamList> streamRuleList = new ArrayList<StreamList>();
                    List<StreamList> updatedStreamRuleList = new ArrayList<StreamList>();

                    if (streamRulesRecord.isPresent()) {

                        streamRuleList = streamRulesRecord.get().getStreamList();
                        StreamList configObject = null;
                        Iterator<StreamList> iterator = streamRuleList.iterator();

                        while (iterator.hasNext()) {

                            configObject = iterator.next();

                            if (configObject.getConfigID().equalsIgnoreCase(confID)) {

                                updatedStreamRuleList
                                        .add(buildPausedStreamListRecord(configObject, opStrmId, input));

                                tx.merge(LogicalDatastoreType.CONFIGURATION, streamRecordId,
                                        new StreamRecordBuilder().setStreamList(updatedStreamRuleList).build());

                            }
                        }

                    }

                    return tx.submit();
                }

            });
    Futures.addCallback(commitFuture, new FutureCallback<Void>() {
        @Override
        public void onSuccess(final Void result) {

            futureResult
                    .set(RpcResultBuilder.<PauseStreamOutput>success(pauseStreamOutputBuilder.build()).build());

        }

        @Override
        public void onFailure(final Throwable ex) {

            LOG.debug("Failed to commit Rule", ex);

            futureResult.set(RpcResultBuilder.<PauseStreamOutput>failed()
                    .withRpcErrors(((TransactionCommitFailedException) ex).getErrorList()).build());

        }
    });

    return futureResult;
}

From source file:org.opendaylight.faas.fabric.general.FabricServiceAPIProvider.java

@Override
public Future<RpcResult<Void>> addStaticRoute(AddStaticRouteInput input) {
    final List<Route> routes = input.getRoute();
    FabricId fabricId = input.getFabricId();
    NodeId ldev = input.getNodeId();/*from w w  w.j a  va 2  s .  co  m*/

    final FabricInstance fabricObj = FabricInstanceCache.INSTANCE.retrieveFabric(fabricId);
    if (fabricObj == null) {
        return Futures.immediateFailedFuture(
                new IllegalArgumentException(String.format("fabric %s does not exist", fabricId)));
    }

    for (Route route : routes) {
        if (route.getNextHopOptions() == null) {
            return Futures.immediateFailedFuture(new IllegalArgumentException(String.format(
                    "next hop is required. (destination = %s)", route.getDestinationPrefix().getValue())));
        }
    }

    final InstanceIdentifier<Routes> routesIId = MdSalUtils.createNodeIId(fabricId, ldev)
            .augmentation(LogicalRouterAugment.class).child(LrAttribute.class).child(Routes.class);

    final List<InstanceIdentifier<Route>> routeKeys = Lists.newArrayList();
    for (Route route : routes) {
        routeKeys.add(routesIId.child(Route.class, route.getKey()));
    }

    RoutesBuilder builder = new RoutesBuilder();
    builder.setRoute(routes);

    WriteTransaction trans = dataBroker.newWriteOnlyTransaction();
    trans.merge(LogicalDatastoreType.OPERATIONAL, routesIId, builder.build(), true);

    return Futures.transform(trans.submit(), new AsyncFunction<Void, RpcResult<Void>>() {

        @Override
        public ListenableFuture<RpcResult<Void>> apply(Void submitResult) throws Exception {
            fabricObj.notifyRouteUpdated(routesIId.firstIdentifierOf(Node.class), routes, false);
            return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
        }
    }, executor);
}

From source file:org.opendaylight.centinel.impl.CentinelImpl.java

/** 
 *    Update Alert Message Count Rule in configurational data store. 
 * //from   ww  w.  jav  a  2 s . c o  m
 */

@Override
public Future<RpcResult<UpdateAlertMessageCountRuleOutput>> updateAlertMessageCountRule(
        final UpdateAlertMessageCountRuleInput input) {
    final ReadWriteTransaction tx = dataProvider.newReadWriteTransaction();
    final SettableFuture<RpcResult<UpdateAlertMessageCountRuleOutput>> futureResult = SettableFuture.create();
    LOG.info("updateAlertMessageCountRule: " + input);
    final UpdateAlertMessageCountRuleOutputBuilder updateAlertMessageCountRuleOutputBuilder = new UpdateAlertMessageCountRuleOutputBuilder();
    updateAlertMessageCountRuleOutputBuilder.setMessageCountOperator(input.getMessageCountOperator());
    updateAlertMessageCountRuleOutputBuilder.setMessageCountCount(input.getMessageCountCount());
    updateAlertMessageCountRuleOutputBuilder.setMessageCountGrace(input.getMessageCountGrace());
    updateAlertMessageCountRuleOutputBuilder.setMessageCountBacklog(input.getMessageCountBacklog());
    updateAlertMessageCountRuleOutputBuilder.setRuleID(input.getRuleID());
    updateAlertMessageCountRuleOutputBuilder.setNodeType(input.getNodeType());
    updateAlertMessageCountRuleOutputBuilder.setRuleTypeClassifier(input.getRuleTypeClassifier());
    updateAlertMessageCountRuleOutputBuilder.setStreamID(input.getStreamID());
    updateAlertMessageCountRuleOutputBuilder.setTimeStamp(input.getTimeStamp());
    updateAlertMessageCountRuleOutputBuilder.setAlertTypeClassifier(input.getAlertTypeClassifier());

    ListenableFuture<Optional<AlertMessageCountRuleRecord>> readFutureOperational = tx
            .read(LogicalDatastoreType.OPERATIONAL, alertMessageCountRuleRecordId);

    ListenableFuture<Optional<AlertMessageCountRuleRecord>> readFutureConfigure = tx
            .read(LogicalDatastoreType.CONFIGURATION, alertMessageCountRuleRecordId);

    String configId = null;

    try {

        AlertMessageCountRuleRecord operationalRecord = readFutureOperational.get().get();
        List<StreamAlertMessageCountRuleList> streamAlertRuleList = new ArrayList<StreamAlertMessageCountRuleList>();

        if (!operationalRecord.getStreamAlertMessageCountRuleList().isEmpty()) {

            streamAlertRuleList = operationalRecord.getStreamAlertMessageCountRuleList();
            Iterator<StreamAlertMessageCountRuleList> itearator = streamAlertRuleList.iterator();

            StreamAlertMessageCountRuleList operationalObject = null;

            while (itearator.hasNext()) {

                operationalObject = itearator.next();
                if (operationalObject.getRuleID().equalsIgnoreCase(input.getRuleID())
                        && operationalObject.getStreamID().equalsIgnoreCase(input.getStreamID())) {

                    configId = operationalObject.getConfigID();

                }
            }

        }

    } catch (InterruptedException | ExecutionException e) {

        futureResult.set(RpcResultBuilder.<UpdateAlertMessageCountRuleOutput>failed()
                .withRpcErrors(((TransactionCommitFailedException) e).getErrorList()).build());
        return futureResult;

    }
    final String configID = configId;

    final ListenableFuture<Void> commitFuture = Futures.transform(readFutureConfigure,
            new AsyncFunction<Optional<AlertMessageCountRuleRecord>, Void>() {

                @Override
                public ListenableFuture<Void> apply(
                        final Optional<AlertMessageCountRuleRecord> alertMessageCountRuleRecord)
                        throws Exception {

                    List<StreamAlertMessageCountRuleList> streamAlertRuleList = new ArrayList<StreamAlertMessageCountRuleList>();
                    List<StreamAlertMessageCountRuleList> updatedStreamAlertRuleList = new ArrayList<StreamAlertMessageCountRuleList>();

                    if (alertMessageCountRuleRecord.isPresent()) {

                        streamAlertRuleList = alertMessageCountRuleRecord.get()
                                .getStreamAlertMessageCountRuleList();
                        StreamAlertMessageCountRuleList configObject = null;
                        Iterator<StreamAlertMessageCountRuleList> iterator = streamAlertRuleList.iterator();

                        while (iterator.hasNext()) {

                            configObject = iterator.next();

                            if (configObject.getConfigID().equalsIgnoreCase(configID)) {

                                updatedStreamAlertRuleList
                                        .add(buildUpdateAlertMessageCountRuleRecord(input, configObject));
                                tx.merge(LogicalDatastoreType.CONFIGURATION, alertMessageCountRuleRecordId,
                                        new AlertMessageCountRuleRecordBuilder()
                                                .setStreamAlertMessageCountRuleList(updatedStreamAlertRuleList)
                                                .build());

                            }
                        }

                    }

                    return tx.submit();
                }

            });
    Futures.addCallback(commitFuture, new FutureCallback<Void>() {
        @Override
        public void onSuccess(final Void result) {

            futureResult.set(RpcResultBuilder.<UpdateAlertMessageCountRuleOutput>success(
                    updateAlertMessageCountRuleOutputBuilder.build()).build());
        }

        @Override
        public void onFailure(final Throwable ex) {

            LOG.debug("Failed to commit Rule", ex);

            futureResult.set(RpcResultBuilder.<UpdateAlertMessageCountRuleOutput>failed()
                    .withRpcErrors(((TransactionCommitFailedException) ex).getErrorList()).build());

        }
    });

    return futureResult;
}

From source file:org.opendaylight.faas.fabric.general.FabricServiceAPIProvider.java

@Override
public Future<RpcResult<Void>> portBindingLogicalToFabric(PortBindingLogicalToFabricInput input) {

    FabricId fabricId = input.getFabricId();
    TpId tpid = input.getLogicalPort();/*ww  w.ja v  a 2s  . com*/
    NodeId ldev = input.getLogicalDevice();
    TpId portId = input.getFabricPort();

    final FabricInstance fabricObj = FabricInstanceCache.INSTANCE.retrieveFabric(fabricId);
    if (fabricObj == null) {
        return Futures.immediateFailedFuture(
                new IllegalArgumentException(String.format("fabric %s does not exist", fabricId)));
    }

    final InstanceIdentifier<LportAttribute> attrIId = MdSalUtils.createLogicPortIId(fabricId, ldev, tpid)
            .augmentation(LogicalPortAugment.class).child(LportAttribute.class);

    LportAttributeBuilder builder = new LportAttributeBuilder();
    builder.setPortLayer(
            new PortLayerBuilder().setLayer1Info(new Layer1InfoBuilder().setLocation(portId).build()).build());

    WriteTransaction trans = dataBroker.newWriteOnlyTransaction();
    trans.merge(LogicalDatastoreType.OPERATIONAL, attrIId, builder.build(), false);

    return Futures.transform(trans.submit(), new AsyncFunction<Void, RpcResult<Void>>() {

        @Override
        public ListenableFuture<RpcResult<Void>> apply(Void submitResult) throws Exception {
            fabricObj.notifyLogicalPortLocated(attrIId.firstIdentifierOf(TerminationPoint.class), portId);
            return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
        }
    }, executor);
}

From source file:org.opendaylight.faas.fabric.general.FabricServiceAPIProvider.java

@Override
public Future<RpcResult<Void>> portBindingLogicalToDevice(PortBindingLogicalToDeviceInput input) {

    FabricId fabricId = input.getFabricId();
    TpId tpid = input.getLogicalPort();/* www.  j a  v  a 2s  .c o m*/
    NodeId ldev = input.getLogicalDevice();
    TpRef physicalPort = input.getPhysicalPort();

    final FabricInstance fabricObj = FabricInstanceCache.INSTANCE.retrieveFabric(fabricId);
    if (fabricObj == null) {
        return Futures.immediateFailedFuture(
                new IllegalArgumentException(String.format("fabric %s does not exist", fabricId)));
    }

    @SuppressWarnings("unchecked")
    InstanceIdentifier<TerminationPoint> fportIid = InterfaceManager.convDevPort2FabricPort(dataBroker,
            fabricId, (InstanceIdentifier<TerminationPoint>) physicalPort.getValue());
    final TpId portId = fportIid.firstKeyOf(TerminationPoint.class).getTpId();

    final InstanceIdentifier<LportAttribute> attrIId = MdSalUtils.createLogicPortIId(fabricId, ldev, tpid)
            .augmentation(LogicalPortAugment.class).child(LportAttribute.class);

    LportAttributeBuilder builder = new LportAttributeBuilder();
    builder.setPortLayer(
            new PortLayerBuilder()
                    .setLayer1Info(new Layer1InfoBuilder()
                            .setLocation(fportIid.firstKeyOf(TerminationPoint.class).getTpId()).build())
                    .build());

    WriteTransaction trans = dataBroker.newWriteOnlyTransaction();
    trans.merge(LogicalDatastoreType.OPERATIONAL, attrIId, builder.build(), false);

    return Futures.transform(trans.submit(), new AsyncFunction<Void, RpcResult<Void>>() {

        @Override
        public ListenableFuture<RpcResult<Void>> apply(Void submitResult) throws Exception {
            fabricObj.notifyLogicalPortLocated(attrIId.firstIdentifierOf(TerminationPoint.class), portId);
            return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
        }
    }, executor);
}

From source file:org.opendaylight.centinel.impl.CentinelStreamImpl.java

@Override
public Future<RpcResult<ResumeStreamOutput>> resumeStream(final ResumeStreamInput input) {
    final ReadWriteTransaction tx = dataProvider.newReadWriteTransaction();
    final SettableFuture<RpcResult<ResumeStreamOutput>> futureResult = SettableFuture.create();
    boolean idMatches = false;
    if (input.getStreamID() == null || input.getStreamID().isEmpty() || input.getStreamID().trim().isEmpty()) {
        LOG.debug("STREAM ID CANNOT BE NULL");
        return Futures.immediateFailedCheckedFuture(
                new TransactionCommitFailedException("invalid-input", streamIdcannotbenullError()));
    }/* w  w w.  j a v  a  2  s .c o m*/
    final ResumeStreamOutputBuilder resumeStreamOutputBuilder = new ResumeStreamOutputBuilder();
    resumeStreamOutputBuilder.setDisabled("false");
    ListenableFuture<Optional<StreamRecord>> readFutureOperational = tx.read(LogicalDatastoreType.OPERATIONAL,
            streamRecordId);

    ListenableFuture<Optional<StreamRecord>> readFutureConfigure = tx.read(LogicalDatastoreType.CONFIGURATION,
            streamRecordId);

    String configId = null;
    String opStrmId = null;

    try {
        Optional<StreamRecord> record = readFutureOperational.get();
        if (record.isPresent()) {
            StreamRecord operationalRecord = readFutureOperational.get().get();
            List<StreamList> streamRulesList = new ArrayList<StreamList>();

            if (!operationalRecord.getStreamList().isEmpty()) {

                streamRulesList = operationalRecord.getStreamList();
                Iterator<StreamList> iterator = streamRulesList.iterator();

                while (iterator.hasNext()) {

                    StreamList operationalObject = iterator.next();

                    if (operationalObject.getStreamID().equals(input.getStreamID())) {
                        configId = operationalObject.getConfigID();
                        opStrmId = operationalObject.getStreamID();
                        idMatches = true;

                    }
                }
                if (!idMatches) {
                    return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException(
                            "invalid-input", RpcResultBuilder.newError(ErrorType.APPLICATION, "invalid-input",
                                    "Invalid Stream id or The stream is not present in operational data store")));

                }
            }
        } else {
            return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("invalid-input",
                    RpcResultBuilder.newError(ErrorType.APPLICATION, "invalid-input",
                            "Record is not present in operational data store")));
        }

    } catch (InterruptedException | ExecutionException e) {

        futureResult.set(RpcResultBuilder.<ResumeStreamOutput>failed()
                .withRpcErrors(((TransactionCommitFailedException) e).getErrorList()).build());
        return futureResult;
    }
    final String confID = configId;
    final String opStreamId = opStrmId;

    final ListenableFuture<Void> commitFuture = Futures.transform(readFutureConfigure,
            new AsyncFunction<Optional<StreamRecord>, Void>() {

                @Override
                public ListenableFuture<Void> apply(final Optional<StreamRecord> streamRulesRecord)
                        throws Exception {

                    List<StreamList> streamRuleList = new ArrayList<StreamList>();
                    List<StreamList> updatedStreamRuleList = new ArrayList<StreamList>();

                    if (streamRulesRecord.isPresent()) {

                        streamRuleList = streamRulesRecord.get().getStreamList();
                        StreamList configObject = null;
                        Iterator<StreamList> iterator = streamRuleList.iterator();

                        while (iterator.hasNext()) {

                            configObject = iterator.next();

                            if (configObject.getConfigID().equalsIgnoreCase(confID)) {
                                StreamList updatedConfigObj = buildResumedStreamListRecord(configObject,
                                        opStreamId, input);

                                updatedStreamRuleList.add(updatedConfigObj);
                                tx.merge(LogicalDatastoreType.CONFIGURATION, streamRecordId,
                                        new StreamRecordBuilder().setStreamList(updatedStreamRuleList).build());

                            }
                        }

                    }

                    return tx.submit();
                }

            });
    Futures.addCallback(commitFuture, new FutureCallback<Void>() {
        @Override
        public void onSuccess(final Void result) {

            futureResult.set(
                    RpcResultBuilder.<ResumeStreamOutput>success(resumeStreamOutputBuilder.build()).build());
        }

        @Override
        public void onFailure(final Throwable ex) {

            LOG.debug("Failed to commit Rule", ex);

            futureResult.set(RpcResultBuilder.<ResumeStreamOutput>failed()
                    .withRpcErrors(((TransactionCommitFailedException) ex).getErrorList()).build());

        }
    });

    return futureResult;
}