Example usage for com.google.common.util.concurrent ListenableFuture get

List of usage examples for com.google.common.util.concurrent ListenableFuture get

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.util.concurrent.*
  5. ListenableFuture
  6. get

Introduction

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

Prototype

V get() throws InterruptedException, ExecutionException;

Source Link

Document

Waits if necessary for the computation to complete, and then retrieves its result.

Usage

From source file:io.druid.query.GroupByParallelQueryRunner.java

@Override
public Sequence<T> run(final Query<T> queryParam, final Map<String, Object> responseContext) {
    final GroupByQuery query = (GroupByQuery) queryParam;
    final Pair<IncrementalIndex, Accumulator<IncrementalIndex, T>> indexAccumulatorPair = GroupByQueryHelper
            .createIndexAccumulatorPair(query, configSupplier.get(), bufferPool);
    final Pair<Queue, Accumulator<Queue, T>> bySegmentAccumulatorPair = GroupByQueryHelper
            .createBySegmentAccumulatorPair();
    final boolean bySegment = query.getContextBySegment(false);
    final int priority = query.getContextPriority(0);

    ListenableFuture<List<Void>> futures = Futures.allAsList(Lists.newArrayList(
            Iterables.transform(queryables, new Function<QueryRunner<T>, ListenableFuture<Void>>() {
                @Override/*from   w  w w  .j  a va 2  s .com*/
                public ListenableFuture<Void> apply(final QueryRunner<T> input) {
                    if (input == null) {
                        throw new ISE("Null queryRunner! Looks to be some segment unmapping action happening");
                    }

                    return exec.submit(new AbstractPrioritizedCallable<Void>(priority) {
                        @Override
                        public Void call() throws Exception {
                            try {
                                if (bySegment) {
                                    input.run(queryParam, responseContext).accumulate(
                                            bySegmentAccumulatorPair.lhs, bySegmentAccumulatorPair.rhs);
                                } else {
                                    input.run(queryParam, responseContext).accumulate(indexAccumulatorPair.lhs,
                                            indexAccumulatorPair.rhs);
                                }

                                return null;
                            } catch (QueryInterruptedException e) {
                                throw Throwables.propagate(e);
                            } catch (Exception e) {
                                log.error(e, "Exception with one of the sequences!");
                                throw Throwables.propagate(e);
                            }
                        }
                    });
                }
            })));

    // Let the runners complete
    try {
        queryWatcher.registerQuery(query, futures);
        final Number timeout = query.getContextValue(QueryContextKeys.TIMEOUT, (Number) null);
        if (timeout == null) {
            futures.get();
        } else {
            futures.get(timeout.longValue(), TimeUnit.MILLISECONDS);
        }
    } catch (InterruptedException e) {
        log.warn(e, "Query interrupted, cancelling pending results, query id [%s]", query.getId());
        futures.cancel(true);
        indexAccumulatorPair.lhs.close();
        throw new QueryInterruptedException("Query interrupted");
    } catch (CancellationException e) {
        indexAccumulatorPair.lhs.close();
        throw new QueryInterruptedException("Query cancelled");
    } catch (TimeoutException e) {
        indexAccumulatorPair.lhs.close();
        log.info("Query timeout, cancelling pending results for query id [%s]", query.getId());
        futures.cancel(true);
        throw new QueryInterruptedException("Query timeout");
    } catch (ExecutionException e) {
        indexAccumulatorPair.lhs.close();
        throw Throwables.propagate(e.getCause());
    }

    if (bySegment) {
        return Sequences.simple(bySegmentAccumulatorPair.lhs);
    }

    return new ResourceClosingSequence<T>(Sequences.simple(Iterables
            .transform(indexAccumulatorPair.lhs.iterableWithPostAggregations(null), new Function<Row, T>() {
                @Override
                public T apply(Row input) {
                    return (T) input;
                }
            })), indexAccumulatorPair.lhs);
}

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

