Examples with TopicPartitionInfo org.thingsboard.server.common.msg.queue.TopicPartitionInfo used on opensource projects

Example 41 with TopicPartitionInfo

use of org.thingsboard.server.common.msg.queue.TopicPartitionInfo in project thingsboard by thingsboard.

the class DefaultAlarmSubscriptionService method onAlarmUpdated.

private void onAlarmUpdated(AlarmOperationResult result) {
    wsCallBackExecutor.submit(() -> {
        Alarm alarm = result.getAlarm();
        TenantId tenantId = result.getAlarm().getTenantId();
        for (EntityId entityId : result.getPropagatedEntitiesList()) {
            TopicPartitionInfo tpi = partitionService.resolve(ServiceType.TB_CORE, tenantId, entityId);
            if (currentPartitions.contains(tpi)) {
                if (subscriptionManagerService.isPresent()) {
                    subscriptionManagerService.get().onAlarmUpdate(tenantId, entityId, alarm, TbCallback.EMPTY);
                } else {
                    log.warn("Possible misconfiguration because subscriptionManagerService is null!");
                }
            } else {
                TransportProtos.ToCoreMsg toCoreMsg = TbSubscriptionUtils.toAlarmUpdateProto(tenantId, entityId, alarm);
                clusterService.pushMsgToCore(tpi, entityId.getId(), toCoreMsg, null);
            }
        }
    });
}

Example 42 with TopicPartitionInfo

use of org.thingsboard.server.common.msg.queue.TopicPartitionInfo in project thingsboard by thingsboard.

the class DefaultDeviceStateService method onDeviceDeleted.

private void onDeviceDeleted(TenantId tenantId, DeviceId deviceId) {
    cleanupEntity(deviceId);
    TopicPartitionInfo tpi = partitionService.resolve(ServiceType.TB_CORE, tenantId, deviceId);
    Set<DeviceId> deviceIdSet = partitionedEntities.get(tpi);
    if (deviceIdSet != null) {
        deviceIdSet.remove(deviceId);
    }
}

Example 43 with TopicPartitionInfo

use of org.thingsboard.server.common.msg.queue.TopicPartitionInfo in project thingsboard by thingsboard.

the class DefaultSubscriptionManagerService method handleNewAttributeSubscription.

private void handleNewAttributeSubscription(TbAttributeSubscription subscription) {
    log.trace("[{}][{}][{}] Processing remote attribute subscription for entity [{}]", serviceId, subscription.getSessionId(), subscription.getSubscriptionId(), subscription.getEntityId());
    final Map<String, Long> keyStates = subscription.getKeyStates();
    DonAsynchron.withCallback(attrService.find(subscription.getTenantId(), subscription.getEntityId(), DataConstants.CLIENT_SCOPE, keyStates.keySet()), values -> {
        List<TsKvEntry> missedUpdates = new ArrayList<>();
        values.forEach(latestEntry -> {
            if (latestEntry.getLastUpdateTs() > keyStates.get(latestEntry.getKey())) {
                missedUpdates.add(new BasicTsKvEntry(latestEntry.getLastUpdateTs(), latestEntry));
            }
        });
        if (!missedUpdates.isEmpty()) {
            TopicPartitionInfo tpi = partitionService.getNotificationsTopic(ServiceType.TB_CORE, subscription.getServiceId());
            toCoreNotificationsProducer.send(tpi, toProto(subscription, missedUpdates), null);
        }
    }, e -> log.error("Failed to fetch missed updates.", e), tsCallBackExecutor);
}

Example 44 with TopicPartitionInfo

use of org.thingsboard.server.common.msg.queue.TopicPartitionInfo in project thingsboard by thingsboard.

the class DefaultTbLocalSubscriptionService method cancelSubscription.

