Andrii Landiak
2 years ago
8 changed files with 983 additions and 1013 deletions
@ -1,939 +0,0 @@ |
|||
/** |
|||
* Copyright © 2016-2024 The Thingsboard Authors |
|||
* |
|||
* Licensed under the Apache License, Version 2.0 (the "License"); |
|||
* you may not use this file except in compliance with the License. |
|||
* You may obtain a copy of the License at |
|||
* |
|||
* http://www.apache.org/licenses/LICENSE-2.0
|
|||
* |
|||
* Unless required by applicable law or agreed to in writing, software |
|||
* distributed under the License is distributed on an "AS IS" BASIS, |
|||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|||
* See the License for the specific language governing permissions and |
|||
* limitations under the License. |
|||
*/ |
|||
package org.thingsboard.server.service.edge.rpc; |
|||
|
|||
import com.datastax.oss.driver.api.core.uuid.Uuids; |
|||
import com.google.common.util.concurrent.FutureCallback; |
|||
import com.google.common.util.concurrent.Futures; |
|||
import com.google.common.util.concurrent.ListenableFuture; |
|||
import com.google.common.util.concurrent.SettableFuture; |
|||
import io.grpc.stub.StreamObserver; |
|||
import lombok.Data; |
|||
import lombok.extern.slf4j.Slf4j; |
|||
import org.checkerframework.checker.nullness.qual.Nullable; |
|||
import org.springframework.data.util.Pair; |
|||
import org.thingsboard.server.common.data.AttributeScope; |
|||
import org.thingsboard.server.common.data.DataConstants; |
|||
import org.thingsboard.server.common.data.EdgeUtils; |
|||
import org.thingsboard.server.common.data.edge.Edge; |
|||
import org.thingsboard.server.common.data.edge.EdgeEvent; |
|||
import org.thingsboard.server.common.data.id.EdgeId; |
|||
import org.thingsboard.server.common.data.id.TenantId; |
|||
import org.thingsboard.server.common.data.kv.AttributeKvEntry; |
|||
import org.thingsboard.server.common.data.kv.BaseAttributeKvEntry; |
|||
import org.thingsboard.server.common.data.kv.LongDataEntry; |
|||
import org.thingsboard.server.common.data.kv.StringDataEntry; |
|||
import org.thingsboard.server.common.data.limit.LimitedApi; |
|||
import org.thingsboard.server.common.data.notification.rule.trigger.EdgeCommunicationFailureTrigger; |
|||
import org.thingsboard.server.common.data.page.PageData; |
|||
import org.thingsboard.server.common.data.page.PageLink; |
|||
import org.thingsboard.server.common.data.page.SortOrder; |
|||
import org.thingsboard.server.common.data.page.TimePageLink; |
|||
import org.thingsboard.server.common.msg.edge.EdgeEventUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.AlarmCommentUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.AlarmUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.AssetProfileUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.AssetUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.AttributesRequestMsg; |
|||
import org.thingsboard.server.gen.edge.v1.ConnectRequestMsg; |
|||
import org.thingsboard.server.gen.edge.v1.ConnectResponseCode; |
|||
import org.thingsboard.server.gen.edge.v1.ConnectResponseMsg; |
|||
import org.thingsboard.server.gen.edge.v1.DashboardUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.DeviceCredentialsRequestMsg; |
|||
import org.thingsboard.server.gen.edge.v1.DeviceCredentialsUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.DeviceProfileUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.DeviceRpcCallMsg; |
|||
import org.thingsboard.server.gen.edge.v1.DeviceUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.DownlinkMsg; |
|||
import org.thingsboard.server.gen.edge.v1.DownlinkResponseMsg; |
|||
import org.thingsboard.server.gen.edge.v1.EdgeConfiguration; |
|||
import org.thingsboard.server.gen.edge.v1.EdgeUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.EdgeVersion; |
|||
import org.thingsboard.server.gen.edge.v1.EntityDataProto; |
|||
import org.thingsboard.server.gen.edge.v1.EntityViewUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.EntityViewsRequestMsg; |
|||
import org.thingsboard.server.gen.edge.v1.RelationRequestMsg; |
|||
import org.thingsboard.server.gen.edge.v1.RelationUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.RequestMsg; |
|||
import org.thingsboard.server.gen.edge.v1.RequestMsgType; |
|||
import org.thingsboard.server.gen.edge.v1.ResourceUpdateMsg; |
|||
import org.thingsboard.server.gen.edge.v1.ResponseMsg; |
|||
import org.thingsboard.server.gen.edge.v1.RuleChainMetadataRequestMsg; |
|||
import org.thingsboard.server.gen.edge.v1.SyncCompletedMsg; |
|||
import org.thingsboard.server.gen.edge.v1.UplinkMsg; |
|||
import org.thingsboard.server.gen.edge.v1.UplinkResponseMsg; |
|||
import org.thingsboard.server.gen.edge.v1.UserCredentialsRequestMsg; |
|||
import org.thingsboard.server.gen.edge.v1.WidgetBundleTypesRequestMsg; |
|||
import org.thingsboard.server.service.edge.EdgeContextComponent; |
|||
import org.thingsboard.server.service.edge.rpc.fetch.EdgeEventFetcher; |
|||
import org.thingsboard.server.service.edge.rpc.fetch.GeneralEdgeEventFetcher; |
|||
import org.thingsboard.server.service.edge.rpc.processor.alarm.AlarmProcessor; |
|||
import org.thingsboard.server.service.edge.rpc.processor.asset.AssetProcessor; |
|||
import org.thingsboard.server.service.edge.rpc.processor.asset.profile.AssetProfileProcessor; |
|||
import org.thingsboard.server.service.edge.rpc.processor.dashboard.DashboardProcessor; |
|||
import org.thingsboard.server.service.edge.rpc.processor.device.DeviceProcessor; |
|||
import org.thingsboard.server.service.edge.rpc.processor.device.profile.DeviceProfileProcessor; |
|||
import org.thingsboard.server.service.edge.rpc.processor.entityview.EntityViewProcessor; |
|||
import org.thingsboard.server.service.edge.rpc.processor.relation.RelationProcessor; |
|||
import org.thingsboard.server.service.edge.rpc.processor.resource.ResourceProcessor; |
|||
|
|||
import java.io.Closeable; |
|||
import java.util.ArrayList; |
|||
import java.util.Arrays; |
|||
import java.util.Collections; |
|||
import java.util.List; |
|||
import java.util.Optional; |
|||
import java.util.UUID; |
|||
import java.util.concurrent.ConcurrentLinkedQueue; |
|||
import java.util.concurrent.ScheduledExecutorService; |
|||
import java.util.concurrent.TimeUnit; |
|||
import java.util.concurrent.locks.ReentrantLock; |
|||
import java.util.function.BiConsumer; |
|||
|
|||
@Slf4j |
|||
@Data |
|||
public abstract class AbstractEdgeGrpcSession implements EdgeGrpcSession, Closeable { |
|||
|
|||
private static final String QUEUE_START_TS_ATTR_KEY = "queueStartTs"; |
|||
private static final String QUEUE_START_SEQ_ID_ATTR_KEY = "queueStartSeqId"; |
|||
|
|||
private static final int MAX_DOWNLINK_ATTEMPTS = 10; |
|||
private static final String RATE_LIMIT_REACHED = "Rate limit reached"; |
|||
|
|||
protected static final ConcurrentLinkedQueue<EdgeEvent> highPriorityQueue = new ConcurrentLinkedQueue<>(); |
|||
|
|||
protected UUID sessionId; |
|||
private BiConsumer<EdgeId, AbstractEdgeGrpcSession> sessionOpenListener; |
|||
private BiConsumer<Edge, UUID> sessionCloseListener; |
|||
|
|||
private final EdgeSessionState sessionState = new EdgeSessionState(); |
|||
private final ReentrantLock downlinkMsgLock = new ReentrantLock(); |
|||
|
|||
protected EdgeContextComponent ctx; |
|||
protected Edge edge; |
|||
protected TenantId tenantId; |
|||
|
|||
private Long newStartTs; |
|||
private Long previousStartTs; |
|||
private Long newStartSeqId; |
|||
private Long previousStartSeqId; |
|||
private Long seqIdEnd; |
|||
|
|||
private StreamObserver<RequestMsg> inputStream; |
|||
private StreamObserver<ResponseMsg> outputStream; |
|||
|
|||
private boolean connected; |
|||
private volatile boolean syncCompleted; |
|||
|
|||
private EdgeVersion edgeVersion; |
|||
private int maxInboundMessageSize; |
|||
private int clientMaxInboundMessageSize; |
|||
private int maxHighPriorityQueueSizePerSession; |
|||
|
|||
private ScheduledExecutorService sendDownlinkExecutorService; |
|||
|
|||
public AbstractEdgeGrpcSession(EdgeContextComponent ctx, StreamObserver<ResponseMsg> outputStream, |
|||
BiConsumer<EdgeId, AbstractEdgeGrpcSession> sessionOpenListener, |
|||
BiConsumer<Edge, UUID> sessionCloseListener, |
|||
ScheduledExecutorService sendDownlinkExecutorService, |
|||
int maxInboundMessageSize, int maxHighPriorityQueueSizePerSession) { |
|||
this.sessionId = UUID.randomUUID(); |
|||
this.ctx = ctx; |
|||
this.outputStream = outputStream; |
|||
this.sessionOpenListener = sessionOpenListener; |
|||
this.sessionCloseListener = sessionCloseListener; |
|||
this.sendDownlinkExecutorService = sendDownlinkExecutorService; |
|||
this.maxInboundMessageSize = maxInboundMessageSize; |
|||
this.maxHighPriorityQueueSizePerSession = maxHighPriorityQueueSizePerSession; |
|||
initInputStream(); |
|||
} |
|||
|
|||
public void initInputStream() { |
|||
inputStream = new StreamObserver<>() { |
|||
@Override |
|||
public void onNext(RequestMsg requestMsg) { |
|||
if (!connected && requestMsg.getMsgType().equals(RequestMsgType.CONNECT_RPC_MESSAGE)) { |
|||
ConnectResponseMsg responseMsg = processConnect(requestMsg.getConnectRequestMsg()); |
|||
outputStream.onNext(ResponseMsg.newBuilder() |
|||
.setConnectResponseMsg(responseMsg) |
|||
.build()); |
|||
if (ConnectResponseCode.ACCEPTED != responseMsg.getResponseCode()) { |
|||
outputStream.onError(new RuntimeException(responseMsg.getErrorMsg())); |
|||
} else { |
|||
if (requestMsg.getConnectRequestMsg().hasMaxInboundMessageSize()) { |
|||
log.debug("[{}][{}] Client max inbound message size: {}", tenantId, sessionId, requestMsg.getConnectRequestMsg().getMaxInboundMessageSize()); |
|||
clientMaxInboundMessageSize = requestMsg.getConnectRequestMsg().getMaxInboundMessageSize(); |
|||
} |
|||
connected = true; |
|||
} |
|||
} |
|||
if (connected) { |
|||
if (requestMsg.getMsgType().equals(RequestMsgType.SYNC_REQUEST_RPC_MESSAGE)) { |
|||
if (requestMsg.hasSyncRequestMsg()) { |
|||
boolean fullSync = false; |
|||
if (requestMsg.getSyncRequestMsg().hasFullSync()) { |
|||
fullSync = requestMsg.getSyncRequestMsg().getFullSync(); |
|||
} |
|||
startSyncProcess(fullSync); |
|||
} else { |
|||
syncCompleted = true; |
|||
} |
|||
} |
|||
if (requestMsg.getMsgType().equals(RequestMsgType.UPLINK_RPC_MESSAGE)) { |
|||
if (requestMsg.hasUplinkMsg()) { |
|||
onUplinkMsg(requestMsg.getUplinkMsg()); |
|||
} |
|||
if (requestMsg.hasDownlinkResponseMsg()) { |
|||
onDownlinkResponse(requestMsg.getDownlinkResponseMsg()); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Override |
|||
public void onError(Throwable t) { |
|||
log.error("[{}][{}] Stream was terminated due to error:", tenantId, sessionId, t); |
|||
closeSession(); |
|||
} |
|||
|
|||
@Override |
|||
public void onCompleted() { |
|||
log.info("[{}][{}] Stream was closed and completed successfully!", tenantId, sessionId); |
|||
closeSession(); |
|||
} |
|||
|
|||
private void closeSession() { |
|||
connected = false; |
|||
if (edge != null) { |
|||
try { |
|||
sessionCloseListener.accept(edge, sessionId); |
|||
} catch (Exception ignored) { |
|||
} |
|||
} |
|||
try { |
|||
outputStream.onCompleted(); |
|||
} catch (Exception ignored) { |
|||
} |
|||
} |
|||
}; |
|||
} |
|||
|
|||
@Override |
|||
public void onConfigurationUpdate(Edge edge) { |
|||
log.debug("[{}] onConfigurationUpdate [{}]", sessionId, edge); |
|||
this.tenantId = edge.getTenantId(); |
|||
this.edge = edge; |
|||
EdgeUpdateMsg edgeConfig = EdgeUpdateMsg.newBuilder() |
|||
.setConfiguration(ctx.getEdgeMsgConstructor().constructEdgeConfiguration(edge)).build(); |
|||
ResponseMsg edgeConfigMsg = ResponseMsg.newBuilder() |
|||
.setEdgeUpdateMsg(edgeConfig) |
|||
.build(); |
|||
sendDownlinkMsg(edgeConfigMsg); |
|||
} |
|||
|
|||
@Override |
|||
public void startSyncProcess(boolean fullSync) { |
|||
log.info("[{}][{}][{}] Staring edge sync process", tenantId, edge.getId(), sessionId); |
|||
syncCompleted = false; |
|||
interruptGeneralProcessingOnSync(); |
|||
doSync(new EdgeSyncCursor(ctx, edge, fullSync)); |
|||
} |
|||
|
|||
private void doSync(EdgeSyncCursor cursor) { |
|||
if (cursor.hasNext()) { |
|||
EdgeEventFetcher next = cursor.getNext(); |
|||
log.info("[{}][{}] starting sync process, cursor current idx = {}, class = {}", |
|||
tenantId, edge.getId(), cursor.getCurrentIdx(), next.getClass().getSimpleName()); |
|||
ListenableFuture<Pair<Long, Long>> future = startProcessingEdgeEvents(next); |
|||
Futures.addCallback(future, new FutureCallback<>() { |
|||
@Override |
|||
public void onSuccess(@Nullable Pair<Long, Long> result) { |
|||
doSync(cursor); |
|||
} |
|||
|
|||
@Override |
|||
public void onFailure(Throwable t) { |
|||
log.error("[{}][{}] Exception during sync process", tenantId, edge.getId(), t); |
|||
} |
|||
}, ctx.getGrpcCallbackExecutorService()); |
|||
} else { |
|||
log.info("[{}][{}] sync process completed", tenantId, edge.getId()); |
|||
DownlinkMsg syncCompleteDownlinkMsg = DownlinkMsg.newBuilder() |
|||
.setDownlinkMsgId(EdgeUtils.nextPositiveInt()) |
|||
.setSyncCompletedMsg(SyncCompletedMsg.newBuilder().build()) |
|||
.build(); |
|||
Futures.addCallback(sendDownlinkMsgsPack(Collections.singletonList(syncCompleteDownlinkMsg)), new FutureCallback<>() { |
|||
@Override |
|||
public void onSuccess(Boolean isInterrupted) { |
|||
markSyncCompletedSendEdgeEventUpdate(); |
|||
} |
|||
|
|||
@Override |
|||
public void onFailure(Throwable t) { |
|||
log.error("[{}][{}] Exception during sending sync complete", tenantId, edge.getId(), t); |
|||
markSyncCompletedSendEdgeEventUpdate(); |
|||
} |
|||
}, ctx.getGrpcCallbackExecutorService()); |
|||
} |
|||
} |
|||
|
|||
protected void processEdgeEvents(EdgeEventFetcher fetcher, PageLink pageLink, SettableFuture<Pair<Long, Long>> result) { |
|||
try { |
|||
if (!highPriorityQueue.isEmpty()) { |
|||
processHighPriorityEvents(); |
|||
} |
|||
PageData<EdgeEvent> pageData = fetcher.fetchEdgeEvents(edge.getTenantId(), edge, pageLink); |
|||
if (isConnected() && !pageData.getData().isEmpty()) { |
|||
log.trace("[{}][{}][{}] event(s) are going to be processed.", tenantId, sessionId, pageData.getData().size()); |
|||
List<DownlinkMsg> downlinkMsgsPack = convertToDownlinkMsgsPack(pageData.getData()); |
|||
Futures.addCallback(sendDownlinkMsgsPack(downlinkMsgsPack), new FutureCallback<>() { |
|||
@Override |
|||
public void onSuccess(@Nullable Boolean isInterrupted) { |
|||
if (Boolean.TRUE.equals(isInterrupted)) { |
|||
log.debug("[{}][{}][{}] Send downlink messages task was interrupted", tenantId, edge.getId(), sessionId); |
|||
result.set(null); |
|||
} else { |
|||
if (isConnected() && pageData.hasNext()) { |
|||
processEdgeEvents(fetcher, pageLink.nextPageLink(), result); |
|||
} else { |
|||
EdgeEvent latestEdgeEvent = pageData.getData().get(pageData.getData().size() - 1); |
|||
UUID idOffset = latestEdgeEvent.getUuidId(); |
|||
if (idOffset != null) { |
|||
Long newStartTs = Uuids.unixTimestamp(idOffset); |
|||
long newStartSeqId = latestEdgeEvent.getSeqId(); |
|||
result.set(Pair.of(newStartTs, newStartSeqId)); |
|||
} else { |
|||
result.set(null); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
@Override |
|||
public void onFailure(Throwable t) { |
|||
log.error("[{}] Failed to send downlink msgs pack", sessionId, t); |
|||
result.setException(t); |
|||
} |
|||
}, ctx.getGrpcCallbackExecutorService()); |
|||
} else { |
|||
log.trace("[{}] no event(s) found. Stop processing edge events", sessionId); |
|||
result.set(null); |
|||
} |
|||
} catch (Exception e) { |
|||
log.error("[{}] Failed to fetch edge events", sessionId, e); |
|||
result.setException(e); |
|||
} |
|||
} |
|||
|
|||
private ConnectResponseMsg processConnect(ConnectRequestMsg request) { |
|||
log.trace("[{}] processConnect [{}]", sessionId, request); |
|||
Optional<Edge> optional = ctx.getEdgeService().findEdgeByRoutingKey(TenantId.SYS_TENANT_ID, request.getEdgeRoutingKey()); |
|||
if (optional.isPresent()) { |
|||
edge = optional.get(); |
|||
tenantId = edge.getTenantId(); |
|||
try { |
|||
if (edge.getSecret().equals(request.getEdgeSecret())) { |
|||
sessionOpenListener.accept(edge.getId(), this); |
|||
edgeVersion = request.getEdgeVersion(); |
|||
processSaveEdgeVersionAsAttribute(request.getEdgeVersion().name()); |
|||
return ConnectResponseMsg.newBuilder() |
|||
.setResponseCode(ConnectResponseCode.ACCEPTED) |
|||
.setErrorMsg("") |
|||
.setConfiguration(ctx.getEdgeMsgConstructor().constructEdgeConfiguration(edge)) |
|||
.setMaxInboundMessageSize(maxInboundMessageSize) |
|||
.build(); |
|||
} |
|||
String error = "Failed to validate the edge!"; |
|||
String failureMsg = String.format("%s Provided request secret: %s", error, request.getEdgeSecret()); |
|||
ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId).edgeId(edge.getId()) |
|||
.customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(failureMsg).error(error).build()); |
|||
return ConnectResponseMsg.newBuilder() |
|||
.setResponseCode(ConnectResponseCode.BAD_CREDENTIALS) |
|||
.setErrorMsg(failureMsg) |
|||
.setConfiguration(EdgeConfiguration.getDefaultInstance()).build(); |
|||
} catch (Exception e) { |
|||
String failureMsg = "Failed to process edge connection!"; |
|||
ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId).edgeId(edge.getId()) |
|||
.customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(failureMsg).error(e.getMessage()).build()); |
|||
log.error(failureMsg, e); |
|||
return ConnectResponseMsg.newBuilder() |
|||
.setResponseCode(ConnectResponseCode.SERVER_UNAVAILABLE) |
|||
.setErrorMsg(failureMsg) |
|||
.setConfiguration(EdgeConfiguration.getDefaultInstance()).build(); |
|||
} |
|||
} |
|||
return ConnectResponseMsg.newBuilder() |
|||
.setResponseCode(ConnectResponseCode.BAD_CREDENTIALS) |
|||
.setErrorMsg("Failed to find the edge! Routing key: " + request.getEdgeRoutingKey()) |
|||
.setConfiguration(EdgeConfiguration.getDefaultInstance()).build(); |
|||
} |
|||
|
|||
private void processSaveEdgeVersionAsAttribute(String edgeVersion) { |
|||
AttributeKvEntry attributeKvEntry = new BaseAttributeKvEntry(new StringDataEntry(DataConstants.EDGE_VERSION_ATTR_KEY, edgeVersion), System.currentTimeMillis()); |
|||
ctx.getAttributesService().save(tenantId, edge.getId(), AttributeScope.SERVER_SCOPE, attributeKvEntry); |
|||
} |
|||
|
|||
private void interruptGeneralProcessingOnSync() { |
|||
log.debug("[{}][{}][{}] Sync process started. General processing interrupted!", tenantId, edge.getId(), sessionId); |
|||
stopCurrentSendDownlinkMsgsTask(true); |
|||
} |
|||
|
|||
protected ListenableFuture<Boolean> sendDownlinkMsgsPack(List<DownlinkMsg> downlinkMsgsPack) { |
|||
interruptPreviousSendDownlinkMsgsTask(); |
|||
|
|||
sessionState.setSendDownlinkMsgsFuture(SettableFuture.create()); |
|||
sessionState.getPendingMsgsMap().clear(); |
|||
|
|||
downlinkMsgsPack.forEach(msg -> sessionState.getPendingMsgsMap().put(msg.getDownlinkMsgId(), msg)); |
|||
scheduleDownlinkMsgsPackSend(1); |
|||
|
|||
return sessionState.getSendDownlinkMsgsFuture(); |
|||
} |
|||
|
|||
private void interruptPreviousSendDownlinkMsgsTask() { |
|||
if (sessionState.getSendDownlinkMsgsFuture() != null && !sessionState.getSendDownlinkMsgsFuture().isDone() |
|||
|| sessionState.getScheduledSendDownlinkTask() != null && !sessionState.getScheduledSendDownlinkTask().isCancelled()) { |
|||
log.debug("[{}][{}][{}] Previous send downlink future was not properly completed, stopping it now!", tenantId, edge.getId(), sessionId); |
|||
stopCurrentSendDownlinkMsgsTask(true); |
|||
} |
|||
} |
|||
|
|||
private void onUplinkMsg(UplinkMsg uplinkMsg) { |
|||
if (isRateLimitViolated(uplinkMsg)) { |
|||
return; |
|||
} |
|||
ListenableFuture<List<Void>> future = processUplinkMsg(uplinkMsg); |
|||
Futures.addCallback(future, new FutureCallback<>() { |
|||
@Override |
|||
public void onSuccess(@Nullable List<Void> result) { |
|||
sendResponseMessage(uplinkMsg.getUplinkMsgId(), true, null); |
|||
} |
|||
|
|||
@Override |
|||
public void onFailure(Throwable t) { |
|||
String errorMsg = EdgeUtils.createErrorMsgFromRootCauseAndStackTrace(t); |
|||
sendResponseMessage(uplinkMsg.getUplinkMsgId(), false, errorMsg); |
|||
} |
|||
}, ctx.getGrpcCallbackExecutorService()); |
|||
} |
|||
|
|||
private boolean isRateLimitViolated(UplinkMsg uplinkMsg) { |
|||
if (!ctx.getRateLimitService().checkRateLimit(LimitedApi.EDGE_UPLINK_MESSAGES, tenantId) || |
|||
!ctx.getRateLimitService().checkRateLimit(LimitedApi.EDGE_UPLINK_MESSAGES_PER_EDGE, tenantId, edge.getId())) { |
|||
String errorMsg = String.format("Failed to process uplink message. %s", RATE_LIMIT_REACHED); |
|||
sendResponseMessage(uplinkMsg.getUplinkMsgId(), false, errorMsg); |
|||
return true; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
private void scheduleDownlinkMsgsPackSend(int attempt) { |
|||
Runnable sendDownlinkMsgsTask = () -> { |
|||
try { |
|||
if (isConnected() && !sessionState.getPendingMsgsMap().values().isEmpty()) { |
|||
List<DownlinkMsg> copy = new ArrayList<>(sessionState.getPendingMsgsMap().values()); |
|||
if (attempt > 1) { |
|||
String error = "Failed to deliver the batch"; |
|||
String failureMsg = String.format("{%s}: {%s}", error, copy); |
|||
if (attempt == 2) { |
|||
// Send a failure notification only on the second attempt.
|
|||
// This ensures that failure alerts are sent just once to avoid redundant notifications.
|
|||
ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId) |
|||
.edgeId(edge.getId()).customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(failureMsg).error(error).build()); |
|||
} |
|||
log.warn("[{}][{}] {}, attempt: {}", tenantId, sessionId, failureMsg, attempt); |
|||
} |
|||
log.trace("[{}][{}][{}] downlink msg(s) are going to be send.", tenantId, sessionId, copy.size()); |
|||
for (DownlinkMsg downlinkMsg : copy) { |
|||
if (clientMaxInboundMessageSize != 0 && downlinkMsg.getSerializedSize() > clientMaxInboundMessageSize) { |
|||
String error = String.format("Client max inbound message size %s is exceeded. Please increase value of CLOUD_RPC_MAX_INBOUND_MESSAGE_SIZE " + |
|||
"env variable on the edge and restart it.", clientMaxInboundMessageSize); |
|||
String message = String.format("Downlink msg size %s exceeds client max inbound message size %s. " + |
|||
"Please increase value of CLOUD_RPC_MAX_INBOUND_MESSAGE_SIZE env variable on the edge and restart it.", downlinkMsg.getSerializedSize(), clientMaxInboundMessageSize); |
|||
log.error("[{}][{}][{}] {} Message {}", tenantId, edge.getId(), sessionId, message, downlinkMsg); |
|||
ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId) |
|||
.edgeId(edge.getId()).customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(message).error(error).build()); |
|||
sessionState.getPendingMsgsMap().remove(downlinkMsg.getDownlinkMsgId()); |
|||
} else { |
|||
sendDownlinkMsg(ResponseMsg.newBuilder() |
|||
.setDownlinkMsg(downlinkMsg) |
|||
.build()); |
|||
} |
|||
} |
|||
if (attempt < MAX_DOWNLINK_ATTEMPTS) { |
|||
scheduleDownlinkMsgsPackSend(attempt + 1); |
|||
} else { |
|||
String failureMsg = String.format("Failed to deliver messages: %s", copy); |
|||
log.warn("[{}][{}] Failed to deliver the batch after {} attempts. Next messages are going to be discarded {}", |
|||
tenantId, sessionId, MAX_DOWNLINK_ATTEMPTS, copy); |
|||
ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId).edgeId(edge.getId()) |
|||
.customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(failureMsg) |
|||
.error("Failed to deliver messages after " + MAX_DOWNLINK_ATTEMPTS + " attempts").build()); |
|||
stopCurrentSendDownlinkMsgsTask(false); |
|||
} |
|||
} else { |
|||
stopCurrentSendDownlinkMsgsTask(false); |
|||
} |
|||
} catch (Exception e) { |
|||
log.warn("[{}][{}] Failed to send downlink msgs. Error msg {}", tenantId, sessionId, e.getMessage(), e); |
|||
stopCurrentSendDownlinkMsgsTask(true); |
|||
} |
|||
}; |
|||
|
|||
if (attempt == 1) { |
|||
sendDownlinkExecutorService.submit(sendDownlinkMsgsTask); |
|||
} else { |
|||
sessionState.setScheduledSendDownlinkTask( |
|||
sendDownlinkExecutorService.schedule( |
|||
sendDownlinkMsgsTask, |
|||
ctx.getEdgeEventStorageSettings().getSleepIntervalBetweenBatches(), |
|||
TimeUnit.MILLISECONDS) |
|||
); |
|||
} |
|||
} |
|||
|
|||
private void sendResponseMessage(int uplinkMsgId, boolean success, String errorMsg) { |
|||
UplinkResponseMsg.Builder responseBuilder = UplinkResponseMsg.newBuilder() |
|||
.setUplinkMsgId(uplinkMsgId) |
|||
.setSuccess(success); |
|||
if (errorMsg != null) { |
|||
responseBuilder.setErrorMsg(errorMsg); |
|||
} |
|||
sendDownlinkMsg(ResponseMsg.newBuilder() |
|||
.setUplinkResponseMsg(responseBuilder.build()) |
|||
.build()); |
|||
} |
|||
|
|||
private void onDownlinkResponse(DownlinkResponseMsg msg) { |
|||
try { |
|||
if (msg.getSuccess()) { |
|||
sessionState.getPendingMsgsMap().remove(msg.getDownlinkMsgId()); |
|||
log.debug("[{}][{}] Msg has been processed successfully! Msg Id: [{}], Msg: {}", tenantId, edge.getRoutingKey(), msg.getDownlinkMsgId(), msg); |
|||
} else { |
|||
log.error("[{}][{}] Msg processing failed! Msg Id: [{}], Error msg: {}", tenantId, edge.getRoutingKey(), msg.getDownlinkMsgId(), msg.getErrorMsg()); |
|||
} |
|||
if (sessionState.getPendingMsgsMap().isEmpty()) { |
|||
log.debug("[{}][{}] Pending msgs map is empty. Stopping current iteration", tenantId, edge.getRoutingKey()); |
|||
stopCurrentSendDownlinkMsgsTask(false); |
|||
} |
|||
} catch (Exception e) { |
|||
log.error("[{}][{}] Can't process downlink response message [{}]", tenantId, sessionId, msg, e); |
|||
} |
|||
} |
|||
|
|||
@Override |
|||
public void processHighPriorityEvents() { |
|||
try { |
|||
List<EdgeEvent> highPriorityEvents = new ArrayList<>(); |
|||
EdgeEvent event; |
|||
while ((event = highPriorityQueue.poll()) != null) { |
|||
highPriorityEvents.add(event); |
|||
} |
|||
List<DownlinkMsg> downlinkMsgsPack = convertToDownlinkMsgsPack(highPriorityEvents); |
|||
sendDownlinkMsgsPack(downlinkMsgsPack).get(); |
|||
} catch (Exception e) { |
|||
log.error("[{}] Failed to process high priority events", sessionId, e); |
|||
} |
|||
} |
|||
|
|||
@Override |
|||
public ListenableFuture<Boolean> processEdgeEvents() throws Exception { |
|||
SettableFuture<Boolean> result = SettableFuture.create(); |
|||
log.trace("[{}][{}] starting processing edge events", tenantId, sessionId); |
|||
if (isConnected() && isSyncCompleted()) { |
|||
Pair<Long, Long> startTsAndSeqId = getQueueStartTsAndSeqId().get(); |
|||
previousStartTs = startTsAndSeqId.getFirst(); |
|||
previousStartSeqId = startTsAndSeqId.getSecond(); |
|||
GeneralEdgeEventFetcher fetcher = new GeneralEdgeEventFetcher( |
|||
previousStartTs, |
|||
previousStartSeqId, |
|||
seqIdEnd, |
|||
false, |
|||
Integer.toUnsignedLong(ctx.getEdgeEventStorageSettings().getMaxReadRecordsCount()), |
|||
ctx.getEdgeEventService()); |
|||
Futures.addCallback(startProcessingEdgeEvents(fetcher), new FutureCallback<>() { |
|||
@Override |
|||
public void onSuccess(@Nullable Pair<Long, Long> newStartTsAndSeqId) { |
|||
if (newStartTsAndSeqId != null) { |
|||
ListenableFuture<List<Long>> updateFuture = updateQueueStartTsAndSeqId(newStartTsAndSeqId); |
|||
Futures.addCallback(updateFuture, new FutureCallback<>() { |
|||
@Override |
|||
public void onSuccess(@Nullable List<Long> list) { |
|||
log.debug("[{}][{}] queue offset was updated [{}]", tenantId, sessionId, newStartTsAndSeqId); |
|||
if (fetcher.isSeqIdNewCycleStarted()) { |
|||
seqIdEnd = fetcher.getSeqIdEnd(); |
|||
boolean newEventsAvailable = isNewEdgeEventsAvailable(); |
|||
result.set(newEventsAvailable); |
|||
} else { |
|||
seqIdEnd = null; |
|||
boolean newEventsAvailable = isSeqIdStartedNewCycle(); |
|||
if (!newEventsAvailable) { |
|||
newEventsAvailable = isNewEdgeEventsAvailable(); |
|||
} |
|||
result.set(newEventsAvailable); |
|||
} |
|||
} |
|||
|
|||
@Override |
|||
public void onFailure(Throwable t) { |
|||
log.error("[{}][{}] Failed to update queue offset [{}]", tenantId, sessionId, newStartTsAndSeqId, t); |
|||
result.setException(t); |
|||
} |
|||
}, ctx.getGrpcCallbackExecutorService()); |
|||
} else { |
|||
log.trace("[{}][{}] newStartTsAndSeqId is null. Skipping iteration without db update", tenantId, sessionId); |
|||
result.set(Boolean.FALSE); |
|||
} |
|||
} |
|||
|
|||
@Override |
|||
public void onFailure(Throwable t) { |
|||
log.error("[{}][{}] Failed to process events", tenantId, sessionId, t); |
|||
result.setException(t); |
|||
} |
|||
}, ctx.getGrpcCallbackExecutorService()); |
|||
} else { |
|||
log.trace("[{}][{}] edge is not connected or sync is not completed. Skipping iteration", tenantId, sessionId); |
|||
result.set(null); |
|||
} |
|||
return result; |
|||
} |
|||
|
|||
protected List<DownlinkMsg> convertToDownlinkMsgsPack(List<EdgeEvent> edgeEvents) { |
|||
List<DownlinkMsg> result = new ArrayList<>(); |
|||
for (EdgeEvent edgeEvent : edgeEvents) { |
|||
log.trace("[{}][{}] converting edge event to downlink msg [{}]", tenantId, sessionId, edgeEvent); |
|||
DownlinkMsg downlinkMsg = null; |
|||
try { |
|||
switch (edgeEvent.getAction()) { |
|||
case UPDATED, ADDED, DELETED, ASSIGNED_TO_EDGE, UNASSIGNED_FROM_EDGE, ALARM_ACK, ALARM_CLEAR, |
|||
ALARM_DELETE, CREDENTIALS_UPDATED, RELATION_ADD_OR_UPDATE, RELATION_DELETED, RPC_CALL, |
|||
ASSIGNED_TO_CUSTOMER, UNASSIGNED_FROM_CUSTOMER, ADDED_COMMENT, UPDATED_COMMENT, DELETED_COMMENT -> { |
|||
downlinkMsg = convertEntityEventToDownlink(edgeEvent); |
|||
if (downlinkMsg != null && downlinkMsg.getWidgetTypeUpdateMsgCount() > 0) { |
|||
log.trace("[{}][{}] widgetTypeUpdateMsg message processed, downlinkMsgId = {}", tenantId, sessionId, downlinkMsg.getDownlinkMsgId()); |
|||
} else { |
|||
log.trace("[{}][{}] entity message processed [{}]", tenantId, sessionId, downlinkMsg); |
|||
} |
|||
} |
|||
case ATTRIBUTES_UPDATED, POST_ATTRIBUTES, ATTRIBUTES_DELETED, TIMESERIES_UPDATED -> |
|||
downlinkMsg = ctx.getTelemetryProcessor().convertTelemetryEventToDownlink(edge, edgeEvent); |
|||
default -> log.warn("[{}][{}] Unsupported action type [{}]", tenantId, sessionId, edgeEvent.getAction()); |
|||
} |
|||
} catch (Exception e) { |
|||
log.error("[{}][{}] Exception during converting edge event to downlink msg", tenantId, sessionId, e); |
|||
} |
|||
if (downlinkMsg != null) { |
|||
result.add(downlinkMsg); |
|||
} |
|||
} |
|||
return result; |
|||
} |
|||
|
|||
private ListenableFuture<Pair<Long, Long>> getQueueStartTsAndSeqId() { |
|||
ListenableFuture<List<AttributeKvEntry>> future = |
|||
ctx.getAttributesService().find(edge.getTenantId(), edge.getId(), AttributeScope.SERVER_SCOPE, Arrays.asList(QUEUE_START_TS_ATTR_KEY, QUEUE_START_SEQ_ID_ATTR_KEY)); |
|||
return Futures.transform(future, attributeKvEntries -> { |
|||
long startTs = 0L; |
|||
long startSeqId = 0L; |
|||
for (AttributeKvEntry attributeKvEntry : attributeKvEntries) { |
|||
if (QUEUE_START_TS_ATTR_KEY.equals(attributeKvEntry.getKey())) { |
|||
startTs = attributeKvEntry.getLongValue().isPresent() ? attributeKvEntry.getLongValue().get() : 0L; |
|||
} |
|||
if (QUEUE_START_SEQ_ID_ATTR_KEY.equals(attributeKvEntry.getKey())) { |
|||
startSeqId = attributeKvEntry.getLongValue().isPresent() ? attributeKvEntry.getLongValue().get() : 0L; |
|||
} |
|||
} |
|||
if (startSeqId == 0L) { |
|||
startSeqId = findStartSeqIdFromOldestEventIfAny(); |
|||
} |
|||
return Pair.of(startTs, startSeqId); |
|||
}, ctx.getGrpcCallbackExecutorService()); |
|||
} |
|||
|
|||
private boolean isSeqIdStartedNewCycle() { |
|||
try { |
|||
TimePageLink pageLink = new TimePageLink(ctx.getEdgeEventStorageSettings().getMaxReadRecordsCount(), 0, null, null, newStartTs, System.currentTimeMillis()); |
|||
PageData<EdgeEvent> edgeEvents = ctx.getEdgeEventService().findEdgeEvents(edge.getTenantId(), edge.getId(), 0L, previousStartSeqId == 0 ? null : previousStartSeqId - 1, pageLink); |
|||
return !edgeEvents.getData().isEmpty(); |
|||
} catch (Exception e) { |
|||
log.error("[{}][{}][{}] Failed to execute isSeqIdStartedNewCycle", tenantId, edge.getId(), sessionId, e); |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
private boolean isNewEdgeEventsAvailable() { |
|||
try { |
|||
TimePageLink pageLink = new TimePageLink(ctx.getEdgeEventStorageSettings().getMaxReadRecordsCount(), 0, null, null, newStartTs, System.currentTimeMillis()); |
|||
PageData<EdgeEvent> edgeEvents = ctx.getEdgeEventService().findEdgeEvents(edge.getTenantId(), edge.getId(), newStartSeqId, null, pageLink); |
|||
return !edgeEvents.getData().isEmpty() || !highPriorityQueue.isEmpty(); |
|||
} catch (Exception e) { |
|||
log.error("[{}][{}][{}] Failed to execute isNewEdgeEventsAvailable", tenantId, edge.getId(), sessionId, e); |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
private long findStartSeqIdFromOldestEventIfAny() { |
|||
long startSeqId = 0L; |
|||
try { |
|||
TimePageLink pageLink = new TimePageLink(1, 0, null, new SortOrder("createdTime"), null, null); |
|||
PageData<EdgeEvent> edgeEvents = ctx.getEdgeEventService().findEdgeEvents(edge.getTenantId(), edge.getId(), null, null, pageLink); |
|||
if (!edgeEvents.getData().isEmpty()) { |
|||
startSeqId = edgeEvents.getData().get(0).getSeqId() - 1; |
|||
} |
|||
} catch (Exception e) { |
|||
log.error("[{}][{}][{}] Failed to execute findStartSeqIdFromOldestEventIfAny", tenantId, edge.getId(), sessionId, e); |
|||
} |
|||
return startSeqId; |
|||
} |
|||
|
|||
private ListenableFuture<List<Long>> updateQueueStartTsAndSeqId(Pair<Long, Long> pair) { |
|||
newStartTs = pair.getFirst(); |
|||
newStartSeqId = pair.getSecond(); |
|||
log.trace("[{}] updateQueueStartTsAndSeqId [{}][{}][{}]", sessionId, edge.getId(), newStartTs, newStartSeqId); |
|||
List<AttributeKvEntry> attributes = Arrays.asList( |
|||
new BaseAttributeKvEntry(new LongDataEntry(QUEUE_START_TS_ATTR_KEY, newStartTs), System.currentTimeMillis()), |
|||
new BaseAttributeKvEntry(new LongDataEntry(QUEUE_START_SEQ_ID_ATTR_KEY, newStartSeqId), System.currentTimeMillis())); |
|||
return ctx.getAttributesService().save(edge.getTenantId(), edge.getId(), AttributeScope.SERVER_SCOPE, attributes); |
|||
} |
|||
|
|||
protected ListenableFuture<Pair<Long, Long>> startProcessingEdgeEvents(EdgeEventFetcher fetcher) { |
|||
SettableFuture<Pair<Long, Long>> result = SettableFuture.create(); |
|||
PageLink pageLink = fetcher.getPageLink(ctx.getEdgeEventStorageSettings().getMaxReadRecordsCount()); |
|||
processEdgeEvents(fetcher, pageLink, result); |
|||
return result; |
|||
} |
|||
|
|||
private void markSyncCompletedSendEdgeEventUpdate() { |
|||
syncCompleted = true; |
|||
ctx.getClusterService().onEdgeEventUpdate(new EdgeEventUpdateMsg(edge.getTenantId(), edge.getId())); |
|||
} |
|||
|
|||
private void stopCurrentSendDownlinkMsgsTask(Boolean isInterrupted) { |
|||
if (sessionState.getSendDownlinkMsgsFuture() != null && !sessionState.getSendDownlinkMsgsFuture().isDone()) { |
|||
sessionState.getSendDownlinkMsgsFuture().set(isInterrupted); |
|||
} |
|||
if (sessionState.getScheduledSendDownlinkTask() != null) { |
|||
sessionState.getScheduledSendDownlinkTask().cancel(true); |
|||
} |
|||
} |
|||
|
|||
private void sendDownlinkMsg(ResponseMsg downlinkMsg) { |
|||
if (downlinkMsg.getDownlinkMsg().getWidgetTypeUpdateMsgCount() > 0) { |
|||
log.trace("[{}][{}] Sending downlink widgetTypeUpdateMsg, downlinkMsgId = {}", tenantId, sessionId, downlinkMsg.getDownlinkMsg().getDownlinkMsgId()); |
|||
} else { |
|||
log.trace("[{}][{}] Sending downlink msg [{}]", tenantId, sessionId, downlinkMsg); |
|||
} |
|||
if (isConnected()) { |
|||
downlinkMsgLock.lock(); |
|||
try { |
|||
outputStream.onNext(downlinkMsg); |
|||
} catch (Exception e) { |
|||
log.error("[{}][{}] Failed to send downlink message [{}]", tenantId, sessionId, downlinkMsg, e); |
|||
connected = false; |
|||
sessionCloseListener.accept(edge, sessionId); |
|||
} finally { |
|||
downlinkMsgLock.unlock(); |
|||
} |
|||
log.trace("[{}][{}] Response msg successfully sent. downlinkMsgId = {}", tenantId, sessionId, downlinkMsg.getDownlinkMsg().getDownlinkMsgId()); |
|||
} |
|||
} |
|||
|
|||
protected DownlinkMsg convertEntityEventToDownlink(EdgeEvent edgeEvent) { |
|||
log.trace("[{}] Executing convertEntityEventToDownlink, edgeEvent [{}], action [{}]", edgeEvent.getTenantId(), edgeEvent, edgeEvent.getAction()); |
|||
return switch (edgeEvent.getType()) { |
|||
case EDGE -> ctx.getEdgeProcessor().convertEdgeEventToDownlink(edgeEvent); |
|||
case DEVICE -> ctx.getDeviceProcessor().convertDeviceEventToDownlink(edgeEvent, edgeVersion); |
|||
case DEVICE_PROFILE -> ctx.getDeviceProfileProcessor().convertDeviceProfileEventToDownlink(edgeEvent, edgeVersion); |
|||
case ASSET_PROFILE -> ctx.getAssetProfileProcessor().convertAssetProfileEventToDownlink(edgeEvent, edgeVersion); |
|||
case ASSET -> ctx.getAssetProcessor().convertAssetEventToDownlink(edgeEvent, edgeVersion); |
|||
case ENTITY_VIEW -> ctx.getEntityViewProcessor().convertEntityViewEventToDownlink(edgeEvent, edgeVersion); |
|||
case DASHBOARD -> ctx.getDashboardProcessor().convertDashboardEventToDownlink(edgeEvent, edgeVersion); |
|||
case CUSTOMER -> ctx.getCustomerProcessor().convertCustomerEventToDownlink(edgeEvent, edgeVersion); |
|||
case RULE_CHAIN -> ctx.getRuleChainProcessor().convertRuleChainEventToDownlink(edgeEvent, edgeVersion); |
|||
case RULE_CHAIN_METADATA -> ctx.getRuleChainProcessor().convertRuleChainMetadataEventToDownlink(edgeEvent, edgeVersion); |
|||
case ALARM -> ctx.getAlarmProcessor().convertAlarmEventToDownlink(edgeEvent, edgeVersion); |
|||
case ALARM_COMMENT -> ctx.getAlarmProcessor().convertAlarmCommentEventToDownlink(edgeEvent, edgeVersion); |
|||
case USER -> ctx.getUserProcessor().convertUserEventToDownlink(edgeEvent, edgeVersion); |
|||
case RELATION -> ctx.getRelationProcessor().convertRelationEventToDownlink(edgeEvent, edgeVersion); |
|||
case WIDGETS_BUNDLE -> ctx.getWidgetBundleProcessor().convertWidgetsBundleEventToDownlink(edgeEvent, edgeVersion); |
|||
case WIDGET_TYPE -> ctx.getWidgetTypeProcessor().convertWidgetTypeEventToDownlink(edgeEvent, edgeVersion); |
|||
case ADMIN_SETTINGS -> ctx.getAdminSettingsProcessor().convertAdminSettingsEventToDownlink(edgeEvent, edgeVersion); |
|||
case OTA_PACKAGE -> ctx.getOtaPackageProcessor().convertOtaPackageEventToDownlink(edgeEvent, edgeVersion); |
|||
case TB_RESOURCE -> ctx.getResourceProcessor().convertResourceEventToDownlink(edgeEvent, edgeVersion); |
|||
case QUEUE -> ctx.getQueueProcessor().convertQueueEventToDownlink(edgeEvent, edgeVersion); |
|||
case TENANT -> ctx.getTenantProcessor().convertTenantEventToDownlink(edgeEvent, edgeVersion); |
|||
case TENANT_PROFILE -> ctx.getTenantProfileProcessor().convertTenantProfileEventToDownlink(edgeEvent, edgeVersion); |
|||
case NOTIFICATION_RULE -> ctx.getNotificationEdgeProcessor().convertNotificationRuleToDownlink(edgeEvent); |
|||
case NOTIFICATION_TARGET -> ctx.getNotificationEdgeProcessor().convertNotificationTargetToDownlink(edgeEvent); |
|||
case NOTIFICATION_TEMPLATE -> ctx.getNotificationEdgeProcessor().convertNotificationTemplateToDownlink(edgeEvent); |
|||
case OAUTH2_CLIENT -> ctx.getOAuth2EdgeProcessor().convertOAuth2ClientEventToDownlink(edgeEvent, edgeVersion); |
|||
case DOMAIN -> ctx.getOAuth2EdgeProcessor().convertOAuth2DomainEventToDownlink(edgeEvent, edgeVersion); |
|||
default -> { |
|||
log.warn("[{}] Unsupported edge event type [{}]", edgeEvent.getTenantId(), edgeEvent); |
|||
yield null; |
|||
} |
|||
}; |
|||
} |
|||
|
|||
public void addEventToHighPriorityQueue(EdgeEvent edgeEvent) { |
|||
while (highPriorityQueue.size() > maxHighPriorityQueueSizePerSession) { |
|||
EdgeEvent oldestHighPriority = highPriorityQueue.poll(); |
|||
if (oldestHighPriority != null) { |
|||
log.warn("[{}][{}][{}] High priority queue is full. Removing oldest high priority event from queue {}", |
|||
tenantId, edge.getId(), sessionId, oldestHighPriority); |
|||
} |
|||
} |
|||
highPriorityQueue.add(edgeEvent); |
|||
} |
|||
|
|||
protected ListenableFuture<List<Void>> processUplinkMsg(UplinkMsg uplinkMsg) { |
|||
List<ListenableFuture<Void>> result = new ArrayList<>(); |
|||
try { |
|||
if (uplinkMsg.getDeviceProfileUpdateMsgCount() > 0) { |
|||
for (DeviceProfileUpdateMsg deviceProfileUpdateMsg : uplinkMsg.getDeviceProfileUpdateMsgList()) { |
|||
result.add(((DeviceProfileProcessor) ctx.getDeviceProfileEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processDeviceProfileMsgFromEdge(edge.getTenantId(), edge, deviceProfileUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getDeviceUpdateMsgCount() > 0) { |
|||
for (DeviceUpdateMsg deviceUpdateMsg : uplinkMsg.getDeviceUpdateMsgList()) { |
|||
result.add(((DeviceProcessor) ctx.getDeviceEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processDeviceMsgFromEdge(edge.getTenantId(), edge, deviceUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getDeviceCredentialsUpdateMsgCount() > 0) { |
|||
for (DeviceCredentialsUpdateMsg deviceCredentialsUpdateMsg : uplinkMsg.getDeviceCredentialsUpdateMsgList()) { |
|||
result.add(((DeviceProcessor) ctx.getDeviceEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processDeviceCredentialsMsgFromEdge(edge.getTenantId(), edge.getId(), deviceCredentialsUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getAssetProfileUpdateMsgCount() > 0) { |
|||
for (AssetProfileUpdateMsg assetProfileUpdateMsg : uplinkMsg.getAssetProfileUpdateMsgList()) { |
|||
result.add(((AssetProfileProcessor) ctx.getAssetProfileEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processAssetProfileMsgFromEdge(edge.getTenantId(), edge, assetProfileUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getAssetUpdateMsgCount() > 0) { |
|||
for (AssetUpdateMsg assetUpdateMsg : uplinkMsg.getAssetUpdateMsgList()) { |
|||
result.add(((AssetProcessor) ctx.getAssetEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processAssetMsgFromEdge(edge.getTenantId(), edge, assetUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getEntityViewUpdateMsgCount() > 0) { |
|||
for (EntityViewUpdateMsg entityViewUpdateMsg : uplinkMsg.getEntityViewUpdateMsgList()) { |
|||
result.add(((EntityViewProcessor) ctx.getEntityViewProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processEntityViewMsgFromEdge(edge.getTenantId(), edge, entityViewUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getEntityDataCount() > 0) { |
|||
for (EntityDataProto entityData : uplinkMsg.getEntityDataList()) { |
|||
result.addAll(ctx.getTelemetryProcessor().processTelemetryMsg(edge.getTenantId(), entityData)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getAlarmUpdateMsgCount() > 0) { |
|||
for (AlarmUpdateMsg alarmUpdateMsg : uplinkMsg.getAlarmUpdateMsgList()) { |
|||
result.add(((AlarmProcessor) ctx.getAlarmEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processAlarmMsgFromEdge(edge.getTenantId(), edge.getId(), alarmUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getAlarmCommentUpdateMsgCount() > 0) { |
|||
for (AlarmCommentUpdateMsg alarmCommentUpdateMsg : uplinkMsg.getAlarmCommentUpdateMsgList()) { |
|||
result.add(((AlarmProcessor) ctx.getAlarmEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processAlarmCommentMsgFromEdge(edge.getTenantId(), edge.getId(), alarmCommentUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getRelationUpdateMsgCount() > 0) { |
|||
for (RelationUpdateMsg relationUpdateMsg : uplinkMsg.getRelationUpdateMsgList()) { |
|||
result.add(((RelationProcessor) ctx.getRelationEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processRelationMsgFromEdge(edge.getTenantId(), edge, relationUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getDashboardUpdateMsgCount() > 0) { |
|||
for (DashboardUpdateMsg dashboardUpdateMsg : uplinkMsg.getDashboardUpdateMsgList()) { |
|||
result.add(((DashboardProcessor) ctx.getDashboardEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processDashboardMsgFromEdge(edge.getTenantId(), edge, dashboardUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getResourceUpdateMsgCount() > 0) { |
|||
for (ResourceUpdateMsg resourceUpdateMsg : uplinkMsg.getResourceUpdateMsgList()) { |
|||
result.add(((ResourceProcessor) ctx.getResourceEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processResourceMsgFromEdge(edge.getTenantId(), edge, resourceUpdateMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getRuleChainMetadataRequestMsgCount() > 0) { |
|||
for (RuleChainMetadataRequestMsg ruleChainMetadataRequestMsg : uplinkMsg.getRuleChainMetadataRequestMsgList()) { |
|||
result.add(ctx.getEdgeRequestsService().processRuleChainMetadataRequestMsg(edge.getTenantId(), edge, ruleChainMetadataRequestMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getAttributesRequestMsgCount() > 0) { |
|||
for (AttributesRequestMsg attributesRequestMsg : uplinkMsg.getAttributesRequestMsgList()) { |
|||
result.add(ctx.getEdgeRequestsService().processAttributesRequestMsg(edge.getTenantId(), edge, attributesRequestMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getRelationRequestMsgCount() > 0) { |
|||
for (RelationRequestMsg relationRequestMsg : uplinkMsg.getRelationRequestMsgList()) { |
|||
result.add(ctx.getEdgeRequestsService().processRelationRequestMsg(edge.getTenantId(), edge, relationRequestMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getUserCredentialsRequestMsgCount() > 0) { |
|||
for (UserCredentialsRequestMsg userCredentialsRequestMsg : uplinkMsg.getUserCredentialsRequestMsgList()) { |
|||
result.add(ctx.getEdgeRequestsService().processUserCredentialsRequestMsg(edge.getTenantId(), edge, userCredentialsRequestMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getDeviceCredentialsRequestMsgCount() > 0) { |
|||
for (DeviceCredentialsRequestMsg deviceCredentialsRequestMsg : uplinkMsg.getDeviceCredentialsRequestMsgList()) { |
|||
result.add(ctx.getEdgeRequestsService().processDeviceCredentialsRequestMsg(edge.getTenantId(), edge, deviceCredentialsRequestMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getDeviceRpcCallMsgCount() > 0) { |
|||
for (DeviceRpcCallMsg deviceRpcCallMsg : uplinkMsg.getDeviceRpcCallMsgList()) { |
|||
result.add(((DeviceProcessor) ctx.getDeviceEdgeProcessorFactory().getProcessorByEdgeVersion(edgeVersion)) |
|||
.processDeviceRpcCallFromEdge(edge.getTenantId(), edge, deviceRpcCallMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getWidgetBundleTypesRequestMsgCount() > 0) { |
|||
for (WidgetBundleTypesRequestMsg widgetBundleTypesRequestMsg : uplinkMsg.getWidgetBundleTypesRequestMsgList()) { |
|||
result.add(ctx.getEdgeRequestsService().processWidgetBundleTypesRequestMsg(edge.getTenantId(), edge, widgetBundleTypesRequestMsg)); |
|||
} |
|||
} |
|||
if (uplinkMsg.getEntityViewsRequestMsgCount() > 0) { |
|||
for (EntityViewsRequestMsg entityViewRequestMsg : uplinkMsg.getEntityViewsRequestMsgList()) { |
|||
result.add(ctx.getEdgeRequestsService().processEntityViewsRequestMsg(edge.getTenantId(), edge, entityViewRequestMsg)); |
|||
} |
|||
} |
|||
} catch (Exception e) { |
|||
String failureMsg = String.format("Can't process uplink msg [%s] from edge", uplinkMsg); |
|||
log.error("[{}][{}] Can't process uplink msg [{}]", edge.getTenantId(), sessionId, uplinkMsg, e); |
|||
ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(edge.getTenantId()).edgeId(edge.getId()) |
|||
.customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(failureMsg).error(e.getMessage()).build()); |
|||
return Futures.immediateFailedFuture(e); |
|||
} |
|||
return Futures.allAsList(result); |
|||
} |
|||
|
|||
@Override |
|||
public void close() { |
|||
log.debug("[{}][{}] Closing session", tenantId, sessionId); |
|||
connected = false; |
|||
try { |
|||
outputStream.onCompleted(); |
|||
} catch (Exception e) { |
|||
log.debug("[{}][{}] Failed to close output stream: {}", tenantId, sessionId, e.getMessage()); |
|||
} |
|||
} |
|||
|
|||
} |
|||
Loading…
Reference in new issue