@Override
public Future<RpcResult<UpdateAlertMessageCountRuleOutput>> updateAlertMessageCountRule(
        final UpdateAlertMessageCountRuleInput input) {
    boolean idMatches = false;
    final ReadWriteTransaction tx = dataProvider.newReadWriteTransaction();
    final SettableFuture<RpcResult<UpdateAlertMessageCountRuleOutput>> futureResult = SettableFuture.create();
    if (input.getStreamID() == null || input.getStreamID().isEmpty() || input.getStreamID().trim().isEmpty()
            || input.getRuleID() == null || input.getRuleID().isEmpty() || input.getRuleID().trim().isEmpty()) {
        LOG.debug("Invalid Parameters for UpdateAlertMessageCountRule");
        return Futures.immediateFailedCheckedFuture(
                new TransactionCommitFailedException("inalid-input", RpcResultBuilder.newError(
                        ErrorType.APPLICATION, "invalid-input", "StreamId and RuleId are mandatory fields")));
    }//w w w.j  a v  a  2s  .  c  o  m
    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());
    updateAlertMessageCountRuleOutputBuilder.setAlertName(input.getAlertName());

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

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

    String configId = null;

    try {

        Optional<AlertMessageCountRuleRecord> record = readFutureOperational.get();
        if (record.isPresent()) {
            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();
                        idMatches = true;

                    }
                }
                if (!idMatches) {
                    return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException(
                            "invalid-input", RpcResultBuilder.newError(ErrorType.APPLICATION, "invalid-input",
                                    "Invalid Stream/Rule id or The stream/Rule 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.<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.info("Failed to commit Rule", ex);

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

        }
    });

    return futureResult;
}

From source file:org.opendaylight.ovsdb.plugin.ConfigurationService.java