@Override
public void cancelSubscription(String sessionId, int subscriptionId) {
    log.debug("[{}][{}] Going to remove subscription.", sessionId, subscriptionId);
    Map<Integer, TbSubscription> sessionSubscriptions = subscriptionsBySessionId.get(sessionId);
    if (sessionSubscriptions != null) {
        TbSubscription subscription = sessionSubscriptions.remove(subscriptionId);
        if (subscription != null) {
            if (sessionSubscriptions.isEmpty()) {
                subscriptionsBySessionId.remove(sessionId);
            }
            TopicPartitionInfo tpi = partitionService.resolve(ServiceType.TB_CORE, subscription.getTenantId(), subscription.getEntityId());
            if (currentPartitions.contains(tpi)) {
                // Subscription is managed on the same server;
                subscriptionManagerService.cancelSubscription(sessionId, subscriptionId, TbCallback.EMPTY);
            } else {
                // Push to the queue;
                TransportProtos.ToCoreMsg toCoreMsg = TbSubscriptionUtils.toCloseSubscriptionProto(subscription);
                clusterService.pushMsgToCore(tpi, subscription.getEntityId().getId(), toCoreMsg, null);
            }
        } else {
            log.debug("[{}][{}] Subscription not found!", sessionId, subscriptionId);
        }
    } else {
        log.debug("[{}] No session subscriptions found!", sessionId);
    }
}

Example 45 with TopicPartitionInfo

use of org.thingsboard.server.common.msg.queue.TopicPartitionInfo in project thingsboard by thingsboard.

the class HashPartitionService method recalculatePartitions.

@Override
public synchronized void recalculatePartitions(ServiceInfo currentService, List<ServiceInfo> otherServices) {
    tbTransportServicesByType.clear();
    logServiceInfo(currentService);
    otherServices.forEach(this::logServiceInfo);
    Map<ServiceQueueKey, List<ServiceInfo>> queueServicesMap = new HashMap<>();
    addNode(queueServicesMap, currentService);
    for (ServiceInfo other : otherServices) {
        addNode(queueServicesMap, other);
    }
    queueServicesMap.values().forEach(list -> list.sort(Comparator.comparing(ServiceInfo::getServiceId)));
    ConcurrentMap<ServiceQueueKey, List<Integer>> oldPartitions = myPartitions;
    TenantId myIsolatedOrSystemTenantId = getSystemOrIsolatedTenantId(currentService);
    myPartitions = new ConcurrentHashMap<>();
    partitionSizes.forEach((serviceQueue, size) -> {
        ServiceQueueKey myServiceQueueKey = new ServiceQueueKey(serviceQueue, myIsolatedOrSystemTenantId);
        for (int i = 0; i < size; i++) {
            ServiceInfo serviceInfo = resolveByPartitionIdx(queueServicesMap.get(myServiceQueueKey), i);
            if (currentService.equals(serviceInfo)) {
                ServiceQueueKey serviceQueueKey = new ServiceQueueKey(serviceQueue, getSystemOrIsolatedTenantId(serviceInfo));
                myPartitions.computeIfAbsent(serviceQueueKey, key -> new ArrayList<>()).add(i);
            }
        }
    });
    tpiCache.clear();
    oldPartitions.forEach((serviceQueueKey, partitions) -> {
        if (!myPartitions.containsKey(serviceQueueKey)) {
            log.info("[{}] NO MORE PARTITIONS FOR CURRENT KEY", serviceQueueKey);
            applicationEventPublisher.publishEvent(new PartitionChangeEvent(this, serviceQueueKey, Collections.emptySet()));
        }
    });
    myPartitions.forEach((serviceQueueKey, partitions) -> {
        if (!partitions.equals(oldPartitions.get(serviceQueueKey))) {
            log.info("[{}] NEW PARTITIONS: {}", serviceQueueKey, partitions);
            Set<TopicPartitionInfo> tpiList = partitions.stream().map(partition -> buildTopicPartitionInfo(serviceQueueKey, partition)).collect(Collectors.toSet());
            applicationEventPublisher.publishEvent(new PartitionChangeEvent(this, serviceQueueKey, tpiList));
        }
    });
    if (currentOtherServices == null) {
        currentOtherServices = new ArrayList<>(otherServices);
    } else {
        Set<ServiceQueueKey> changes = new HashSet<>();
        Map<ServiceQueueKey, List<ServiceInfo>> currentMap = getServiceKeyListMap(currentOtherServices);
        Map<ServiceQueueKey, List<ServiceInfo>> newMap = getServiceKeyListMap(otherServices);
        currentOtherServices = otherServices;
        currentMap.forEach((key, list) -> {
            if (!list.equals(newMap.get(key))) {
                changes.add(key);
            }
        });
        currentMap.keySet().forEach(newMap::remove);
        changes.addAll(newMap.keySet());
        if (!changes.isEmpty()) {
            applicationEventPublisher.publishEvent(new ClusterTopologyChangeEvent(this, changes));
        }
    }
    applicationEventPublisher.publishEvent(new ServiceListChangedEvent(otherServices, currentService));
}