dendi-wang/thingsboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added ALARM entity support

Browse Source
This commit is contained in:
Volodymyr Babak 2019-11-18 19:37:16 +02:00
parent c99cf51ca6
commit acfaf68042
8 changed files with 227 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
application/src/main/java/org/thingsboard/server/actors/ruleChain/RuleChainActorMessageProcessor.java
View File

@ -350,6 +350,8 @@ public class RuleChainActorMessageProcessor extends ComponentMsgProcessor<RuleCh
case DataConstants.ENTITY_DELETED: case DataConstants.ENTITY_DELETED:
case DataConstants.ENTITY_ASSIGNED_TO_EDGE: case DataConstants.ENTITY_ASSIGNED_TO_EDGE:
case DataConstants.ENTITY_UNASSIGNED_FROM_EDGE: case DataConstants.ENTITY_UNASSIGNED_FROM_EDGE:
case DataConstants.ALARM_ACK:
case DataConstants.ALARM_CLEAR:
edgeService.pushEventToEdge(tenantId, msg, new FutureCallback<Void>() { edgeService.pushEventToEdge(tenantId, msg, new FutureCallback<Void>() {
@Override @Override
public void onSuccess(@Nullable Void aVoid) { public void onSuccess(@Nullable Void aVoid) {

33
application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcService.java
View File

@ -25,20 +25,9 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.thingsboard.server.actors.service.ActorService;
import org.thingsboard.server.common.data.Event;
import org.thingsboard.server.common.data.edge.Edge;
import org.thingsboard.server.common.data.id.DeviceId;
import org.thingsboard.server.common.data.id.EdgeId; import org.thingsboard.server.common.data.id.EdgeId;
import org.thingsboard.server.common.data.id.RuleChainId;
import org.thingsboard.server.common.data.id.TenantId; import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.common.data.page.TimePageData;
import org.thingsboard.server.common.data.page.TimePageLink;
import org.thingsboard.server.dao.asset.AssetService;
import org.thingsboard.server.dao.attributes.AttributesService;
import org.thingsboard.server.dao.device.DeviceService;
import org.thingsboard.server.dao.edge.EdgeService;
import org.thingsboard.server.dao.entityview.EntityViewService;
import org.thingsboard.server.dao.event.EventService;
import org.thingsboard.server.gen.edge.EdgeRpcServiceGrpc; import org.thingsboard.server.gen.edge.EdgeRpcServiceGrpc;
import org.thingsboard.server.gen.edge.RequestMsg; import org.thingsboard.server.gen.edge.RequestMsg;
import org.thingsboard.server.gen.edge.ResponseMsg; import org.thingsboard.server.gen.edge.ResponseMsg;
@ -52,7 +41,6 @@ import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
@Service @Service
@Slf4j @Slf4j
@ -74,24 +62,6 @@ public class EdgeGrpcService extends EdgeRpcServiceGrpc.EdgeRpcServiceImplBase {
@Autowired @Autowired
private EdgeContextComponent ctx; private EdgeContextComponent ctx;
@Autowired
private EdgeService edgeService;
@Autowired
private AssetService assetService;
@Autowired
private DeviceService deviceService;
@Autowired
private EntityViewService entityViewService;
@Autowired
private AttributesService attributesService;
@Autowired
private ActorService actorService;
private Server server; private Server server;
private ExecutorService executor; private ExecutorService executor;
@ -156,4 +126,5 @@ public class EdgeGrpcService extends EdgeRpcServiceGrpc.EdgeRpcServiceImplBase {
private void onEdgeDisconnect(EdgeId edgeId) { private void onEdgeDisconnect(EdgeId edgeId) {
sessions.remove(edgeId); sessions.remove(edgeId);
} }
} }

121
application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcSession.java
View File

@ -31,6 +31,7 @@ import org.thingsboard.server.common.data.Device;
import org.thingsboard.server.common.data.EntityType; import org.thingsboard.server.common.data.EntityType;
import org.thingsboard.server.common.data.EntityView; import org.thingsboard.server.common.data.EntityView;
import org.thingsboard.server.common.data.Event; import org.thingsboard.server.common.data.Event;
import org.thingsboard.server.common.data.alarm.Alarm;
import org.thingsboard.server.common.data.asset.Asset; import org.thingsboard.server.common.data.asset.Asset;
import org.thingsboard.server.common.data.edge.Edge; import org.thingsboard.server.common.data.edge.Edge;
import org.thingsboard.server.common.data.edge.EdgeQueueEntry; import org.thingsboard.server.common.data.edge.EdgeQueueEntry;
@ -59,6 +60,7 @@ import org.thingsboard.server.common.msg.cluster.SendToClusterMsg;
import org.thingsboard.server.common.msg.session.SessionMsgType; import org.thingsboard.server.common.msg.session.SessionMsgType;
import org.thingsboard.server.common.msg.system.ServiceToRuleEngineMsg; import org.thingsboard.server.common.msg.system.ServiceToRuleEngineMsg;
import org.thingsboard.server.dao.util.mapping.JacksonUtil; import org.thingsboard.server.dao.util.mapping.JacksonUtil;
import org.thingsboard.server.gen.edge.AlarmUpdateMsg;
import org.thingsboard.server.gen.edge.AssetUpdateMsg; import org.thingsboard.server.gen.edge.AssetUpdateMsg;
import org.thingsboard.server.gen.edge.ConnectRequestMsg; import org.thingsboard.server.gen.edge.ConnectRequestMsg;
import org.thingsboard.server.gen.edge.ConnectResponseCode; import org.thingsboard.server.gen.edge.ConnectResponseCode;
@ -68,6 +70,7 @@ import org.thingsboard.server.gen.edge.DeviceUpdateMsg;
import org.thingsboard.server.gen.edge.DownlinkMsg; import org.thingsboard.server.gen.edge.DownlinkMsg;
import org.thingsboard.server.gen.edge.EdgeConfiguration; import org.thingsboard.server.gen.edge.EdgeConfiguration;
import org.thingsboard.server.gen.edge.EntityDataProto; import org.thingsboard.server.gen.edge.EntityDataProto;
import org.thingsboard.server.gen.edge.EntityUpdateMsg;
import org.thingsboard.server.gen.edge.EntityViewUpdateMsg; import org.thingsboard.server.gen.edge.EntityViewUpdateMsg;
import org.thingsboard.server.gen.edge.NodeConnectionInfoProto; import org.thingsboard.server.gen.edge.NodeConnectionInfoProto;
import org.thingsboard.server.gen.edge.RequestMsg; import org.thingsboard.server.gen.edge.RequestMsg;
@ -140,11 +143,6 @@ public final class EdgeGrpcSession implements Cloneable {
.setUplinkResponseMsg(processUplinkMsg(requestMsg.getUplinkMsg())) .setUplinkResponseMsg(processUplinkMsg(requestMsg.getUplinkMsg()))
.build()); .build());
} }
if (requestMsg.getMsgType().equals(RequestMsgType.DEVICE_UPDATE_RPC_MESSAGE) && requestMsg.hasDeviceUpdateMsg()) {
outputStream.onNext(ResponseMsg.newBuilder()
.setUplinkResponseMsg(processUplinkMsg(requestMsg.getUplinkMsg()))
.build());
}
} }
} }
@ -161,6 +159,7 @@ public final class EdgeGrpcSession implements Cloneable {
}; };
} }
void processHandleMessages() throws ExecutionException, InterruptedException { void processHandleMessages() throws ExecutionException, InterruptedException {
Long queueStartTs = getQueueStartTs().get(); Long queueStartTs = getQueueStartTs().get();
// TODO: this 100 value must be changed properly // TODO: this 100 value must be changed properly
@ -170,7 +169,6 @@ public final class EdgeGrpcSession implements Cloneable {
do { do {
pageData = ctx.getEdgeService().findQueueEvents(edge.getTenantId(), edge.getId(), pageLink); pageData = ctx.getEdgeService().findQueueEvents(edge.getTenantId(), edge.getId(), pageLink);
if (!pageData.getData().isEmpty()) { if (!pageData.getData().isEmpty()) {
edge = ctx.getEdgeService().findEdgeById(edge.getTenantId(), edge.getId());
for (Event event : pageData.getData()) { for (Event event : pageData.getData()) {
EdgeQueueEntry entry; EdgeQueueEntry entry;
try { try {
@ -181,6 +179,8 @@ public final class EdgeGrpcSession implements Cloneable {
case ENTITY_DELETED_RPC_MESSAGE: case ENTITY_DELETED_RPC_MESSAGE:
case ENTITY_UPDATED_RPC_MESSAGE: case ENTITY_UPDATED_RPC_MESSAGE:
case ENTITY_CREATED_RPC_MESSAGE: case ENTITY_CREATED_RPC_MESSAGE:
case ALARM_ACK_RPC_MESSAGE:
case ALARM_CLEARK_RPC_MESSAGE:
processEntityCRUDMessage(entry, msgType); processEntityCRUDMessage(entry, msgType);
break; break;
case RULE_CHAIN_CUSTOM_MESSAGE: case RULE_CHAIN_CUSTOM_MESSAGE:
@ -239,6 +239,10 @@ public final class EdgeGrpcSession implements Cloneable {
private void processEntityCRUDMessage(EdgeQueueEntry entry, UpdateMsgType msgType) throws java.io.IOException { private void processEntityCRUDMessage(EdgeQueueEntry entry, UpdateMsgType msgType) throws java.io.IOException {
log.trace("Executing processEntityCRUDMessage, entry [{}], msgType [{}]", entry, msgType); log.trace("Executing processEntityCRUDMessage, entry [{}], msgType [{}]", entry, msgType);
switch (entry.getEntityType()) { switch (entry.getEntityType()) {
case EDGE:
Edge edge = objectMapper.readValue(entry.getData(), Edge.class);
onEdgeUpdated(msgType, edge);
break;
case DEVICE: case DEVICE:
Device device = objectMapper.readValue(entry.getData(), Device.class); Device device = objectMapper.readValue(entry.getData(), Device.class);
onDeviceUpdated(msgType, device); onDeviceUpdated(msgType, device);
@ -263,6 +267,10 @@ public final class EdgeGrpcSession implements Cloneable {
RuleChainMetaData ruleChainMetaData = objectMapper.readValue(entry.getData(), RuleChainMetaData.class); RuleChainMetaData ruleChainMetaData = objectMapper.readValue(entry.getData(), RuleChainMetaData.class);
onRuleChainMetadataUpdated(msgType, ruleChainMetaData); onRuleChainMetadataUpdated(msgType, ruleChainMetaData);
break; break;
case ALARM:
Alarm alarm = objectMapper.readValue(entry.getData(), Alarm.class);
onAlarmUpdated(msgType, alarm);
break;
} }
} }
@ -284,45 +292,107 @@ public final class EdgeGrpcSession implements Cloneable {
} ); } );
} }
private void onEdgeUpdated(UpdateMsgType msgType, Edge edge) {
// TODO: voba add configuration update to edge
this.edge = edge;
}
private void onDeviceUpdated(UpdateMsgType msgType, Device device) { private void onDeviceUpdated(UpdateMsgType msgType, Device device) {
outputStream.onNext(ResponseMsg.newBuilder() EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
.setDeviceUpdateMsg(constructDeviceUpdatedMsg(msgType, device)) .setDeviceUpdateMsg(constructDeviceUpdatedMsg(msgType, device))
.build();
outputStream.onNext(ResponseMsg.newBuilder()
.setEntityUpdateMsg(entityUpdateMsg)
.build()); .build());
} }
private void onAssetUpdated(UpdateMsgType msgType, Asset asset) { private void onAssetUpdated(UpdateMsgType msgType, Asset asset) {
outputStream.onNext(ResponseMsg.newBuilder() EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
.setAssetUpdateMsg(constructAssetUpdatedMsg(msgType, asset)) .setAssetUpdateMsg(constructAssetUpdatedMsg(msgType, asset))
.build();
outputStream.onNext(ResponseMsg.newBuilder()
.setEntityUpdateMsg(entityUpdateMsg)
.build()); .build());
} }
private void onEntityViewUpdated(UpdateMsgType msgType, EntityView entityView) { private void onEntityViewUpdated(UpdateMsgType msgType, EntityView entityView) {
outputStream.onNext(ResponseMsg.newBuilder() EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
.setEntityViewUpdateMsg(constructEntityViewUpdatedMsg(msgType, entityView)) .setEntityViewUpdateMsg(constructEntityViewUpdatedMsg(msgType, entityView))
.build();
outputStream.onNext(ResponseMsg.newBuilder()
.setEntityUpdateMsg(entityUpdateMsg)
.build()); .build());
} }
private void onRuleChainUpdated(UpdateMsgType msgType, RuleChain ruleChain) { private void onRuleChainUpdated(UpdateMsgType msgType, RuleChain ruleChain) {
outputStream.onNext(ResponseMsg.newBuilder() EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
.setRuleChainUpdateMsg(constructRuleChainUpdatedMsg(msgType, ruleChain)) .setRuleChainUpdateMsg(constructRuleChainUpdatedMsg(msgType, ruleChain))
.build();
outputStream.onNext(ResponseMsg.newBuilder()
.setEntityUpdateMsg(entityUpdateMsg)
.build()); .build());
} }
private void onRuleChainMetadataUpdated(UpdateMsgType msgType, RuleChainMetaData ruleChainMetaData) { private void onRuleChainMetadataUpdated(UpdateMsgType msgType, RuleChainMetaData ruleChainMetaData) {
RuleChainMetadataUpdateMsg ruleChainMetadataUpdateMsg = constructRuleChainMetadataUpdatedMsg(msgType, ruleChainMetaData); RuleChainMetadataUpdateMsg ruleChainMetadataUpdateMsg = constructRuleChainMetadataUpdatedMsg(msgType, ruleChainMetaData);
if (ruleChainMetadataUpdateMsg != null) { if (ruleChainMetadataUpdateMsg != null) {
outputStream.onNext(ResponseMsg.newBuilder() EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
.setRuleChainMetadataUpdateMsg(ruleChainMetadataUpdateMsg) .setRuleChainMetadataUpdateMsg(ruleChainMetadataUpdateMsg)
.build();
outputStream.onNext(ResponseMsg.newBuilder()
.setEntityUpdateMsg(entityUpdateMsg)
.build()); .build());
} }
} }
private void onDashboardUpdated(UpdateMsgType msgType, Dashboard dashboard) { private void onDashboardUpdated(UpdateMsgType msgType, Dashboard dashboard) {
outputStream.onNext(ResponseMsg.newBuilder() EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
.setDashboardUpdateMsg(constructDashboardUpdatedMsg(msgType, dashboard)) .setDashboardUpdateMsg(constructDashboardUpdatedMsg(msgType, dashboard))
.build();
outputStream.onNext(ResponseMsg.newBuilder()
.setEntityUpdateMsg(entityUpdateMsg)
.build()); .build());
} }
private void onAlarmUpdated(UpdateMsgType msgType, Alarm alarm) {
EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
.setAlarmUpdateMsg(constructAlarmUpdatedMsg(msgType, alarm))
.build();
outputStream.onNext(ResponseMsg.newBuilder()
.setEntityUpdateMsg(entityUpdateMsg)
.build());
}
private AlarmUpdateMsg constructAlarmUpdatedMsg(UpdateMsgType msgType, Alarm alarm) {
String entityName = null;
switch (alarm.getOriginator().getEntityType()) {
case DEVICE:
entityName = ctx.getDeviceService().findDeviceById(edge.getTenantId(), new DeviceId(alarm.getOriginator().getId())).getName();
break;
case ASSET:
entityName = ctx.getAssetService().findAssetById(edge.getTenantId(), new AssetId(alarm.getOriginator().getId())).getName();
break;
case ENTITY_VIEW:
entityName = ctx.getEntityViewService().findEntityViewById(edge.getTenantId(), new EntityViewId(alarm.getOriginator().getId())).getName();
break;
}
AlarmUpdateMsg.Builder builder = AlarmUpdateMsg.newBuilder()
.setMsgType(msgType)
.setName(alarm.getName())
.setType(alarm.getName())
.setOriginatorName(entityName)
.setOriginatorType(alarm.getOriginator().getEntityType().name())
.setSeverity(alarm.getSeverity().name())
.setStatus(alarm.getStatus().name())
.setStartTs(alarm.getStartTs())
.setEndTs(alarm.getEndTs())
.setAckTs(alarm.getAckTs())
.setClearTs(alarm.getClearTs())
.setDetails(JacksonUtil.toString(alarm.getDetails()))
.setPropagate(alarm.isPropagate());
return builder.build();
}
private UpdateMsgType getResponseMsgType(String msgType) { private UpdateMsgType getResponseMsgType(String msgType) {
if (msgType.equals(SessionMsgType.POST_TELEMETRY_REQUEST.name()) || if (msgType.equals(SessionMsgType.POST_TELEMETRY_REQUEST.name()) ||
msgType.equals(SessionMsgType.POST_ATTRIBUTES_REQUEST.name()) || msgType.equals(SessionMsgType.POST_ATTRIBUTES_REQUEST.name()) ||
@ -504,31 +574,31 @@ public final class EdgeGrpcSession implements Cloneable {
if (uplinkMsg.getEntityDataList() != null && !uplinkMsg.getEntityDataList().isEmpty()) { if (uplinkMsg.getEntityDataList() != null && !uplinkMsg.getEntityDataList().isEmpty()) {
for (EntityDataProto entityData : uplinkMsg.getEntityDataList()) { for (EntityDataProto entityData : uplinkMsg.getEntityDataList()) {
TbMsg tbMsg = null; TbMsg tbMsg = null;
TbMsg tmp = TbMsg.fromBytes(entityData.getTbMsg().toByteArray()); TbMsg originalTbMsg = TbMsg.fromBytes(entityData.getTbMsg().toByteArray());
switch (tmp.getOriginator().getEntityType()) { switch (originalTbMsg.getOriginator().getEntityType()) {
case DEVICE: case DEVICE:
String deviceName = entityData.getEntityName(); String deviceName = entityData.getEntityName();
String deviceType = entityData.getEntityType(); String deviceType = entityData.getEntityType();
Device device = getOrCreateDevice(deviceName, deviceType); Device device = getOrCreateDevice(deviceName, deviceType);
if (device != null) { if (device != null) {
tbMsg = new TbMsg(UUIDs.timeBased(), tmp.getType(), device.getId(), tmp.getMetaData().copy(), tbMsg = new TbMsg(UUIDs.timeBased(), originalTbMsg.getType(), device.getId(), originalTbMsg.getMetaData().copy(),
tmp.getDataType(), tmp.getData(), null, null, 0L); originalTbMsg.getDataType(), originalTbMsg.getData(), null, null, 0L);
} }
break; break;
case ASSET: case ASSET:
String assetName = entityData.getEntityName(); String assetName = entityData.getEntityName();
Asset asset = ctx.getAssetService().findAssetByTenantIdAndName(edge.getTenantId(), assetName); Asset asset = ctx.getAssetService().findAssetByTenantIdAndName(edge.getTenantId(), assetName);
if (asset != null) { if (asset != null) {
tbMsg = new TbMsg(UUIDs.timeBased(), tmp.getType(), asset.getId(), tmp.getMetaData().copy(), tbMsg = new TbMsg(UUIDs.timeBased(), originalTbMsg.getType(), asset.getId(), originalTbMsg.getMetaData().copy(),
tmp.getDataType(), tmp.getData(), null, null, 0L); originalTbMsg.getDataType(), originalTbMsg.getData(), null, null, 0L);
} }
break; break;
case ENTITY_VIEW: case ENTITY_VIEW:
String entityViewName = entityData.getEntityName(); String entityViewName = entityData.getEntityName();
EntityView entityView = ctx.getEntityViewService().findEntityViewByTenantIdAndName(edge.getTenantId(), entityViewName); EntityView entityView = ctx.getEntityViewService().findEntityViewByTenantIdAndName(edge.getTenantId(), entityViewName);
if (entityView != null) { if (entityView != null) {
tbMsg = new TbMsg(UUIDs.timeBased(), tmp.getType(), entityView.getId(), tmp.getMetaData().copy(), tbMsg = new TbMsg(UUIDs.timeBased(), originalTbMsg.getType(), entityView.getId(), originalTbMsg.getMetaData().copy(),
tmp.getDataType(), tmp.getData(), null, null, 0L); originalTbMsg.getDataType(), originalTbMsg.getData(), null, null, 0L);
} }
break; break;
} }
@ -537,6 +607,17 @@ public final class EdgeGrpcSession implements Cloneable {
} }
} }
} }
if (uplinkMsg.getDeviceUpdateMsgList() != null && !uplinkMsg.getDeviceUpdateMsgList().isEmpty()) {
for (DeviceUpdateMsg deviceUpdateMsg : uplinkMsg.getDeviceUpdateMsgList()) {
String deviceName = deviceUpdateMsg.getName();
String deviceType = deviceUpdateMsg.getType();
switch (deviceUpdateMsg.getMsgType()) {
case ENTITY_CREATED_RPC_MESSAGE:
getOrCreateDevice(deviceName, deviceType);
break;
}
}
}
} catch (Exception e) { } catch (Exception e) {
return UplinkResponseMsg.newBuilder().setSuccess(false).setErrorMsg(e.getMessage()).build(); return UplinkResponseMsg.newBuilder().setSuccess(false).setErrorMsg(e.getMessage()).build();
} }

2
common/data/src/main/java/org/thingsboard/server/common/data/edge/EdgeQueueEntityType.java
View File

@ -16,5 +16,5 @@
package org.thingsboard.server.common.data.edge; package org.thingsboard.server.common.data.edge;
public enum EdgeQueueEntityType { public enum EdgeQueueEntityType {
DASHBOARD, ASSET, DEVICE, ENTITY_VIEW, ALARM, RULE_CHAIN, RULE_CHAIN_METADATA DASHBOARD, ASSET, DEVICE, ENTITY_VIEW, ALARM, RULE_CHAIN, RULE_CHAIN_METADATA, EDGE
} }

44
common/edge-api/src/main/java/org/thingsboard/edge/rpc/EdgeGrpcClient.java
View File

@ -24,21 +24,16 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.thingsboard.edge.exception.EdgeConnectionException; import org.thingsboard.edge.exception.EdgeConnectionException;
import org.thingsboard.server.gen.edge.AssetUpdateMsg;
import org.thingsboard.server.gen.edge.ConnectRequestMsg; import org.thingsboard.server.gen.edge.ConnectRequestMsg;
import org.thingsboard.server.gen.edge.ConnectResponseCode; import org.thingsboard.server.gen.edge.ConnectResponseCode;
import org.thingsboard.server.gen.edge.ConnectResponseMsg; import org.thingsboard.server.gen.edge.ConnectResponseMsg;
import org.thingsboard.server.gen.edge.DashboardUpdateMsg;
import org.thingsboard.server.gen.edge.DeviceUpdateMsg;
import org.thingsboard.server.gen.edge.DownlinkMsg; import org.thingsboard.server.gen.edge.DownlinkMsg;
import org.thingsboard.server.gen.edge.EdgeConfiguration; import org.thingsboard.server.gen.edge.EdgeConfiguration;
import org.thingsboard.server.gen.edge.EdgeRpcServiceGrpc; import org.thingsboard.server.gen.edge.EdgeRpcServiceGrpc;
import org.thingsboard.server.gen.edge.EntityViewUpdateMsg; import org.thingsboard.server.gen.edge.EntityUpdateMsg;
import org.thingsboard.server.gen.edge.RequestMsg; import org.thingsboard.server.gen.edge.RequestMsg;
import org.thingsboard.server.gen.edge.RequestMsgType; import org.thingsboard.server.gen.edge.RequestMsgType;
import org.thingsboard.server.gen.edge.ResponseMsg; import org.thingsboard.server.gen.edge.ResponseMsg;
import org.thingsboard.server.gen.edge.RuleChainMetadataUpdateMsg;
import org.thingsboard.server.gen.edge.RuleChainUpdateMsg;
import org.thingsboard.server.gen.edge.UplinkMsg; import org.thingsboard.server.gen.edge.UplinkMsg;
import org.thingsboard.server.gen.edge.UplinkResponseMsg; import org.thingsboard.server.gen.edge.UplinkResponseMsg;
@ -72,12 +67,7 @@ public class EdgeGrpcClient implements EdgeRpcClient {
String edgeSecret, String edgeSecret,
Consumer<UplinkResponseMsg> onUplinkResponse, Consumer<UplinkResponseMsg> onUplinkResponse,
Consumer<EdgeConfiguration> onEdgeUpdate, Consumer<EdgeConfiguration> onEdgeUpdate,
Consumer<DeviceUpdateMsg> onDeviceUpdate, Consumer<EntityUpdateMsg> onEntityUpdate,
Consumer<AssetUpdateMsg> onAssetUpdate,
Consumer<EntityViewUpdateMsg> onEntityViewUpdate,
Consumer<RuleChainUpdateMsg> onRuleChainUpdate,
Consumer<RuleChainMetadataUpdateMsg> onRuleChainMetadataUpdate,
Consumer<DashboardUpdateMsg> onDashboardUpdate,
Consumer<DownlinkMsg> onDownlink, Consumer<DownlinkMsg> onDownlink,
Consumer<Exception> onError) { Consumer<Exception> onError) {
NettyChannelBuilder builder = NettyChannelBuilder.forAddress(rpcHost, rpcPort).usePlaintext(); NettyChannelBuilder builder = NettyChannelBuilder.forAddress(rpcHost, rpcPort).usePlaintext();
@ -92,7 +82,7 @@ public class EdgeGrpcClient implements EdgeRpcClient {
channel = builder.build(); channel = builder.build();
EdgeRpcServiceGrpc.EdgeRpcServiceStub stub = EdgeRpcServiceGrpc.newStub(channel); EdgeRpcServiceGrpc.EdgeRpcServiceStub stub = EdgeRpcServiceGrpc.newStub(channel);
log.info("[{}] Sending a connect request to the TB!", edgeKey); log.info("[{}] Sending a connect request to the TB!", edgeKey);
this.inputStream = stub.handleMsgs(initOutputStream(edgeKey, onUplinkResponse, onEdgeUpdate, onDeviceUpdate, onAssetUpdate, onEntityViewUpdate, onRuleChainUpdate, onRuleChainMetadataUpdate, onDashboardUpdate, onDownlink, onError)); this.inputStream = stub.handleMsgs(initOutputStream(edgeKey, onUplinkResponse, onEdgeUpdate, onEntityUpdate, onDownlink, onError));
this.inputStream.onNext(RequestMsg.newBuilder() this.inputStream.onNext(RequestMsg.newBuilder()
.setMsgType(RequestMsgType.CONNECT_RPC_MESSAGE) .setMsgType(RequestMsgType.CONNECT_RPC_MESSAGE)
.setConnectRequestMsg(ConnectRequestMsg.newBuilder().setEdgeRoutingKey(edgeKey).setEdgeSecret(edgeSecret).build()) .setConnectRequestMsg(ConnectRequestMsg.newBuilder().setEdgeRoutingKey(edgeKey).setEdgeSecret(edgeSecret).build())
@ -118,12 +108,7 @@ public class EdgeGrpcClient implements EdgeRpcClient {
private StreamObserver<ResponseMsg> initOutputStream(String edgeKey, private StreamObserver<ResponseMsg> initOutputStream(String edgeKey,
Consumer<UplinkResponseMsg> onUplinkResponse, Consumer<UplinkResponseMsg> onUplinkResponse,
Consumer<EdgeConfiguration> onEdgeUpdate, Consumer<EdgeConfiguration> onEdgeUpdate,
Consumer<DeviceUpdateMsg> onDeviceUpdate, Consumer<EntityUpdateMsg> onEntityUpdate,
Consumer<AssetUpdateMsg> onAssetUpdate,
Consumer<EntityViewUpdateMsg> onEntityViewUpdate,
Consumer<RuleChainUpdateMsg> onRuleChainUpdate,
Consumer<RuleChainMetadataUpdateMsg> onRuleChainMetadataUpdate,
Consumer<DashboardUpdateMsg> onDashboardUpdate,
Consumer<DownlinkMsg> onDownlink, Consumer<DownlinkMsg> onDownlink,
Consumer<Exception> onError) { Consumer<Exception> onError) {
return new StreamObserver<ResponseMsg>() { return new StreamObserver<ResponseMsg>() {
@ -141,24 +126,9 @@ public class EdgeGrpcClient implements EdgeRpcClient {
} else if (responseMsg.hasUplinkResponseMsg()) { } else if (responseMsg.hasUplinkResponseMsg()) {
log.debug("[{}] Uplink response message received {}", edgeKey, responseMsg.getUplinkResponseMsg()); log.debug("[{}] Uplink response message received {}", edgeKey, responseMsg.getUplinkResponseMsg());
onUplinkResponse.accept(responseMsg.getUplinkResponseMsg()); onUplinkResponse.accept(responseMsg.getUplinkResponseMsg());
} else if (responseMsg.hasDeviceUpdateMsg()) { } else if (responseMsg.hasEntityUpdateMsg()) {
log.debug("[{}] Device update message received {}", edgeKey, responseMsg.getDeviceUpdateMsg()); log.debug("[{}] Entity update message received {}", edgeKey, responseMsg.getEntityUpdateMsg());
onDeviceUpdate.accept(responseMsg.getDeviceUpdateMsg()); onEntityUpdate.accept(responseMsg.getEntityUpdateMsg());
} else if (responseMsg.hasAssetUpdateMsg()) {
log.debug("[{}] Asset update message received {}", edgeKey, responseMsg.getAssetUpdateMsg());
onAssetUpdate.accept(responseMsg.getAssetUpdateMsg());
} else if (responseMsg.hasEntityViewUpdateMsg()) {
log.debug("[{}] EntityView update message received {}", edgeKey, responseMsg.getEntityViewUpdateMsg());
onEntityViewUpdate.accept(responseMsg.getEntityViewUpdateMsg());
} else if (responseMsg.hasRuleChainUpdateMsg()) {
log.debug("[{}] Rule Chain udpate message received {}", edgeKey, responseMsg.getRuleChainUpdateMsg());
onRuleChainUpdate.accept(responseMsg.getRuleChainUpdateMsg());
} else if (responseMsg.hasRuleChainMetadataUpdateMsg()) {
log.debug("[{}] Rule Chain Metadata udpate message received {}", edgeKey, responseMsg.getRuleChainMetadataUpdateMsg());
onRuleChainMetadataUpdate.accept(responseMsg.getRuleChainMetadataUpdateMsg());
} else if (responseMsg.hasDashboardUpdateMsg()) {
log.debug("[{}] Dashboard message received {}", edgeKey, responseMsg.getDashboardUpdateMsg());
onDashboardUpdate.accept(responseMsg.getDashboardUpdateMsg());
} else if (responseMsg.hasDownlinkMsg()) { } else if (responseMsg.hasDownlinkMsg()) {
log.debug("[{}] Downlink message received for rule chain {}", edgeKey, responseMsg.getDownlinkMsg()); log.debug("[{}] Downlink message received for rule chain {}", edgeKey, responseMsg.getDownlinkMsg());
onDownlink.accept(responseMsg.getDownlinkMsg()); onDownlink.accept(responseMsg.getDownlinkMsg());

14
common/edge-api/src/main/java/org/thingsboard/edge/rpc/EdgeRpcClient.java
View File

@ -15,14 +15,9 @@
*/ */
package org.thingsboard.edge.rpc; package org.thingsboard.edge.rpc;
import org.thingsboard.server.gen.edge.AssetUpdateMsg;
import org.thingsboard.server.gen.edge.DashboardUpdateMsg;
import org.thingsboard.server.gen.edge.DeviceUpdateMsg;
import org.thingsboard.server.gen.edge.DownlinkMsg; import org.thingsboard.server.gen.edge.DownlinkMsg;
import org.thingsboard.server.gen.edge.EdgeConfiguration; import org.thingsboard.server.gen.edge.EdgeConfiguration;
import org.thingsboard.server.gen.edge.EntityViewUpdateMsg; import org.thingsboard.server.gen.edge.EntityUpdateMsg;
import org.thingsboard.server.gen.edge.RuleChainMetadataUpdateMsg;
import org.thingsboard.server.gen.edge.RuleChainUpdateMsg;
import org.thingsboard.server.gen.edge.UplinkMsg; import org.thingsboard.server.gen.edge.UplinkMsg;
import org.thingsboard.server.gen.edge.UplinkResponseMsg; import org.thingsboard.server.gen.edge.UplinkResponseMsg;
@ -34,12 +29,7 @@ public interface EdgeRpcClient {
String integrationSecret, String integrationSecret,
Consumer<UplinkResponseMsg> onUplinkResponse, Consumer<UplinkResponseMsg> onUplinkResponse,
Consumer<EdgeConfiguration> onEdgeUpdate, Consumer<EdgeConfiguration> onEdgeUpdate,
Consumer<DeviceUpdateMsg> onDeviceUpdate, Consumer<EntityUpdateMsg> onEntityUpdate,
Consumer<AssetUpdateMsg> onAssetUpdate,
Consumer<EntityViewUpdateMsg> onEntityViewUpdate,
Consumer<RuleChainUpdateMsg> onRuleChainUpdate,
Consumer<RuleChainMetadataUpdateMsg> onRuleChainMetadataUpdate,
Consumer<DashboardUpdateMsg> onDashboardUpdate,
Consumer<DownlinkMsg> onDownlink, Consumer<DownlinkMsg> onDownlink,
Consumer<Exception> onError); Consumer<Exception> onError);

45
common/edge-api/src/main/proto/edge.proto
View File

@ -34,26 +34,29 @@ service EdgeRpcService {
message RequestMsg { message RequestMsg {
RequestMsgType msgType = 1; RequestMsgType msgType = 1;
ConnectRequestMsg connectRequestMsg = 2; ConnectRequestMsg connectRequestMsg = 2;
DeviceUpdateMsg deviceUpdateMsg = 3; UplinkMsg uplinkMsg = 3;
UplinkMsg uplinkMsg = 4;
} }
message ResponseMsg { message ResponseMsg {
ConnectResponseMsg connectResponseMsg = 1; ConnectResponseMsg connectResponseMsg = 1;
UplinkResponseMsg uplinkResponseMsg = 2; UplinkResponseMsg uplinkResponseMsg = 2;
DeviceUpdateMsg deviceUpdateMsg = 3; EntityUpdateMsg entityUpdateMsg = 3;
RuleChainUpdateMsg ruleChainUpdateMsg = 4; DownlinkMsg downlinkMsg = 4;
RuleChainMetadataUpdateMsg ruleChainMetadataUpdateMsg = 5; }
DashboardUpdateMsg dashboardUpdateMsg = 6;
AssetUpdateMsg assetUpdateMsg = 7; message EntityUpdateMsg {
EntityViewUpdateMsg entityViewUpdateMsg = 8; DeviceUpdateMsg deviceUpdateMsg = 1;
DownlinkMsg downlinkMsg = 9; RuleChainUpdateMsg ruleChainUpdateMsg = 2;
RuleChainMetadataUpdateMsg ruleChainMetadataUpdateMsg = 3;
DashboardUpdateMsg dashboardUpdateMsg = 4;
AssetUpdateMsg assetUpdateMsg = 5;
EntityViewUpdateMsg entityViewUpdateMsg = 6;
AlarmUpdateMsg alarmUpdateMsg = 7;
} }
enum RequestMsgType { enum RequestMsgType {
CONNECT_RPC_MESSAGE = 0; CONNECT_RPC_MESSAGE = 0;
UPLINK_RPC_MESSAGE = 1; UPLINK_RPC_MESSAGE = 1;
DEVICE_UPDATE_RPC_MESSAGE = 2;
} }
message ConnectRequestMsg { message ConnectRequestMsg {
@ -85,7 +88,9 @@ enum UpdateMsgType {
ENTITY_CREATED_RPC_MESSAGE = 0; ENTITY_CREATED_RPC_MESSAGE = 0;
ENTITY_UPDATED_RPC_MESSAGE = 1; ENTITY_UPDATED_RPC_MESSAGE = 1;
ENTITY_DELETED_RPC_MESSAGE = 2; ENTITY_DELETED_RPC_MESSAGE = 2;
RULE_CHAIN_CUSTOM_MESSAGE = 3; ALARM_ACK_RPC_MESSAGE = 3;
ALARM_CLEARK_RPC_MESSAGE = 4;
RULE_CHAIN_CUSTOM_MESSAGE = 5;
} }
message EntityDataProto { message EntityDataProto {
@ -166,6 +171,22 @@ message EntityViewUpdateMsg {
EntityType relatedEntityType = 6; EntityType relatedEntityType = 6;
} }
message AlarmUpdateMsg {
UpdateMsgType msgType = 1;
string name = 2;
string type = 3;
string originatorType = 4;
string originatorName = 5;
string severity = 6;
string status = 7;
int64 startTs = 8;
int64 endTs = 9;
int64 ackTs = 10;
int64 clearTs = 11;
string details = 12;
bool propagate = 13;
}
enum EntityType { enum EntityType {
DEVICE = 0; DEVICE = 0;
ASSET = 1; ASSET = 1;
@ -178,6 +199,8 @@ enum EntityType {
message UplinkMsg { message UplinkMsg {
int32 uplinkMsgId = 1; int32 uplinkMsgId = 1;
repeated EntityDataProto entityData = 2; repeated EntityDataProto entityData = 2;
repeated DeviceUpdateMsg deviceUpdateMsg = 3;
repeated AlarmUpdateMsg alarmUpdatemsg = 4;
} }
message UplinkResponseMsg { message UplinkResponseMsg {

102
dao/src/main/java/org/thingsboard/server/dao/edge/BaseEdgeService.java
View File

@ -37,6 +37,7 @@ import org.thingsboard.server.common.data.EntityView;
import org.thingsboard.server.common.data.Event; import org.thingsboard.server.common.data.Event;
import org.thingsboard.server.common.data.ShortEdgeInfo; import org.thingsboard.server.common.data.ShortEdgeInfo;
import org.thingsboard.server.common.data.Tenant; import org.thingsboard.server.common.data.Tenant;
import org.thingsboard.server.common.data.alarm.Alarm;
import org.thingsboard.server.common.data.asset.Asset; import org.thingsboard.server.common.data.asset.Asset;
import org.thingsboard.server.common.data.edge.Edge; import org.thingsboard.server.common.data.edge.Edge;
import org.thingsboard.server.common.data.edge.EdgeQueueEntityType; import org.thingsboard.server.common.data.edge.EdgeQueueEntityType;
@ -151,7 +152,6 @@ public class BaseEdgeService extends AbstractEntityService implements EdgeServic
} }
} }
@Override @Override
public Edge findEdgeById(TenantId tenantId, EdgeId edgeId) { public Edge findEdgeById(TenantId tenantId, EdgeId edgeId) {
log.trace("Executing findEdgeById [{}]", edgeId); log.trace("Executing findEdgeById [{}]", edgeId);
@ -349,6 +349,9 @@ public class BaseEdgeService extends AbstractEntityService implements EdgeServic
} else { } else {
try { try {
switch (tbMsg.getOriginator().getEntityType()) { switch (tbMsg.getOriginator().getEntityType()) {
case EDGE:
processEdge(tenantId, tbMsg, callback);
break;
case ASSET: case ASSET:
processAsset(tenantId, tbMsg, callback); processAsset(tenantId, tbMsg, callback);
break; break;
@ -364,6 +367,9 @@ public class BaseEdgeService extends AbstractEntityService implements EdgeServic
case ENTITY_VIEW: case ENTITY_VIEW:
processEntityView(tenantId, tbMsg, callback); processEntityView(tenantId, tbMsg, callback);
break; break;
case ALARM:
processAlarm(tenantId, tbMsg, callback);
break;
default: default:
log.debug("Entity type [{}] is not designed to be pushed to edge", tbMsg.getOriginator().getEntityType()); log.debug("Entity type [{}] is not designed to be pushed to edge", tbMsg.getOriginator().getEntityType());
} }
@ -374,26 +380,9 @@ public class BaseEdgeService extends AbstractEntityService implements EdgeServic
} }
private void processCustomTbMsg(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback) { private void processCustomTbMsg(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback) {
EdgeId edgeId = null; EdgeId edgeId = getEdgeIdByOriginatorId(tenantId, tbMsg.getOriginator());
EdgeQueueEntityType edgeQueueEntityType = null; EdgeQueueEntityType edgeQueueEntityType = getEdgeQueueTypeByEntityType(tbMsg.getOriginator().getEntityType());
switch (tbMsg.getOriginator().getEntityType()) { if (edgeId != null && edgeQueueEntityType != null) {
case DEVICE:
edgeQueueEntityType = EdgeQueueEntityType.DEVICE;
Device device = deviceService.findDeviceById(tenantId, new DeviceId(tbMsg.getOriginator().getId()));
edgeId = device.getEdgeId();
break;
case ASSET:
edgeQueueEntityType = EdgeQueueEntityType.ASSET;
Asset asset = assetService.findAssetById(tenantId, new AssetId(tbMsg.getOriginator().getId()));
edgeId = asset.getEdgeId();
break;
case ENTITY_VIEW:
edgeQueueEntityType = EdgeQueueEntityType.ENTITY_VIEW;
EntityView entityView = entityViewService.findEntityViewById(tenantId, new EntityViewId(tbMsg.getOriginator().getId()));
edgeId = entityView.getEdgeId();
break;
}
if (edgeId != null) {
try { try {
saveEventToEdgeQueue(tenantId, edgeId, edgeQueueEntityType, tbMsg.getType(), mapper.writeValueAsString(tbMsg), callback); saveEventToEdgeQueue(tenantId, edgeId, edgeQueueEntityType, tbMsg.getType(), mapper.writeValueAsString(tbMsg), callback);
} catch (IOException e) { } catch (IOException e) {
@ -402,6 +391,37 @@ public class BaseEdgeService extends AbstractEntityService implements EdgeServic
} }
} }
private EdgeQueueEntityType getEdgeQueueTypeByEntityType(EntityType entityType) {
switch (entityType) {
case DEVICE:
return EdgeQueueEntityType.DEVICE;
case ASSET:
return EdgeQueueEntityType.ASSET;
case ENTITY_VIEW:
return EdgeQueueEntityType.ENTITY_VIEW;
default:
log.info("Unsupported entity type: [{}]", entityType);
return null;
}
}
private EdgeId getEdgeIdByOriginatorId(TenantId tenantId, EntityId originatorId) {
switch (originatorId.getEntityType()) {
case DEVICE:
Device device = deviceService.findDeviceById(tenantId, new DeviceId(originatorId.getId()));
return device.getEdgeId();
case ASSET:
Asset asset = assetService.findAssetById(tenantId, new AssetId(originatorId.getId()));
return asset.getEdgeId();
case ENTITY_VIEW:
EntityView entityView = entityViewService.findEntityViewById(tenantId, new EntityViewId(originatorId.getId()));
return entityView.getEdgeId();
default:
log.info("Unsupported entity type: [{}]", originatorId.getEntityType());
return null;
}
}
private void processDevice(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback) throws IOException { private void processDevice(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback) throws IOException {
switch (tbMsg.getType()) { switch (tbMsg.getType()) {
case DataConstants.ENTITY_ASSIGNED_TO_EDGE: case DataConstants.ENTITY_ASSIGNED_TO_EDGE:
@ -421,6 +441,21 @@ public class BaseEdgeService extends AbstractEntityService implements EdgeServic
} }
} }
private void processEdge(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback) throws IOException {
switch (tbMsg.getType()) {
case DataConstants.ENTITY_DELETED:
case DataConstants.ENTITY_CREATED:
case DataConstants.ENTITY_UPDATED:
Edge edge = mapper.readValue(tbMsg.getData(), Edge.class);
if (edge != null) {
pushEventToEdge(tenantId, edge.getId(), EdgeQueueEntityType.EDGE, tbMsg, callback);
}
break;
default:
log.warn("Unsupported msgType [{}], tbMsg [{}]", tbMsg.getType(), tbMsg);
}
}
private void processAsset(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback) throws IOException { private void processAsset(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback) throws IOException {
switch (tbMsg.getType()) { switch (tbMsg.getType()) {
case DataConstants.ENTITY_ASSIGNED_TO_EDGE: case DataConstants.ENTITY_ASSIGNED_TO_EDGE:
@ -459,6 +494,25 @@ public class BaseEdgeService extends AbstractEntityService implements EdgeServic
} }
} }
private void processAlarm(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback) throws IOException {
switch (tbMsg.getType()) {
case DataConstants.ENTITY_DELETED:
case DataConstants.ENTITY_CREATED:
case DataConstants.ENTITY_UPDATED:
case DataConstants.ALARM_ACK:
case DataConstants.ALARM_CLEAR:
Alarm alarm = mapper.readValue(tbMsg.getData(), Alarm.class);
EdgeId edgeId = getEdgeIdByOriginatorId(tenantId, alarm.getOriginator());
EdgeQueueEntityType edgeQueueEntityType = getEdgeQueueTypeByEntityType(alarm.getOriginator().getEntityType());
if (edgeId != null && edgeQueueEntityType != null) {
pushEventToEdge(tenantId, edgeId, EdgeQueueEntityType.ALARM, tbMsg, callback);
}
break;
default:
log.warn("Unsupported msgType [{}], tbMsg [{}]", tbMsg.getType(), tbMsg);
}
}
private void processDashboard(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback) throws IOException { private void processDashboard(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback) throws IOException {
processAssignedEntity(tenantId, tbMsg, EdgeQueueEntityType.DASHBOARD, callback); processAssignedEntity(tenantId, tbMsg, EdgeQueueEntityType.DASHBOARD, callback);
} }
@ -562,8 +616,8 @@ public class BaseEdgeService extends AbstractEntityService implements EdgeServic
@Override @Override
public Edge setRootRuleChain(TenantId tenantId, Edge edge, RuleChainId ruleChainId) throws IOException { public Edge setRootRuleChain(TenantId tenantId, Edge edge, RuleChainId ruleChainId) throws IOException {
edge.setRootRuleChainId(ruleChainId); edge.setRootRuleChainId(ruleChainId);
Edge saveEdge = saveEdge(edge); Edge savedEdge = saveEdge(edge);
ruleChainService.updateEdgeRuleChains(tenantId, saveEdge.getId()); ruleChainService.updateEdgeRuleChains(tenantId, savedEdge.getId());
RuleChain ruleChain = ruleChainService.findRuleChainById(tenantId, ruleChainId); RuleChain ruleChain = ruleChainService.findRuleChainById(tenantId, ruleChainId);
saveEventToEdgeQueue(tenantId, edge.getId(), EdgeQueueEntityType.RULE_CHAIN, DataConstants.ENTITY_UPDATED, mapper.writeValueAsString(ruleChain), new FutureCallback<Void>() { saveEventToEdgeQueue(tenantId, edge.getId(), EdgeQueueEntityType.RULE_CHAIN, DataConstants.ENTITY_UPDATED, mapper.writeValueAsString(ruleChain), new FutureCallback<Void>() {
@Override @Override
@ -576,7 +630,7 @@ public class BaseEdgeService extends AbstractEntityService implements EdgeServic
log.debug("Failure during event save", t); log.debug("Failure during event save", t);
} }
}); });
return saveEdge; return savedEdge;
} }
private DataValidator<Edge> edgeValidator = private DataValidator<Edge> edgeValidator =