Examples with FutureCallback com.google.common.util.concurrent.FutureCallback used on opensource projects

Example 36 with FutureCallback

use of com.google.common.util.concurrent.FutureCallback in project qpid-broker-j by apache.

the class AbstractSystemConfig method makeActive.

protected ListenableFuture<Void> makeActive() {
    final EventLogger eventLogger = _eventLogger;
    final EventLogger startupLogger = initiateStartupLogging();
    try {
        final Container<?> container = initiateStoreAndRecovery();
        container.setEventLogger(startupLogger);
        final SettableFuture<Void> returnVal = SettableFuture.create();
        addFutureCallback(container.openAsync(), new FutureCallback() {

            @Override
            public void onSuccess(final Object result) {
                State state = container.getState();
                if (state == State.ACTIVE) {
                    startupLogger.message(BrokerMessages.READY());
                    container.setEventLogger(eventLogger);
                    returnVal.set(null);
                } else {
                    returnVal.setException(new ServerScopedRuntimeException("Broker failed reach ACTIVE state (state is " + state + ")"));
                }
            }

            @Override
            public void onFailure(final Throwable t) {
                returnVal.setException(t);
            }
        }, getTaskExecutor());
        return returnVal;
    } catch (IOException e) {
        throw new IllegalArgumentException(e);
    }
}

Example 37 with FutureCallback

use of com.google.common.util.concurrent.FutureCallback in project thingsboard by thingsboard.

the class TelemetryController method deleteAttributes.

private DeferredResult<ResponseEntity> deleteAttributes(EntityId entityIdSrc, String scope, String keysStr) throws ThingsboardException {
    List<String> keys = toKeysList(keysStr);
    if (keys.isEmpty()) {
        return getImmediateDeferredResult("Empty keys: " + keysStr, HttpStatus.BAD_REQUEST);
    }
    SecurityUser user = getCurrentUser();
    if (DataConstants.SERVER_SCOPE.equals(scope) || DataConstants.SHARED_SCOPE.equals(scope) || DataConstants.CLIENT_SCOPE.equals(scope)) {
        return accessValidator.validateEntityAndCallback(getCurrentUser(), Operation.WRITE_ATTRIBUTES, entityIdSrc, (result, tenantId, entityId) -> {
            tsSubService.deleteAndNotify(tenantId, entityId, scope, keys, new FutureCallback<Void>() {

                @Override
                public void onSuccess(@Nullable Void tmp) {
                    logAttributesDeleted(user, entityId, scope, keys, null);
                    if (entityIdSrc.getEntityType().equals(EntityType.DEVICE)) {
                        DeviceId deviceId = new DeviceId(entityId.getId());
                        Set<AttributeKey> keysToNotify = new HashSet<>();
                        keys.forEach(key -> keysToNotify.add(new AttributeKey(scope, key)));
                        tbClusterService.pushMsgToCore(DeviceAttributesEventNotificationMsg.onDelete(user.getTenantId(), deviceId, keysToNotify), null);
                    }
                    result.setResult(new ResponseEntity<>(HttpStatus.OK));
                }

                @Override
                public void onFailure(Throwable t) {
                    logAttributesDeleted(user, entityId, scope, keys, t);
                    result.setResult(new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR));
                }
            });
        });
    } else {
        return getImmediateDeferredResult("Invalid attribute scope: " + scope, HttpStatus.BAD_REQUEST);
    }
}

Example 38 with FutureCallback

use of com.google.common.util.concurrent.FutureCallback in project thingsboard by thingsboard.

the class EdgeGrpcSession method processEdgeEvents.