private StatusWithUuid _insertTableRow(Node node, TransactBuilder transaction, Integer insertIndex,
        String insertErrorMsg, String rowName) {

    try {//from w  w  w  .java2s . c o m
        //Check for connection before calling RPC to perform transaction
        if (connectionService == null) {
            logger.error("Couldn't refer to the ConnectionService");
            return new StatusWithUuid(StatusCode.NOSERVICE);
        }

        Connection connection = this.getConnection(node);
        if (connection == null) {
            return new StatusWithUuid(StatusCode.NOSERVICE, "Connection to ovsdb-server not available");
        }

        ListenableFuture<List<OperationResult>> transResponse = connection.getRpc().transact(transaction);
        List<OperationResult> tr = transResponse.get();
        List<Operation> requests = transaction.getRequests();
        StatusWithUuid status = new StatusWithUuid(StatusCode.SUCCESS);
        for (int i = 0; i < tr.size(); i++) {
            if (i < requests.size())
                requests.get(i).setResult(tr.get(i));
            if (tr.get(i) != null && tr.get(i).getError() != null && tr.get(i).getError().trim().length() > 0) {
                OperationResult result = tr.get(i);
                status = new StatusWithUuid(StatusCode.BADREQUEST,
                        result.getError() + " : " + result.getDetails());
            }
        }

        if (tr.size() > requests.size()) {
            OperationResult result = tr.get(tr.size() - 1);
            logger.error("Error creating {} : {}\n Error : {}\n Details : {}", insertErrorMsg, rowName,
                    result.getError(), result.getDetails());
            status = new StatusWithUuid(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
        }
        if (status.isSuccess()) {
            if (insertIndex >= 0 && insertIndex < tr.size() && tr.get(insertIndex) != null) {
                UUID uuid = tr.get(insertIndex).getUuid();
                status = new StatusWithUuid(StatusCode.SUCCESS, uuid);
            } else {
                // We can't get the uuid from the transact as the insertIndex is invalid or -1
                // return null uuid.
                status = new StatusWithUuid(StatusCode.SUCCESS, (UUID) null);
            }
        }
        return status;
    } catch (Exception e) {
        logger.error("Error in _insertTableRow(): ", e);
    }
    return new StatusWithUuid(StatusCode.INTERNALERROR);
}

From source file:org.opendaylight.ovsdb.plugin.ConfigurationService.java

@Override
public Status updateRow(Node node, String tableName, String parentUUID, String rowUUID, Table<?> row) {
    try {/*w  ww .  ja va2s. c o  m*/
        if (connectionService == null) {
            logger.error("Couldn't refer to the ConnectionService");
            return new Status(StatusCode.NOSERVICE);
        }

        Connection connection = this.getConnection(node);
        if (connection == null) {
            return new Status(StatusCode.NOSERVICE, "Connection to ovsdb-server not available");
        }

        Map<String, Table<?>> ovsTable = inventoryServiceInternal.getTableCache(node,
                Open_vSwitch.NAME.getName());

        if (ovsTable == null) {
            return new Status(StatusCode.NOTFOUND,
                    "There are no Open_vSwitch instance in the Open_vSwitch table");
        }

        UUID uuid = new UUID(rowUUID);
        Condition condition = new Condition("_uuid", Function.EQUALS, uuid);
        List<Condition> where = new ArrayList<Condition>();
        where.add(condition);
        Operation updateRequest = new UpdateOperation(tableName, where, row);

        TransactBuilder transaction = new TransactBuilder();
        transaction.addOperations(new ArrayList<Operation>(Arrays.asList(updateRequest)));

        ListenableFuture<List<OperationResult>> transResponse = connection.getRpc().transact(transaction);
        List<OperationResult> tr = transResponse.get();
        List<Operation> requests = transaction.getRequests();
        Status status = new Status(StatusCode.SUCCESS);
        for (int i = 0; i < tr.size(); i++) {
            if (i < requests.size())
                requests.get(i).setResult(tr.get(i));
            if (tr.get(i) != null && tr.get(i).getError() != null && tr.get(i).getError().trim().length() > 0) {
                OperationResult result = tr.get(i);
                status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
            }
        }

        if (tr.size() > requests.size()) {
            OperationResult result = tr.get(tr.size() - 1);
            logger.error("Error Updating Row : {}/{}\n Error : {}\n Details : {}", tableName, row,
                    result.getError(), result.getDetails());
            status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
        }
        if (status.isSuccess()) {
            status = new Status(StatusCode.SUCCESS);
        }
        return status;
    } catch (Exception e) {
        logger.error("Error in updateRow(): ", e);
    }
    return new Status(StatusCode.INTERNALERROR);
}

From source file:org.opendaylight.ovsdb.plugin.ConfigurationService.java

@Override
public Status deleteBridgeDomain(Node node, String bridgeIdentifier) {

    try {// www.j  a v a2s. com
        if (connectionService == null) {
            logger.error("Couldn't refer to the ConnectionService");
            return new Status(StatusCode.NOSERVICE);
        }
        Connection connection = this.getConnection(node);
        if (connection == null) {
            return new Status(StatusCode.NOSERVICE, "Connection to ovsdb-server not available");
        }
        Map<String, Table<?>> ovsTable = inventoryServiceInternal.getTableCache(node,
                Open_vSwitch.NAME.getName());
        Map<String, Table<?>> brTable = inventoryServiceInternal.getTableCache(node, Bridge.NAME.getName());
        Operation delBrRequest = null;
        String ovsUuid = null;
        String brUuid = null;

        if (brTable != null) {
            for (String uuid : brTable.keySet()) {
                Bridge bridge = (Bridge) brTable.get(uuid);
                if (bridge.getName().contains(bridgeIdentifier)) {
                    brUuid = uuid;
                }
            }
        }
        if (ovsTable != null) {
            ovsUuid = (String) ovsTable.keySet().toArray()[0];
        }
        UUID bridgeUuidPair = new UUID(brUuid);
        Mutation bm = new Mutation("bridges", Mutator.DELETE, bridgeUuidPair);
        List<Mutation> mutations = new ArrayList<Mutation>();
        mutations.add(bm);

        UUID uuid = new UUID(ovsUuid);
        Condition condition = new Condition("_uuid", Function.EQUALS, uuid);
        List<Condition> where = new ArrayList<Condition>();
        where.add(condition);
        delBrRequest = new MutateOperation(Open_vSwitch.NAME.getName(), where, mutations);

        TransactBuilder transaction = new TransactBuilder();
        transaction.addOperations(new ArrayList<Operation>(Arrays.asList(delBrRequest)));

        ListenableFuture<List<OperationResult>> transResponse = connection.getRpc().transact(transaction);
        List<OperationResult> tr = transResponse.get();
        List<Operation> requests = transaction.getRequests();
        Status status = new Status(StatusCode.SUCCESS);
        for (int i = 0; i < tr.size(); i++) {
            if (i < requests.size())
                requests.get(i).setResult(tr.get(i));
            if (tr.get(i) != null && tr.get(i).getError() != null && tr.get(i).getError().trim().length() > 0) {
                OperationResult result = tr.get(i);
                status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
            }
        }

        if (tr.size() > requests.size()) {
            OperationResult result = tr.get(tr.size() - 1);
            logger.error("Error deleting Bridge : {}\n Error : {}\n Details : {}", bridgeIdentifier,
                    result.getError(), result.getDetails());
            status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
        }
        return status;
    } catch (Exception e) {
        logger.error("Error in deleteBridgeDomain(): ", e);
    }
    return new Status(StatusCode.INTERNALERROR);
}

From source file:org.opendaylight.ovsdb.plugin.ConfigurationService.java

@Override
public Status deletePort(Node node, String bridgeIdentifier, String portIdentifier) {

    try {/*from  w  ww .  ja  v  a 2  s .c  om*/
        if (connectionService == null) {
            logger.error("Couldn't refer to the ConnectionService");
            return new Status(StatusCode.NOSERVICE);
        }

        Connection connection = this.getConnection(node);
        if (connection == null) {
            return new Status(StatusCode.NOSERVICE, "Connection to ovsdb-server not available");
        }

        Map<String, Table<?>> brTable = inventoryServiceInternal.getTableCache(node, Bridge.NAME.getName());
        Map<String, Table<?>> portTable = inventoryServiceInternal.getTableCache(node, Port.NAME.getName());
        Operation delPortRequest = null;
        String brUuid = null;
        String portUuid = null;
        if (brTable != null) {
            for (String uuid : brTable.keySet()) {
                Bridge bridge = (Bridge) brTable.get(uuid);
                if (bridge.getName().contains(bridgeIdentifier)) {
                    brUuid = uuid;
                }
            }
        }
        if (portTable != null) {
            for (String uuid : portTable.keySet()) {
                Port port = (Port) portTable.get(uuid);
                if (port.getName().contains(portIdentifier)) {
                    portUuid = uuid;
                }
            }
        }

        UUID portUuidPair = new UUID(portUuid);
        Mutation bm = new Mutation("ports", Mutator.DELETE, portUuidPair);
        List<Mutation> mutations = new ArrayList<Mutation>();
        mutations.add(bm);

        UUID uuid = new UUID(brUuid);
        Condition condition = new Condition("_uuid", Function.EQUALS, uuid);
        List<Condition> where = new ArrayList<Condition>();
        where.add(condition);
        delPortRequest = new MutateOperation(Bridge.NAME.getName(), where, mutations);

        TransactBuilder transaction = new TransactBuilder();
        transaction.addOperations(new ArrayList<Operation>(Arrays.asList(delPortRequest)));

        ListenableFuture<List<OperationResult>> transResponse = connection.getRpc().transact(transaction);
        List<OperationResult> tr = transResponse.get();
        List<Operation> requests = transaction.getRequests();
        Status status = new Status(StatusCode.SUCCESS);
        for (int i = 0; i < tr.size(); i++) {
            if (i < requests.size())
                requests.get(i).setResult(tr.get(i));
            if (tr.get(i).getError() != null && tr.get(i).getError().trim().length() > 0) {
                OperationResult result = tr.get(i);
                status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
            }
        }

        if (tr.size() > requests.size()) {
            OperationResult result = tr.get(tr.size() - 1);
            logger.error("Error creating Bridge : {}\n Error : {}\n Details : {}", bridgeIdentifier,
                    result.getError(), result.getDetails());
            status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
        }
        return status;
    } catch (Exception e) {
        logger.error("Error in deletePort()", e);
    }
    return new Status(StatusCode.INTERNALERROR);
}

From source file:com.microsoft.windowsazure.mobileservices.table.sync.MobileServiceSyncContext.java

/**
 * Performs a query against the remote table and stores results.
 *
 * @param tableName the remote table name
 * @param query     an optional query to filter results
 *//*from www.  ja v a2  s  .com*/
void pull(String tableName, Query query, String queryId) throws Throwable {
    this.mInitLock.readLock().lock();

    try {
        ensureCorrectlyInitialized();

        String invTableName = tableName != null ? tableName.trim().toLowerCase(Locale.getDefault()) : null;

        boolean busyPullDone = false;

        while (!busyPullDone) {
            ListenableFuture<Void> pushFuture = null;

            // prevent Coffman Circular wait condition: lock resources in
            // same order, independent of unlock order. Op then Table then
            // Id.

            // get SHARED access to op lock
            this.mOpLock.readLock().lock();

            try {
                // get EXCLUSIVE access to table lock
                MultiReadWriteLock<String> multiRWLock = this.mTableLockMap.lockWrite(invTableName);

                try {
                    int pendingTable = this.mOpQueue.countPending(invTableName);

                    if (pendingTable > 0) {
                        pushFuture = push();
                    } else {
                        processPull(invTableName, query, queryId);
                    }
                } finally {
                    this.mTableLockMap.unLockWrite(multiRWLock);
                }
            } finally {
                this.mOpLock.readLock().unlock();
            }

            if (pushFuture != null) {
                try {
                    pushFuture.get();
                } catch (ExecutionException e) {
                    throw e.getCause();
                }
            } else {
                busyPullDone = true;
            }
        }
    } finally {
        this.mInitLock.readLock().unlock();
    }
}

From source file:org.opendaylight.ovsdb.plugin.ConfigurationService.java

private Status _deleteRootTableRow(Node node, String uuid, String TableName) {
    try {// w ww. j a  v  a  2  s . c  om
        // Check there is a connectionService
        if (connectionService == null) {
            logger.error("Couldn't refer to the ConnectionService");
            return new Status(StatusCode.NOSERVICE);
        }

        // Establish the connection
        Connection connection = this.getConnection(node);
        if (connection == null) {
            return new Status(StatusCode.NOSERVICE, "Connection to ovsdb-server not available");
        }

        Map<String, Table<?>> table = inventoryServiceInternal.getTableCache(node, TableName);

        // Check that the UUID exists
        if (table == null || table.get(uuid) == null) {
            return new Status(StatusCode.NOTFOUND, "");
        }

        // Initialise the actual request var
        Operation delRequest = null;

        UUID rowUuid = new UUID(uuid);

        Status status = new Status(StatusCode.SUCCESS);

        Condition condition = new Condition("_uuid", Function.EQUALS, rowUuid);
        List<Condition> where = new ArrayList<Condition>();
        where.add(condition);
        delRequest = new DeleteOperation(TableName, where);

        TransactBuilder transaction = new TransactBuilder();
        transaction.addOperations(new ArrayList<Operation>(Arrays.asList(delRequest)));

        // This executes the transaction.
        ListenableFuture<List<OperationResult>> transResponse = connection.getRpc().transact(transaction);

        // Pull the responses
        List<OperationResult> tr = transResponse.get();
        List<Operation> requests = transaction.getRequests();

        for (int i = 0; i < tr.size(); i++) {
            if (i < requests.size())
                requests.get(i).setResult(tr.get(i));
            if (tr.get(i) != null && tr.get(i).getError() != null && tr.get(i).getError().trim().length() > 0) {
                OperationResult result = tr.get(i);
                status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
            }
        }

        if (tr.size() > requests.size()) {
            OperationResult result = tr.get(tr.size() - 1);
            logger.error("Error deleting: {}\n Error : {}\n Details : {}", uuid, result.getError(),
                    result.getDetails());
            status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
        }
        return status;
    } catch (Exception e) {
        logger.error("Error in _deleteRootTableRow", e);
    }
    return new Status(StatusCode.INTERNALERROR);
}

From source file:org.opendaylight.ovsdb.plugin.ConfigurationService.java

private Status _deleteTableRow(Node node, String uuid, String parentTableName, String childTableName,
        String parentColumn) {//from   ww  w  . j a v  a  2s.c  om
    try {
        // Check there is a connectionService
        if (connectionService == null) {
            logger.error("Couldn't refer to the ConnectionService");
            return new Status(StatusCode.NOSERVICE);
        }

        // Establish the connection
        Connection connection = this.getConnection(node);
        if (connection == null) {
            return new Status(StatusCode.NOSERVICE, "Connection to ovsdb-server not available");
        }

        // Remove from Parent and Child
        Map<String, Table<?>> parentTable = inventoryServiceInternal.getTableCache(node, parentTableName);
        Map<String, Table<?>> childTable = inventoryServiceInternal.getTableCache(node, childTableName);

        // Check that the UUID exists
        if (parentTable == null || childTable == null || uuid == null || childTable.get(uuid) == null) {
            return new Status(StatusCode.NOTFOUND, "");
        }

        // Initialise the actual request var
        Operation delRequest = null;

        // Prepare the mutator to remove the child UUID from the parentColumn list in the parent TABLE
        UUID rowUuid = new UUID(uuid);
        Mutation mutator = new Mutation(parentColumn, Mutator.DELETE, rowUuid);
        List<Mutation> mutations = new ArrayList<Mutation>();
        mutations.add(mutator);

        Status status = new Status(StatusCode.SUCCESS);

        // INCLUDES condition ensures that it captures all rows in the parent table (ie duplicates) that have the child UUID
        Condition condition = new Condition(parentColumn, Function.INCLUDES, rowUuid);
        List<Condition> where = new ArrayList<Condition>();
        where.add(condition);
        delRequest = new MutateOperation(parentTableName, where, mutations);

        TransactBuilder transaction = new TransactBuilder();
        transaction.addOperations(new ArrayList<Operation>(Arrays.asList(delRequest)));

        // This executes the transaction.
        ListenableFuture<List<OperationResult>> transResponse = connection.getRpc().transact(transaction);

        // Pull the responses
        List<OperationResult> tr = transResponse.get();
        List<Operation> requests = transaction.getRequests();

        for (int i = 0; i < tr.size(); i++) {
            if (i < requests.size())
                requests.get(i).setResult(tr.get(i));
            if (tr.get(i) != null && tr.get(i).getError() != null && tr.get(i).getError().trim().length() > 0) {
                OperationResult result = tr.get(i);
                status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
            }
        }

        if (tr.size() > requests.size()) {
            OperationResult result = tr.get(tr.size() - 1);
            logger.error("Error deleting: {}\n Error : {}\n Details : {}", uuid, result.getError(),
                    result.getDetails());
            status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
        }
        return status;
    } catch (Exception e) {
        logger.error("Error in _deleteTableRow", e);
    }
    return new Status(StatusCode.INTERNALERROR);
}

From source file:org.opendaylight.ovsdb.plugin.ConfigurationService.java

/**
 * Add a new bridge//from ww w.j  a  va 2  s .  c o  m
 * @param node Node serving this configuration service
 * @param bridgeConnectorIdentifier String representation of a Bridge Connector
 * @return Bridge Connector configurations
 */
@Override
public Status createBridgeDomain(Node node, String bridgeIdentifier, Map<ConfigConstants, Object> configs) {
    try {
        if (connectionService == null) {
            logger.error("Couldn't refer to the ConnectionService");
            return new Status(StatusCode.NOSERVICE);
        }

        Connection connection = this.getConnection(node);
        if (connection == null) {
            return new Status(StatusCode.NOSERVICE, "Connection to ovsdb-server not available");
        }

        Map<String, Table<?>> ovsTable = inventoryServiceInternal.getTableCache(node,
                Open_vSwitch.NAME.getName());
        String newBridge = "new_bridge";
        String newInterface = "new_interface";
        String newPort = "new_port";
        String newSwitch = "new_switch";

        Operation addSwitchRequest = null;

        if (ovsTable != null) {
            String ovsTableUUID = (String) ovsTable.keySet().toArray()[0];
            UUID bridgeUuidPair = new UUID(newBridge);
            Mutation bm = new Mutation("bridges", Mutator.INSERT, bridgeUuidPair);
            List<Mutation> mutations = new ArrayList<Mutation>();
            mutations.add(bm);

            UUID uuid = new UUID(ovsTableUUID);
            Condition condition = new Condition("_uuid", Function.EQUALS, uuid);
            List<Condition> where = new ArrayList<Condition>();
            where.add(condition);
            addSwitchRequest = new MutateOperation(Open_vSwitch.NAME.getName(), where, mutations);
        } else {
            Open_vSwitch ovsTableRow = new Open_vSwitch();
            OvsDBSet<UUID> bridges = new OvsDBSet<UUID>();
            UUID bridgeUuidPair = new UUID(newBridge);
            bridges.add(bridgeUuidPair);
            ovsTableRow.setBridges(bridges);
            addSwitchRequest = new InsertOperation(Open_vSwitch.NAME.getName(), newSwitch, ovsTableRow);
        }

        Bridge bridgeRow = new Bridge();
        bridgeRow.setName(bridgeIdentifier);
        OvsDBSet<UUID> ports = new OvsDBSet<UUID>();
        UUID port = new UUID(newPort);
        ports.add(port);
        bridgeRow.setPorts(ports);
        InsertOperation addBridgeRequest = new InsertOperation(Bridge.NAME.getName(), newBridge, bridgeRow);

        Port portRow = new Port();
        portRow.setName(bridgeIdentifier);
        OvsDBSet<UUID> interfaces = new OvsDBSet<UUID>();
        UUID interfaceid = new UUID(newInterface);
        interfaces.add(interfaceid);
        portRow.setInterfaces(interfaces);
        InsertOperation addPortRequest = new InsertOperation(Port.NAME.getName(), newPort, portRow);

        Interface interfaceRow = new Interface();
        interfaceRow.setName(bridgeIdentifier);
        interfaceRow.setType("internal");
        InsertOperation addIntfRequest = new InsertOperation(Interface.NAME.getName(), newInterface,
                interfaceRow);

        /* Update config version */
        String ovsTableUUID = (String) ovsTable.keySet().toArray()[0];
        Mutation bm = new Mutation("next_cfg", Mutator.SUM, 1);
        List<Mutation> mutations = new ArrayList<Mutation>();
        mutations.add(bm);

        UUID uuid = new UUID(ovsTableUUID);
        Condition condition = new Condition("_uuid", Function.EQUALS, uuid);
        List<Condition> where = new ArrayList<Condition>();
        where.add(condition);
        MutateOperation updateCfgVerRequest = new MutateOperation(Open_vSwitch.NAME.getName(), where,
                mutations);

        TransactBuilder transaction = new TransactBuilder();
        transaction.addOperations(new ArrayList<Operation>(Arrays.asList(addSwitchRequest, addIntfRequest,
                addPortRequest, addBridgeRequest, updateCfgVerRequest)));

        ListenableFuture<List<OperationResult>> transResponse = connection.getRpc().transact(transaction);
        List<OperationResult> tr = transResponse.get();
        List<Operation> requests = transaction.getRequests();
        Status status = new Status(StatusCode.SUCCESS);
        for (int i = 0; i < tr.size(); i++) {
            if (i < requests.size())
                requests.get(i).setResult(tr.get(i));
            if (tr.get(i) != null && tr.get(i).getError() != null && tr.get(i).getError().trim().length() > 0) {
                OperationResult result = tr.get(i);
                status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
            }
        }

        if (tr.size() > requests.size()) {
            OperationResult result = tr.get(tr.size() - 1);
            logger.error("Error creating Bridge : {}\n Error : {}\n Details : {}", bridgeIdentifier,
                    result.getError(), result.getDetails());
            status = new Status(StatusCode.BADREQUEST, result.getError() + " : " + result.getDetails());
        }
        if (status.isSuccess()) {
            setBridgeOFController(node, bridgeIdentifier);
        }
        return status;
    } catch (Exception e) {
        logger.error("Error in createBridgeDomain(): ", e);
    }
    return new Status(StatusCode.INTERNALERROR);
}