ListenableFuture<Void> processEdgeEvents() throws Exception {
    SettableFuture<Void> result = SettableFuture.create();
    log.trace("[{}] starting processing edge events", this.sessionId);
    if (isConnected() && isSyncCompleted()) {
        Long queueStartTs = getQueueStartTs().get();
        GeneralEdgeEventFetcher fetcher = new GeneralEdgeEventFetcher(queueStartTs, ctx.getEdgeEventService());
        ListenableFuture<UUID> ifOffsetFuture = startProcessingEdgeEvents(fetcher);
        Futures.addCallback(ifOffsetFuture, new FutureCallback<>() {

            @Override
            public void onSuccess(@Nullable UUID ifOffset) {
                if (ifOffset != null) {
                    Long newStartTs = Uuids.unixTimestamp(ifOffset);
                    ListenableFuture<List<Void>> updateFuture = updateQueueStartTs(newStartTs);
                    Futures.addCallback(updateFuture, new FutureCallback<>() {

                        @Override
                        public void onSuccess(@Nullable List<Void> list) {
                            log.debug("[{}] queue offset was updated [{}][{}]", sessionId, ifOffset, newStartTs);
                            result.set(null);
                        }

                        @Override
                        public void onFailure(Throwable t) {
                            log.error("[{}] Failed to update queue offset [{}]", sessionId, ifOffset, t);
                            result.setException(t);
                        }
                    }, ctx.getGrpcCallbackExecutorService());
                } else {
                    log.trace("[{}] ifOffset is null. Skipping iteration without db update", sessionId);
                    result.set(null);
                }
            }

            @Override
            public void onFailure(Throwable t) {
                log.error("[{}] Failed to process events", sessionId, t);
                result.setException(t);
            }
        }, ctx.getGrpcCallbackExecutorService());
    } else {
        log.trace("[{}] edge is not connected or sync is not completed. Skipping iteration", sessionId);
        result.set(null);
    }
    return result;
}

Example 39 with FutureCallback

use of com.google.common.util.concurrent.FutureCallback in project thingsboard by thingsboard.

the class CassandraBaseTimeseriesDao method findAllAsyncSequentiallyWithLimit.

private void findAllAsyncSequentiallyWithLimit(TenantId tenantId, final TsKvQueryCursor cursor, final SimpleListenableFuture<List<TsKvEntry>> resultFuture) {
    if (cursor.isFull() || !cursor.hasNextPartition()) {
        resultFuture.set(cursor.getData());
    } else {
        PreparedStatement proto = getFetchStmt(Aggregation.NONE, cursor.getOrderBy());
        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(proto.bind());
        stmtBuilder.setString(0, cursor.getEntityType());
        stmtBuilder.setUuid(1, cursor.getEntityId());
        stmtBuilder.setString(2, cursor.getKey());
        stmtBuilder.setLong(3, cursor.getNextPartition());
        stmtBuilder.setLong(4, cursor.getStartTs());
        stmtBuilder.setLong(5, cursor.getEndTs());
        stmtBuilder.setInt(6, cursor.getCurrentLimit());
        BoundStatement stmt = stmtBuilder.build();
        Futures.addCallback(executeAsyncRead(tenantId, stmt), new FutureCallback<TbResultSet>() {

            @Override
            public void onSuccess(@Nullable TbResultSet result) {
                if (result == null) {
                    cursor.addData(convertResultToTsKvEntryList(Collections.emptyList()));
                    findAllAsyncSequentiallyWithLimit(tenantId, cursor, resultFuture);
                } else {
                    Futures.addCallback(result.allRows(readResultsProcessingExecutor), new FutureCallback<List<Row>>() {

                        @Override
                        public void onSuccess(@Nullable List<Row> result) {
                            cursor.addData(convertResultToTsKvEntryList(result == null ? Collections.emptyList() : result));
                            findAllAsyncSequentiallyWithLimit(tenantId, cursor, resultFuture);
                        }

                        @Override
                        public void onFailure(Throwable t) {
                            log.error("[{}][{}] Failed to fetch data for query {}-{}", stmt, t);
                        }
                    }, readResultsProcessingExecutor);
                }
            }

            @Override
            public void onFailure(Throwable t) {
                log.error("[{}][{}] Failed to fetch data for query {}-{}", stmt, t);
            }
        }, readResultsProcessingExecutor);
    }
}

Example 40 with FutureCallback

use of com.google.common.util.concurrent.FutureCallback in project thingsboard by thingsboard.

the class TbCopyAttributesToEntityViewNode method onMsg.

@Override
public void onMsg(TbContext ctx, TbMsg msg) {
    if (DataConstants.ATTRIBUTES_UPDATED.equals(msg.getType()) || DataConstants.ATTRIBUTES_DELETED.equals(msg.getType()) || DataConstants.ACTIVITY_EVENT.equals(msg.getType()) || SessionMsgType.POST_ATTRIBUTES_REQUEST.name().equals(msg.getType())) {
        if (!msg.getMetaData().getData().isEmpty()) {
            long now = System.currentTimeMillis();
            String scope = msg.getType().equals(SessionMsgType.POST_ATTRIBUTES_REQUEST.name()) ? DataConstants.CLIENT_SCOPE : msg.getMetaData().getValue(DataConstants.SCOPE);
            ListenableFuture<List<EntityView>> entityViewsFuture = ctx.getEntityViewService().findEntityViewsByTenantIdAndEntityIdAsync(ctx.getTenantId(), msg.getOriginator());
            DonAsynchron.withCallback(entityViewsFuture, entityViews -> {
                for (EntityView entityView : entityViews) {
                    long startTime = entityView.getStartTimeMs();
                    long endTime = entityView.getEndTimeMs();
                    if ((endTime != 0 && endTime > now && startTime < now) || (endTime == 0 && startTime < now)) {
                        if (DataConstants.ATTRIBUTES_UPDATED.equals(msg.getType()) || DataConstants.ACTIVITY_EVENT.equals(msg.getType()) || SessionMsgType.POST_ATTRIBUTES_REQUEST.name().equals(msg.getType())) {
                            Set<AttributeKvEntry> attributes = JsonConverter.convertToAttributes(new JsonParser().parse(msg.getData()));
                            List<AttributeKvEntry> filteredAttributes = attributes.stream().filter(attr -> attributeContainsInEntityView(scope, attr.getKey(), entityView)).collect(Collectors.toList());
                            ctx.getTelemetryService().saveAndNotify(ctx.getTenantId(), entityView.getId(), scope, filteredAttributes, new FutureCallback<Void>() {

                                @Override
                                public void onSuccess(@Nullable Void result) {
                                    transformAndTellNext(ctx, msg, entityView);
                                }

                                @Override
                                public void onFailure(Throwable t) {
                                    ctx.tellFailure(msg, t);
                                }
                            });
                        } else if (DataConstants.ATTRIBUTES_DELETED.equals(msg.getType())) {
                            List<String> attributes = new ArrayList<>();
                            for (JsonElement element : new JsonParser().parse(msg.getData()).getAsJsonObject().get("attributes").getAsJsonArray()) {
                                if (element.isJsonPrimitive()) {
                                    JsonPrimitive value = element.getAsJsonPrimitive();
                                    if (value.isString()) {
                                        attributes.add(value.getAsString());
                                    }
                                }
                            }
                            List<String> filteredAttributes = attributes.stream().filter(attr -> attributeContainsInEntityView(scope, attr, entityView)).collect(Collectors.toList());
                            if (!filteredAttributes.isEmpty()) {
                                ctx.getAttributesService().removeAll(ctx.getTenantId(), entityView.getId(), scope, filteredAttributes);
                                transformAndTellNext(ctx, msg, entityView);
                            }
                        }
                    }
                }
                ctx.ack(msg);
            }, t -> ctx.tellFailure(msg, t));
        } else {
            ctx.tellFailure(msg, new IllegalArgumentException("Message metadata is empty"));
        }
    } else {
        ctx.tellFailure(msg, new IllegalArgumentException("Unsupported msg type [" + msg.getType() + "]"));
    }
}