Merge with origin develop/2.6-edge

application/src/main/java/org/thingsboard/server/controller/EdgeController.java

@@ -92,10 +92,10 @@ public class EdgeController extends BaseController {
             edge.setTenantId(tenantId);
             boolean created = edge.getId() == null;
 
-            RuleChain defaultRootEdgeRuleChain = null;
+            RuleChain edgeTemplateRootRuleChain = null;
             if (created) {
-                defaultRootEdgeRuleChain = ruleChainService.getDefaultRootEdgeRuleChain(tenantId);
+                edgeTemplateRootRuleChain = ruleChainService.getEdgeTemplateRootRuleChain(tenantId);
-                if (defaultRootEdgeRuleChain == null) {
+                if (edgeTemplateRootRuleChain == null) {
                     throw new DataValidationException("Root edge rule chain is not available!");
                 }
             }
@@ -108,8 +108,8 @@ public class EdgeController extends BaseController {
             Edge savedEdge = checkNotNull(edgeService.saveEdge(edge));
 
             if (created) {
-                ruleChainService.assignRuleChainToEdge(tenantId, defaultRootEdgeRuleChain.getId(), savedEdge.getId());
+                ruleChainService.assignRuleChainToEdge(tenantId, edgeTemplateRootRuleChain.getId(), savedEdge.getId());
-                edgeNotificationService.setEdgeRootRuleChain(tenantId, savedEdge, defaultRootEdgeRuleChain.getId());
+                edgeNotificationService.setEdgeRootRuleChain(tenantId, savedEdge, edgeTemplateRootRuleChain.getId());
                 edgeService.assignDefaultRuleChainsToEdge(tenantId, savedEdge.getId());
             }
 
@@ -389,10 +389,12 @@ public class EdgeController extends BaseController {
         checkNotNull(query.getEdgeTypes());
         checkEntityId(query.getParameters().getEntityId(), Operation.READ);
         try {
-            List<Edge> edges = checkNotNull(edgeService.findEdgesByQuery(getCurrentUser().getTenantId(), query).get());
+            SecurityUser user = getCurrentUser();
+            TenantId tenantId = user.getTenantId();
+            List<Edge> edges = checkNotNull(edgeService.findEdgesByQuery(tenantId, query).get());
             edges = edges.stream().filter(edge -> {
                 try {
-                    accessControlService.checkPermission(getCurrentUser(), Resource.EDGE, Operation.READ, edge.getId(), edge);
+                    accessControlService.checkPermission(user, Resource.EDGE, Operation.READ, edge.getId(), edge);
                     return true;
                 } catch (ThingsboardException e) {
                     return false;
@@ -419,14 +421,18 @@ public class EdgeController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('TENANT_ADMIN')")
-    @RequestMapping(value = "/edge/sync", method = RequestMethod.POST)
+    @RequestMapping(value = "/edge/sync/{edgeId}", method = RequestMethod.POST)
-    public void syncEdge(@RequestBody EdgeId edgeId) throws ThingsboardException {
+    public void syncEdge(@PathVariable("edgeId") String strEdgeId) throws ThingsboardException {
+        checkParameter("edgeId", strEdgeId);
         try {
-            edgeId = checkNotNull(edgeId);
             if (isEdgesEnabled()) {
-                EdgeGrpcSession session = edgeGrpcService.getEdgeGrpcSessionById(edgeId);
+                EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+                edgeId = checkNotNull(edgeId);
+                SecurityUser user = getCurrentUser();
+                TenantId tenantId = user.getTenantId();
+                EdgeGrpcSession session = edgeGrpcService.getEdgeGrpcSessionById(tenantId, edgeId);
                 Edge edge = session.getEdge();
-                syncEdgeService.sync(edge);
+                syncEdgeService.sync(tenantId, edge);
             } else {
                 throw new ThingsboardException("Edges support disabled", ThingsboardErrorCode.GENERAL);
             }
@@ -455,4 +461,19 @@ public class EdgeController extends BaseController {
             throw new ThingsboardException(e, ThingsboardErrorCode.SUBSCRIPTION_VIOLATION);
         }
     }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/missingToRelatedRuleChains/{edgeId}", method = RequestMethod.GET)
+    @ResponseBody
+    public String findMissingToRelatedRuleChains(@PathVariable("edgeId") String strEdgeId) throws ThingsboardException {
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            edgeId = checkNotNull(edgeId);
+            SecurityUser user = getCurrentUser();
+            TenantId tenantId = user.getTenantId();
+            return edgeService.findMissingToRelatedRuleChains(tenantId, edgeId);
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
 }

application/src/main/java/org/thingsboard/server/controller/RuleChainController.java

@@ -495,14 +495,14 @@ public class RuleChainController extends BaseController {
     }
 
     @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
-    @RequestMapping(value = "/ruleChain/{ruleChainId}/defaultRootEdge", method = RequestMethod.POST)
+    @RequestMapping(value = "/ruleChain/{ruleChainId}/edgeTemplateRoot", method = RequestMethod.POST)
     @ResponseBody
-    public RuleChain setDefaultRootEdgeRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
+    public RuleChain setEdgeTemplateRootRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
         checkParameter(RULE_CHAIN_ID, strRuleChainId);
         try {
             RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
             RuleChain ruleChain = checkRuleChain(ruleChainId, Operation.WRITE);
-            ruleChainService.setDefaultRootEdgeRuleChain(getTenantId(), ruleChainId);
+            ruleChainService.setEdgeTemplateRootRuleChain(getTenantId(), ruleChainId);
             return ruleChain;
         } catch (Exception e) {
             logEntityAction(emptyId(EntityType.RULE_CHAIN),
@@ -514,14 +514,14 @@ public class RuleChainController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('TENANT_ADMIN')")
-    @RequestMapping(value = "/ruleChain/{ruleChainId}/defaultEdge", method = RequestMethod.POST)
+    @RequestMapping(value = "/ruleChain/{ruleChainId}/autoAssignToEdge", method = RequestMethod.POST)
     @ResponseBody
-    public RuleChain addDefaultEdgeRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
+    public RuleChain setAutoAssignToEdgeRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
         checkParameter(RULE_CHAIN_ID, strRuleChainId);
         try {
             RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
             RuleChain ruleChain = checkRuleChain(ruleChainId, Operation.WRITE);
-            ruleChainService.addDefaultEdgeRuleChain(getTenantId(), ruleChainId);
+            ruleChainService.setAutoAssignToEdgeRuleChain(getTenantId(), ruleChainId);
             return ruleChain;
         } catch (Exception e) {
             logEntityAction(emptyId(EntityType.RULE_CHAIN),
@@ -533,14 +533,14 @@ public class RuleChainController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('TENANT_ADMIN')")
-    @RequestMapping(value = "/ruleChain/{ruleChainId}/defaultEdge", method = RequestMethod.DELETE)
+    @RequestMapping(value = "/ruleChain/{ruleChainId}/autoAssignToEdge", method = RequestMethod.DELETE)
     @ResponseBody
-    public RuleChain removeDefaultEdgeRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
+    public RuleChain unsetAutoAssignToEdgeRuleChain(@PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
         checkParameter(RULE_CHAIN_ID, strRuleChainId);
         try {
             RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
             RuleChain ruleChain = checkRuleChain(ruleChainId, Operation.WRITE);
-            ruleChainService.removeDefaultEdgeRuleChain(getTenantId(), ruleChainId);
+            ruleChainService.unsetAutoAssignToEdgeRuleChain(getTenantId(), ruleChainId);
             return ruleChain;
         } catch (Exception e) {
             logEntityAction(emptyId(EntityType.RULE_CHAIN),
@@ -552,12 +552,12 @@ public class RuleChainController extends BaseController {
     }
 
     @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
-    @RequestMapping(value = "/ruleChain/defaultEdgeRuleChains", method = RequestMethod.GET)
+    @RequestMapping(value = "/ruleChain/autoAssignToEdgeRuleChains", method = RequestMethod.GET)
     @ResponseBody
-    public List<RuleChain> getDefaultEdgeRuleChains() throws ThingsboardException {
+    public List<RuleChain> getAutoAssignToEdgeRuleChains() throws ThingsboardException {
         try {
             TenantId tenantId = getCurrentUser().getTenantId();
-            return checkNotNull(ruleChainService.findDefaultEdgeRuleChainsByTenantId(tenantId)).get();
+            return checkNotNull(ruleChainService.findAutoAssignToEdgeRuleChainsByTenantId(tenantId)).get();
         } catch (Exception e) {
             throw handleException(e);
         }

application/src/main/java/org/thingsboard/server/service/edge/DefaultEdgeNotificationService.java

@@ -113,11 +113,6 @@ public class DefaultEdgeNotificationService implements EdgeNotificationService {
         }
     }
 
-    @Override
-    public TimePageData<EdgeEvent> findEdgeEvents(TenantId tenantId, EdgeId edgeId, TimePageLink pageLink) {
-        return edgeEventService.findEdgeEvents(tenantId, edgeId, pageLink, true);
-    }
-
     @Override
     public Edge setEdgeRootRuleChain(TenantId tenantId, Edge edge, RuleChainId ruleChainId) throws IOException {
         edge.setRootRuleChainId(ruleChainId);

application/src/main/java/org/thingsboard/server/service/edge/EdgeContextComponent.java

@@ -28,6 +28,7 @@ import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.dao.dashboard.DashboardService;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
 import org.thingsboard.server.dao.device.DeviceService;
+import org.thingsboard.server.dao.edge.EdgeEventService;
 import org.thingsboard.server.dao.edge.EdgeService;
 import org.thingsboard.server.dao.entityview.EntityViewService;
 import org.thingsboard.server.dao.relation.RelationService;
@@ -74,7 +75,7 @@ public class EdgeContextComponent {
 
     @Lazy
     @Autowired
-    private EdgeNotificationService edgeNotificationService;
+    private EdgeEventService edgeEventService;
 
     @Lazy
     @Autowired

application/src/main/java/org/thingsboard/server/service/edge/EdgeNotificationService.java

@@ -15,14 +15,9 @@
  */
 package org.thingsboard.server.service.edge;
 
-import org.thingsboard.server.common.data.Event;
 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.RuleChainId;
 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.common.msg.queue.TbCallback;
 import org.thingsboard.server.gen.transport.TransportProtos;
 
@@ -30,8 +25,6 @@ import java.io.IOException;
 
 public interface EdgeNotificationService {
 
-    TimePageData<EdgeEvent> findEdgeEvents(TenantId tenantId, EdgeId edgeId, TimePageLink pageLink);
-
     Edge setEdgeRootRuleChain(TenantId tenantId, Edge edge, RuleChainId ruleChainId) throws IOException;
 
     void pushNotificationToEdge(TransportProtos.EdgeNotificationMsgProto edgeNotificationMsg, TbCallback callback);

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

@@ -28,6 +28,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.stereotype.Service;
 import org.thingsboard.common.util.ThingsBoardThreadFactory;
 import org.thingsboard.server.common.data.DataConstants;
+import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -186,11 +187,12 @@ public class EdgeGrpcService extends EdgeRpcServiceGrpc.EdgeRpcServiceImplBase i
         scheduleEdgeEventsCheck(edgeGrpcSession);
     }
 
-    public EdgeGrpcSession getEdgeGrpcSessionById(EdgeId edgeId) {
+    public EdgeGrpcSession getEdgeGrpcSessionById(TenantId tenantId, EdgeId edgeId) {
         EdgeGrpcSession session = sessions.get(edgeId);
         if (session != null && session.isConnected()) {
             return session;
         } else {
+            log.error("[{}] Edge is not connected [{}]", tenantId, edgeId);
             throw new RuntimeException("Edge is not connected");
         }
     }

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

@@ -160,11 +160,12 @@ public final class EdgeGrpcSession implements Closeable {
                             .build());
                     if (ConnectResponseCode.ACCEPTED != responseMsg.getResponseCode()) {
                         outputStream.onError(new RuntimeException(responseMsg.getErrorMsg()));
+                    } else {
+                        connected = true;
                     }
                 }
-                if (!connected && requestMsg.getMsgType().equals(RequestMsgType.SYNC_REQUEST_RPC_MESSAGE)) {
+                if (connected && requestMsg.getMsgType().equals(RequestMsgType.SYNC_REQUEST_RPC_MESSAGE)) {
-                    connected = true;
+                    ctx.getSyncEdgeService().sync(edge.getTenantId(), edge);
-                    ctx.getSyncEdgeService().sync(edge);
                 }
                 if (connected) {
                     if (requestMsg.getMsgType().equals(RequestMsgType.UPLINK_RPC_MESSAGE) && requestMsg.hasUplinkMsg()) {
@@ -266,7 +267,7 @@ public final class EdgeGrpcSession implements Closeable {
             UUID ifOffset = null;
             boolean success = true;
             do {
-                pageData = ctx.getEdgeNotificationService().findEdgeEvents(edge.getTenantId(), edge.getId(), pageLink);
+                pageData = ctx.getEdgeEventService().findEdgeEvents(edge.getTenantId(), edge.getId(), pageLink, true);
                 if (isConnected() && !pageData.getData().isEmpty()) {
                     log.trace("[{}] [{}] event(s) are going to be processed.", this.sessionId, pageData.getData().size());
                     List<DownlinkMsg> downlinkMsgsPack = convertToDownlinkMsgsPack(pageData.getData());
@@ -898,27 +899,27 @@ public final class EdgeGrpcSession implements Closeable {
             }
             if (uplinkMsg.getRuleChainMetadataRequestMsgList() != null && !uplinkMsg.getRuleChainMetadataRequestMsgList().isEmpty()) {
                 for (RuleChainMetadataRequestMsg ruleChainMetadataRequestMsg : uplinkMsg.getRuleChainMetadataRequestMsgList()) {
-                    result.add(ctx.getSyncEdgeService().processRuleChainMetadataRequestMsg(edge, ruleChainMetadataRequestMsg));
+                    result.add(ctx.getSyncEdgeService().processRuleChainMetadataRequestMsg(edge.getTenantId(), edge, ruleChainMetadataRequestMsg));
                 }
             }
             if (uplinkMsg.getAttributesRequestMsgList() != null && !uplinkMsg.getAttributesRequestMsgList().isEmpty()) {
                 for (AttributesRequestMsg attributesRequestMsg : uplinkMsg.getAttributesRequestMsgList()) {
-                    result.add(ctx.getSyncEdgeService().processAttributesRequestMsg(edge, attributesRequestMsg));
+                    result.add(ctx.getSyncEdgeService().processAttributesRequestMsg(edge.getTenantId(), edge, attributesRequestMsg));
                 }
             }
             if (uplinkMsg.getRelationRequestMsgList() != null && !uplinkMsg.getRelationRequestMsgList().isEmpty()) {
                 for (RelationRequestMsg relationRequestMsg : uplinkMsg.getRelationRequestMsgList()) {
-                    result.add(ctx.getSyncEdgeService().processRelationRequestMsg(edge, relationRequestMsg));
+                    result.add(ctx.getSyncEdgeService().processRelationRequestMsg(edge.getTenantId(), edge, relationRequestMsg));
                 }
             }
             if (uplinkMsg.getUserCredentialsRequestMsgList() != null && !uplinkMsg.getUserCredentialsRequestMsgList().isEmpty()) {
                 for (UserCredentialsRequestMsg userCredentialsRequestMsg : uplinkMsg.getUserCredentialsRequestMsgList()) {
-                    result.add(ctx.getSyncEdgeService().processUserCredentialsRequestMsg(edge, userCredentialsRequestMsg));
+                    result.add(ctx.getSyncEdgeService().processUserCredentialsRequestMsg(edge.getTenantId(), edge, userCredentialsRequestMsg));
                 }
             }
             if (uplinkMsg.getDeviceCredentialsRequestMsgList() != null && !uplinkMsg.getDeviceCredentialsRequestMsgList().isEmpty()) {
                 for (DeviceCredentialsRequestMsg deviceCredentialsRequestMsg : uplinkMsg.getDeviceCredentialsRequestMsgList()) {
-                    result.add(ctx.getSyncEdgeService().processDeviceCredentialsRequestMsg(edge, deviceCredentialsRequestMsg));
+                    result.add(ctx.getSyncEdgeService().processDeviceCredentialsRequestMsg(edge.getTenantId(), edge, deviceCredentialsRequestMsg));
                 }
             }
             if (uplinkMsg.getDeviceRpcCallMsgList() != null && !uplinkMsg.getDeviceRpcCallMsgList().isEmpty()) {

application/src/main/java/org/thingsboard/server/service/edge/rpc/init/DefaultSyncEdgeService.java

@@ -33,7 +33,6 @@ import org.springframework.core.io.DefaultResourceLoader;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.AdminSettings;
 import org.thingsboard.server.common.data.DashboardInfo;
-import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.EdgeUtils;
 import org.thingsboard.server.common.data.EntityType;
@@ -146,37 +145,37 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
     private TbClusterService tbClusterService;
 
     @Override
-    public void sync(Edge edge) {
+    public void sync(TenantId tenantId, Edge edge) {
-        log.trace("[{}][{}] Staring edge sync process", edge.getTenantId(), edge.getId());
+        log.trace("[{}][{}] Staring edge sync process", tenantId, edge.getId());
         try {
-            syncWidgetsBundleAndWidgetTypes(edge);
+            syncWidgetsBundleAndWidgetTypes(tenantId, edge);
-            syncAdminSettings(edge);
+            syncAdminSettings(tenantId, edge);
-            syncRuleChains(edge, new TimePageLink(DEFAULT_LIMIT));
+            syncRuleChains(tenantId, edge, new TimePageLink(DEFAULT_LIMIT));
-            syncUsers(edge, new TextPageLink(DEFAULT_LIMIT));
+            syncUsers(tenantId, edge, new TextPageLink(DEFAULT_LIMIT));
-            syncDevices(edge, new TimePageLink(DEFAULT_LIMIT));
+            syncDevices(tenantId, edge, new TimePageLink(DEFAULT_LIMIT));
-            syncAssets(edge, new TimePageLink(DEFAULT_LIMIT));
+            syncAssets(tenantId, edge, new TimePageLink(DEFAULT_LIMIT));
-            syncEntityViews(edge, new TimePageLink(DEFAULT_LIMIT));
+            syncEntityViews(tenantId, edge, new TimePageLink(DEFAULT_LIMIT));
-            syncDashboards(edge, new TimePageLink(DEFAULT_LIMIT));
+            syncDashboards(tenantId, edge, new TimePageLink(DEFAULT_LIMIT));
         } catch (Exception e) {
-            log.error("[{}][{}] Exception during sync process", edge.getTenantId(), edge.getId(), e);
+            log.error("[{}][{}] Exception during sync process", tenantId, edge.getId(), e);
         }
     }
 
-    private void syncRuleChains(Edge edge, TimePageLink pageLink) {
+    private void syncRuleChains(TenantId tenantId, Edge edge, TimePageLink pageLink) {
-        log.trace("[{}] syncRuleChains [{}] [{}]", edge.getTenantId(), edge.getName(), pageLink);
+        log.trace("[{}] syncRuleChains [{}] [{}]", tenantId, edge.getName(), pageLink);
         try {
             ListenableFuture<TimePageData<RuleChain>> future =
-                    ruleChainService.findRuleChainsByTenantIdAndEdgeId(edge.getTenantId(), edge.getId(), pageLink);
+                    ruleChainService.findRuleChainsByTenantIdAndEdgeId(tenantId, edge.getId(), pageLink);
             Futures.addCallback(future, new FutureCallback<TimePageData<RuleChain>>() {
                 @Override
                 public void onSuccess(@Nullable TimePageData<RuleChain> pageData) {
                     if (pageData != null && pageData.getData() != null && !pageData.getData().isEmpty()) {
                         log.trace("[{}] [{}] rule chains(s) are going to be pushed to edge.", edge.getId(), pageData.getData().size());
                         for (RuleChain ruleChain : pageData.getData()) {
-                            saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.RULE_CHAIN, EdgeEventActionType.ADDED, ruleChain.getId(), null);
+                            saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.RULE_CHAIN, EdgeEventActionType.ADDED, ruleChain.getId(), null);
                         }
                         if (pageData.hasNext()) {
-                            syncRuleChains(edge, pageData.getNextPageLink());
+                            syncRuleChains(tenantId, edge, pageData.getNextPageLink());
                         }
                     }
                 }
@@ -191,21 +190,21 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
         }
     }
 
-    private void syncDevices(Edge edge, TimePageLink pageLink) {
+    private void syncDevices(TenantId tenantId, Edge edge, TimePageLink pageLink) {
-        log.trace("[{}] syncDevices [{}]", edge.getTenantId(), edge.getName());
+        log.trace("[{}] syncDevices [{}]", tenantId, edge.getName());
         try {
             ListenableFuture<TimePageData<Device>> future =
-                    deviceService.findDevicesByTenantIdAndEdgeId(edge.getTenantId(), edge.getId(), pageLink);
+                    deviceService.findDevicesByTenantIdAndEdgeId(tenantId, edge.getId(), pageLink);
             Futures.addCallback(future, new FutureCallback<TimePageData<Device>>() {
                 @Override
                 public void onSuccess(@Nullable TimePageData<Device> pageData) {
                     if (pageData != null && pageData.getData() != null && !pageData.getData().isEmpty()) {
                         log.trace("[{}] [{}] device(s) are going to be pushed to edge.", edge.getId(), pageData.getData().size());
                         for (Device device : pageData.getData()) {
-                            saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.DEVICE, EdgeEventActionType.ADDED, device.getId(), null);
+                            saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.DEVICE, EdgeEventActionType.ADDED, device.getId(), null);
                         }
                         if (pageData.hasNext()) {
-                            syncDevices(edge, pageData.getNextPageLink());
+                            syncDevices(tenantId, edge, pageData.getNextPageLink());
                         }
                     }
                 }
@@ -220,20 +219,20 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
         }
     }
 
-    private void syncAssets(Edge edge, TimePageLink pageLink) {
+    private void syncAssets(TenantId tenantId, Edge edge, TimePageLink pageLink) {
-        log.trace("[{}] syncAssets [{}]", edge.getTenantId(), edge.getName());
+        log.trace("[{}] syncAssets [{}]", tenantId, edge.getName());
         try {
-            ListenableFuture<TimePageData<Asset>> future = assetService.findAssetsByTenantIdAndEdgeId(edge.getTenantId(), edge.getId(), pageLink);
+            ListenableFuture<TimePageData<Asset>> future = assetService.findAssetsByTenantIdAndEdgeId(tenantId, edge.getId(), pageLink);
             Futures.addCallback(future, new FutureCallback<TimePageData<Asset>>() {
                 @Override
                 public void onSuccess(@Nullable TimePageData<Asset> pageData) {
                     if (pageData != null && pageData.getData() != null && !pageData.getData().isEmpty()) {
                         log.trace("[{}] [{}] asset(s) are going to be pushed to edge.", edge.getId(), pageData.getData().size());
                         for (Asset asset : pageData.getData()) {
-                            saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.ASSET, EdgeEventActionType.ADDED, asset.getId(), null);
+                            saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.ASSET, EdgeEventActionType.ADDED, asset.getId(), null);
                         }
                         if (pageData.hasNext()) {
-                            syncAssets(edge, pageData.getNextPageLink());
+                            syncAssets(tenantId, edge, pageData.getNextPageLink());
                         }
                     }
                 }
@@ -248,20 +247,20 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
         }
     }
 
-    private void syncEntityViews(Edge edge, TimePageLink pageLink) {
+    private void syncEntityViews(TenantId tenantId, Edge edge, TimePageLink pageLink) {
-        log.trace("[{}] syncEntityViews [{}]", edge.getTenantId(), edge.getName());
+        log.trace("[{}] syncEntityViews [{}]", tenantId, edge.getName());
         try {
-            ListenableFuture<TimePageData<EntityView>> future = entityViewService.findEntityViewsByTenantIdAndEdgeId(edge.getTenantId(), edge.getId(), pageLink);
+            ListenableFuture<TimePageData<EntityView>> future = entityViewService.findEntityViewsByTenantIdAndEdgeId(tenantId, edge.getId(), pageLink);
             Futures.addCallback(future, new FutureCallback<TimePageData<EntityView>>() {
                 @Override
                 public void onSuccess(@Nullable TimePageData<EntityView> pageData) {
                     if (pageData != null && pageData.getData() != null && !pageData.getData().isEmpty()) {
                         log.trace("[{}] [{}] entity view(s) are going to be pushed to edge.", edge.getId(), pageData.getData().size());
                         for (EntityView entityView : pageData.getData()) {
-                            saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.ENTITY_VIEW, EdgeEventActionType.ADDED, entityView.getId(), null);
+                            saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.ENTITY_VIEW, EdgeEventActionType.ADDED, entityView.getId(), null);
                         }
                         if (pageData.hasNext()) {
-                            syncEntityViews(edge, pageData.getNextPageLink());
+                            syncEntityViews(tenantId, edge, pageData.getNextPageLink());
                         }
                     }
                 }
@@ -276,20 +275,20 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
         }
     }
 
-    private void syncDashboards(Edge edge, TimePageLink pageLink) {
+    private void syncDashboards(TenantId tenantId, Edge edge, TimePageLink pageLink) {
-        log.trace("[{}] syncDashboards [{}]", edge.getTenantId(), edge.getName());
+        log.trace("[{}] syncDashboards [{}]", tenantId, edge.getName());
         try {
-            ListenableFuture<TimePageData<DashboardInfo>> future = dashboardService.findDashboardsByTenantIdAndEdgeId(edge.getTenantId(), edge.getId(), pageLink);
+            ListenableFuture<TimePageData<DashboardInfo>> future = dashboardService.findDashboardsByTenantIdAndEdgeId(tenantId, edge.getId(), pageLink);
             Futures.addCallback(future, new FutureCallback<TimePageData<DashboardInfo>>() {
                 @Override
                 public void onSuccess(@Nullable TimePageData<DashboardInfo> pageData) {
                     if (pageData != null && pageData.getData() != null && !pageData.getData().isEmpty()) {
                         log.trace("[{}] [{}] dashboard(s) are going to be pushed to edge.", edge.getId(), pageData.getData().size());
                         for (DashboardInfo dashboardInfo : pageData.getData()) {
-                            saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.DASHBOARD, EdgeEventActionType.ADDED, dashboardInfo.getId(), null);
+                            saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.DASHBOARD, EdgeEventActionType.ADDED, dashboardInfo.getId(), null);
                         }
                         if (pageData.hasNext()) {
-                            syncDashboards(edge, pageData.getNextPageLink());
+                            syncDashboards(tenantId, edge, pageData.getNextPageLink());
                         }
                     }
                 }
@@ -304,31 +303,31 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
         }
     }
 
-    private void syncUsers(Edge edge, TextPageLink pageLink) {
+    private void syncUsers(TenantId tenantId, Edge edge, TextPageLink pageLink) {
-        log.trace("[{}] syncUsers [{}]", edge.getTenantId(), edge.getName());
+        log.trace("[{}] syncUsers [{}]", tenantId, edge.getName());
         try {
             TextPageData<User> pageData;
             do {
-                pageData = userService.findTenantAdmins(edge.getTenantId(), pageLink);
+                pageData = userService.findTenantAdmins(tenantId, pageLink);
-                pushUsersToEdge(pageData, edge);
+                pushUsersToEdge(tenantId, pageData, edge);
                 if (pageData != null && pageData.hasNext()) {
                     pageLink = pageData.getNextPageLink();
                 }
             } while (pageData != null && pageData.hasNext());
-            syncCustomerUsers(edge);
+            syncCustomerUsers(tenantId, edge);
         } catch (Exception e) {
             log.error("Exception during loading edge user(s) on sync!", e);
         }
     }
 
-    private void syncCustomerUsers(Edge edge) {
+    private void syncCustomerUsers(TenantId tenantId, Edge edge) {
         if (edge.getCustomerId() != null && !EntityId.NULL_UUID.equals(edge.getCustomerId().getId())) {
-            saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.CUSTOMER, EdgeEventActionType.ADDED, edge.getCustomerId(), null);
+            saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.CUSTOMER, EdgeEventActionType.ADDED, edge.getCustomerId(), null);
             TextPageLink pageLink = new TextPageLink(DEFAULT_LIMIT);
             TextPageData<User> pageData;
             do {
-                pageData = userService.findCustomerUsers(edge.getTenantId(), edge.getCustomerId(), pageLink);
+                pageData = userService.findCustomerUsers(tenantId, edge.getCustomerId(), pageLink);
-                pushUsersToEdge(pageData, edge);
+                pushUsersToEdge(tenantId, pageData, edge);
                 if (pageData != null && pageData.hasNext()) {
                     pageLink = pageData.getNextPageLink();
                 }
@@ -336,45 +335,45 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
         }
     }
 
-    private void pushUsersToEdge(TextPageData<User> pageData, Edge edge) {
+    private void pushUsersToEdge(TenantId tenantId, TextPageData<User> pageData, Edge edge) {
         if (pageData != null && pageData.getData() != null && !pageData.getData().isEmpty()) {
             log.trace("[{}] [{}] user(s) are going to be pushed to edge.", edge.getId(), pageData.getData().size());
             for (User user : pageData.getData()) {
-                saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.USER, EdgeEventActionType.ADDED, user.getId(), null);
+                saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.USER, EdgeEventActionType.ADDED, user.getId(), null);
             }
         }
     }
 
-    private void syncWidgetsBundleAndWidgetTypes(Edge edge) {
+    private void syncWidgetsBundleAndWidgetTypes(TenantId tenantId, Edge edge) {
-        log.trace("[{}] syncWidgetsBundleAndWidgetTypes [{}]", edge.getTenantId(), edge.getName());
+        log.trace("[{}] syncWidgetsBundleAndWidgetTypes [{}]", tenantId, edge.getName());
         List<WidgetsBundle> widgetsBundlesToPush = new ArrayList<>();
         List<WidgetType> widgetTypesToPush = new ArrayList<>();
-        widgetsBundlesToPush.addAll(widgetsBundleService.findAllTenantWidgetsBundlesByTenantId(edge.getTenantId()));
+        widgetsBundlesToPush.addAll(widgetsBundleService.findAllTenantWidgetsBundlesByTenantId(tenantId));
-        widgetsBundlesToPush.addAll(widgetsBundleService.findSystemWidgetsBundles(edge.getTenantId()));
+        widgetsBundlesToPush.addAll(widgetsBundleService.findSystemWidgetsBundles(tenantId));
         try {
             for (WidgetsBundle widgetsBundle: widgetsBundlesToPush) {
-                saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.WIDGETS_BUNDLE, EdgeEventActionType.ADDED, widgetsBundle.getId(), null);
+                saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.WIDGETS_BUNDLE, EdgeEventActionType.ADDED, widgetsBundle.getId(), null);
                 widgetTypesToPush.addAll(widgetTypeService.findWidgetTypesByTenantIdAndBundleAlias(widgetsBundle.getTenantId(), widgetsBundle.getAlias()));
             }
             for (WidgetType widgetType: widgetTypesToPush) {
-                saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.WIDGET_TYPE, EdgeEventActionType.ADDED, widgetType.getId(), null);
+                saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.WIDGET_TYPE, EdgeEventActionType.ADDED, widgetType.getId(), null);
             }
         } catch (Exception e) {
             log.error("Exception during loading widgets bundle(s) and widget type(s) on sync!", e);
         }
     }
 
-    private void syncAdminSettings(Edge edge) {
+    private void syncAdminSettings(TenantId tenantId, Edge edge) {
-        log.trace("[{}] syncAdminSettings [{}]", edge.getTenantId(), edge.getName());
+        log.trace("[{}] syncAdminSettings [{}]", tenantId, edge.getName());
         try {
             AdminSettings systemMailSettings = adminSettingsService.findAdminSettingsByKey(TenantId.SYS_TENANT_ID, "mail");
-            saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.ADMIN_SETTINGS, EdgeEventActionType.UPDATED, null, mapper.valueToTree(systemMailSettings));
+            saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.ADMIN_SETTINGS, EdgeEventActionType.UPDATED, null, mapper.valueToTree(systemMailSettings));
             AdminSettings tenantMailSettings = convertToTenantAdminSettings(systemMailSettings.getKey(), (ObjectNode) systemMailSettings.getJsonValue());
-            saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.ADMIN_SETTINGS, EdgeEventActionType.UPDATED, null, mapper.valueToTree(tenantMailSettings));
+            saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.ADMIN_SETTINGS, EdgeEventActionType.UPDATED, null, mapper.valueToTree(tenantMailSettings));
             AdminSettings systemMailTemplates = loadMailTemplates();
-            saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.ADMIN_SETTINGS, EdgeEventActionType.UPDATED, null, mapper.valueToTree(systemMailTemplates));
+            saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.ADMIN_SETTINGS, EdgeEventActionType.UPDATED, null, mapper.valueToTree(systemMailTemplates));
             AdminSettings tenantMailTemplates = convertToTenantAdminSettings(systemMailTemplates.getKey(), (ObjectNode) systemMailTemplates.getJsonValue());
-            saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.ADMIN_SETTINGS, EdgeEventActionType.UPDATED, null, mapper.valueToTree(tenantMailTemplates));
+            saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.ADMIN_SETTINGS, EdgeEventActionType.UPDATED, null, mapper.valueToTree(tenantMailTemplates));
         } catch (Exception e) {
             log.error("Can't load admin settings", e);
         }
@@ -433,13 +432,13 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
     }
 
     @Override
-    public ListenableFuture<Void> processRuleChainMetadataRequestMsg(Edge edge, RuleChainMetadataRequestMsg ruleChainMetadataRequestMsg) {
+    public ListenableFuture<Void> processRuleChainMetadataRequestMsg(TenantId tenantId, Edge edge, RuleChainMetadataRequestMsg ruleChainMetadataRequestMsg) {
-        log.trace("[{}] processRuleChainMetadataRequestMsg [{}][{}]", edge.getTenantId(), edge.getName(), ruleChainMetadataRequestMsg);
+        log.trace("[{}] processRuleChainMetadataRequestMsg [{}][{}]", tenantId, edge.getName(), ruleChainMetadataRequestMsg);
         SettableFuture<Void> futureToSet = SettableFuture.create();
         if (ruleChainMetadataRequestMsg.getRuleChainIdMSB() != 0 && ruleChainMetadataRequestMsg.getRuleChainIdLSB() != 0) {
             RuleChainId ruleChainId =
                     new RuleChainId(new UUID(ruleChainMetadataRequestMsg.getRuleChainIdMSB(), ruleChainMetadataRequestMsg.getRuleChainIdLSB()));
-            ListenableFuture<EdgeEvent> future = saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.RULE_CHAIN_METADATA, EdgeEventActionType.ADDED, ruleChainId, null);
+            ListenableFuture<EdgeEvent> future = saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.RULE_CHAIN_METADATA, EdgeEventActionType.ADDED, ruleChainId, null);
             Futures.addCallback(future, new FutureCallback<EdgeEvent>() {
                 @Override
                 public void onSuccess(@Nullable EdgeEvent result) {
@@ -457,8 +456,8 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
     }
 
     @Override
-    public ListenableFuture<Void> processAttributesRequestMsg(Edge edge, AttributesRequestMsg attributesRequestMsg) {
+    public ListenableFuture<Void> processAttributesRequestMsg(TenantId tenantId, Edge edge, AttributesRequestMsg attributesRequestMsg) {
-        log.trace("[{}] processAttributesRequestMsg [{}][{}]", edge.getTenantId(), edge.getName(), attributesRequestMsg);
+        log.trace("[{}] processAttributesRequestMsg [{}][{}]", tenantId, edge.getName(), attributesRequestMsg);
         EntityId entityId = EntityIdFactory.getByTypeAndUuid(
                 EntityType.valueOf(attributesRequestMsg.getEntityType()),
                 new UUID(attributesRequestMsg.getEntityIdMSB(), attributesRequestMsg.getEntityIdLSB()));
@@ -466,7 +465,7 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
         if (type != null) {
             SettableFuture<Void> futureToSet = SettableFuture.create();
             String scope = attributesRequestMsg.getScope();
-            ListenableFuture<List<AttributeKvEntry>> ssAttrFuture = attributesService.findAll(edge.getTenantId(), entityId, scope);
+            ListenableFuture<List<AttributeKvEntry>> ssAttrFuture = attributesService.findAll(tenantId, entityId, scope);
             Futures.addCallback(ssAttrFuture, new FutureCallback<List<AttributeKvEntry>>() {
                         @Override
                         public void onSuccess(@Nullable List<AttributeKvEntry> ssAttributes) {
@@ -489,7 +488,7 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
                                     entityData.put("scope", scope);
                                     JsonNode body = mapper.valueToTree(entityData);
                                     log.debug("Sending attributes data msg, entityId [{}], attributes [{}]", entityId, body);
-                                    saveEdgeEvent(edge.getTenantId(),
+                                    saveEdgeEvent(tenantId,
                                             edge.getId(),
                                             type,
                                             EdgeEventActionType.ATTRIBUTES_UPDATED,
@@ -500,7 +499,7 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
                                     throw new RuntimeException("[" + edge.getName() + "] Failed to send attribute updates to the edge", e);
                                 }
                             } else {
-                                log.trace("[{}][{}] No attributes found for entity {} [{}]", edge.getTenantId(),
+                                log.trace("[{}][{}] No attributes found for entity {} [{}]", tenantId,
                                         edge.getName(),
                                         entityId.getEntityType(),
                                         entityId.getId());
@@ -516,21 +515,21 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
                     }, dbCallbackExecutorService);
             return futureToSet;
         } else {
-            log.warn("[{}] Type doesn't supported {}", edge.getTenantId(), entityId.getEntityType());
+            log.warn("[{}] Type doesn't supported {}", tenantId, entityId.getEntityType());
             return Futures.immediateFuture(null);
         }
     }
 
     @Override
-    public ListenableFuture<Void> processRelationRequestMsg(Edge edge, RelationRequestMsg relationRequestMsg) {
+    public ListenableFuture<Void> processRelationRequestMsg(TenantId tenantId, Edge edge, RelationRequestMsg relationRequestMsg) {
-        log.trace("[{}] processRelationRequestMsg [{}][{}]", edge.getTenantId(), edge.getName(), relationRequestMsg);
+        log.trace("[{}] processRelationRequestMsg [{}][{}]", tenantId, edge.getName(), relationRequestMsg);
         EntityId entityId = EntityIdFactory.getByTypeAndUuid(
                 EntityType.valueOf(relationRequestMsg.getEntityType()),
                 new UUID(relationRequestMsg.getEntityIdMSB(), relationRequestMsg.getEntityIdLSB()));
 
         List<ListenableFuture<List<EntityRelation>>> futures = new ArrayList<>();
-        futures.add(findRelationByQuery(edge, entityId, EntitySearchDirection.FROM));
+        futures.add(findRelationByQuery(tenantId, edge, entityId, EntitySearchDirection.FROM));
-        futures.add(findRelationByQuery(edge, entityId, EntitySearchDirection.TO));
+        futures.add(findRelationByQuery(tenantId, edge, entityId, EntitySearchDirection.TO));
         ListenableFuture<List<List<EntityRelation>>> relationsListFuture = Futures.allAsList(futures);
         SettableFuture<Void> futureToSet = SettableFuture.create();
         Futures.addCallback(relationsListFuture, new FutureCallback<List<List<EntityRelation>>>() {
@@ -544,7 +543,7 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
                                         try {
                                             if (!relation.getFrom().getEntityType().equals(EntityType.EDGE) &&
                                                     !relation.getTo().getEntityType().equals(EntityType.EDGE)) {
-                                                saveEdgeEvent(edge.getTenantId(),
+                                                saveEdgeEvent(tenantId,
                                                         edge.getId(),
                                                         EdgeEventType.RELATION,
                                                         EdgeEventActionType.ADDED,
@@ -568,26 +567,26 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
 
                     @Override
                     public void onFailure(Throwable t) {
-                        log.error("[{}] Can't find relation by query. Entity id [{}]", edge.getTenantId(), entityId, t);
+                        log.error("[{}] Can't find relation by query. Entity id [{}]", tenantId, entityId, t);
                         futureToSet.setException(t);
                     }
                 }, dbCallbackExecutorService);
         return futureToSet;
     }
 
-    private ListenableFuture<List<EntityRelation>> findRelationByQuery(Edge edge, EntityId entityId, EntitySearchDirection direction) {
+    private ListenableFuture<List<EntityRelation>> findRelationByQuery(TenantId tenantId, Edge edge, EntityId entityId, EntitySearchDirection direction) {
         EntityRelationsQuery query = new EntityRelationsQuery();
         query.setParameters(new RelationsSearchParameters(entityId, direction, -1, false));
-        return relationService.findByQuery(edge.getTenantId(), query);
+        return relationService.findByQuery(tenantId, query);
     }
 
     @Override
-    public ListenableFuture<Void> processDeviceCredentialsRequestMsg(Edge edge, DeviceCredentialsRequestMsg deviceCredentialsRequestMsg) {
+    public ListenableFuture<Void> processDeviceCredentialsRequestMsg(TenantId tenantId, Edge edge, DeviceCredentialsRequestMsg deviceCredentialsRequestMsg) {
-        log.trace("[{}] processDeviceCredentialsRequestMsg [{}][{}]", edge.getTenantId(), edge.getName(), deviceCredentialsRequestMsg);
+        log.trace("[{}] processDeviceCredentialsRequestMsg [{}][{}]", tenantId, edge.getName(), deviceCredentialsRequestMsg);
         SettableFuture<Void> futureToSet = SettableFuture.create();
         if (deviceCredentialsRequestMsg.getDeviceIdMSB() != 0 && deviceCredentialsRequestMsg.getDeviceIdLSB() != 0) {
             DeviceId deviceId = new DeviceId(new UUID(deviceCredentialsRequestMsg.getDeviceIdMSB(), deviceCredentialsRequestMsg.getDeviceIdLSB()));
-            ListenableFuture<EdgeEvent> future = saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.DEVICE, EdgeEventActionType.CREDENTIALS_UPDATED, deviceId, null);
+            ListenableFuture<EdgeEvent> future = saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.DEVICE, EdgeEventActionType.CREDENTIALS_UPDATED, deviceId, null);
             Futures.addCallback(future, new FutureCallback<EdgeEvent>() {
                 @Override
                 public void onSuccess(@Nullable EdgeEvent result) {
@@ -605,12 +604,12 @@ public class DefaultSyncEdgeService implements SyncEdgeService {
     }
 
     @Override
-    public ListenableFuture<Void> processUserCredentialsRequestMsg(Edge edge, UserCredentialsRequestMsg userCredentialsRequestMsg) {
+    public ListenableFuture<Void> processUserCredentialsRequestMsg(TenantId tenantId, Edge edge, UserCredentialsRequestMsg userCredentialsRequestMsg) {
-        log.trace("[{}] processUserCredentialsRequestMsg [{}][{}]", edge.getTenantId(), edge.getName(), userCredentialsRequestMsg);
+        log.trace("[{}] processUserCredentialsRequestMsg [{}][{}]", tenantId, edge.getName(), userCredentialsRequestMsg);
         SettableFuture<Void> futureToSet = SettableFuture.create();
         if (userCredentialsRequestMsg.getUserIdMSB() != 0 && userCredentialsRequestMsg.getUserIdLSB() != 0) {
             UserId userId = new UserId(new UUID(userCredentialsRequestMsg.getUserIdMSB(), userCredentialsRequestMsg.getUserIdLSB()));
-            ListenableFuture<EdgeEvent> future = saveEdgeEvent(edge.getTenantId(), edge.getId(), EdgeEventType.USER, EdgeEventActionType.CREDENTIALS_UPDATED, userId, null);
+            ListenableFuture<EdgeEvent> future = saveEdgeEvent(tenantId, edge.getId(), EdgeEventType.USER, EdgeEventActionType.CREDENTIALS_UPDATED, userId, null);
             Futures.addCallback(future, new FutureCallback<EdgeEvent>() {
                 @Override
                 public void onSuccess(@Nullable EdgeEvent result) {

application/src/main/java/org/thingsboard/server/service/edge/rpc/init/SyncEdgeService.java

@@ -17,6 +17,7 @@ package org.thingsboard.server.service.edge.rpc.init;
 
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.edge.Edge;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.gen.edge.AttributesRequestMsg;
 import org.thingsboard.server.gen.edge.DeviceCredentialsRequestMsg;
 import org.thingsboard.server.gen.edge.RelationRequestMsg;
@@ -25,15 +26,15 @@ import org.thingsboard.server.gen.edge.UserCredentialsRequestMsg;
 
 public interface SyncEdgeService {
 
-    void sync(Edge edge);
+    void sync(TenantId tenantId, Edge edge);
 
-    ListenableFuture<Void> processRuleChainMetadataRequestMsg(Edge edge, RuleChainMetadataRequestMsg ruleChainMetadataRequestMsg);
+    ListenableFuture<Void> processRuleChainMetadataRequestMsg(TenantId tenantId, Edge edge, RuleChainMetadataRequestMsg ruleChainMetadataRequestMsg);
 
-    ListenableFuture<Void> processAttributesRequestMsg(Edge edge, AttributesRequestMsg attributesRequestMsg);
+    ListenableFuture<Void> processAttributesRequestMsg(TenantId tenantId, Edge edge, AttributesRequestMsg attributesRequestMsg);
 
-    ListenableFuture<Void> processRelationRequestMsg(Edge edge, RelationRequestMsg relationRequestMsg);
+    ListenableFuture<Void> processRelationRequestMsg(TenantId tenantId, Edge edge, RelationRequestMsg relationRequestMsg);
 
-    ListenableFuture<Void> processDeviceCredentialsRequestMsg(Edge edge, DeviceCredentialsRequestMsg deviceCredentialsRequestMsg);
+    ListenableFuture<Void> processDeviceCredentialsRequestMsg(TenantId tenantId, Edge edge, DeviceCredentialsRequestMsg deviceCredentialsRequestMsg);
 
-    ListenableFuture<Void> processUserCredentialsRequestMsg(Edge edge, UserCredentialsRequestMsg userCredentialsRequestMsg);
+    ListenableFuture<Void> processUserCredentialsRequestMsg(TenantId tenantId, Edge edge, UserCredentialsRequestMsg userCredentialsRequestMsg);
 }

application/src/main/java/org/thingsboard/server/service/install/update/DefaultDataUpdateService.java

@@ -89,7 +89,7 @@ public class DefaultDataUpdateService implements DataUpdateService {
                 @Override
                 protected void updateEntity(Tenant tenant) {
                     try {
-                        RuleChain defaultEdgeRuleChain = ruleChainService.getDefaultRootEdgeRuleChain(tenant.getId());
+                        RuleChain defaultEdgeRuleChain = ruleChainService.getEdgeTemplateRootRuleChain(tenant.getId());
                         if (defaultEdgeRuleChain == null) {
                             installScripts.createDefaultEdgeRuleChains(tenant.getId());
                         }

application/src/test/java/org/thingsboard/server/controller/BaseEdgeControllerTest.java

@@ -682,7 +682,7 @@ public abstract class BaseEdgeControllerTest extends AbstractControllerTest {
         edgeImitator.getDownlinkMsgs().clear();
 
         edgeImitator.expectMessageAmount(4);
-        doPost("/api/edge/sync", edge.getId());
+        doPost("/api/edge/sync/" + edge.getId());
         edgeImitator.waitForMessages();
 
         Assert.assertEquals(4, edgeImitator.getDownlinkMsgs().size());

common/dao-api/src/main/java/org/thingsboard/server/dao/edge/EdgeService.java

@@ -80,4 +80,6 @@ public interface EdgeService {
     Object checkInstance(Object request);
 
     Object activateInstance(String licenseSecret, String releaseDate);
+
+    String findMissingToRelatedRuleChains(TenantId tenantId, EdgeId edgeId);
 }

common/dao-api/src/main/java/org/thingsboard/server/dao/rule/RuleChainService.java

@@ -73,14 +73,14 @@ public interface RuleChainService {
 
     ListenableFuture<TimePageData<RuleChain>> findRuleChainsByTenantIdAndEdgeId(TenantId tenantId, EdgeId edgeId, TimePageLink pageLink);
 
-    RuleChain getDefaultRootEdgeRuleChain(TenantId tenantId);
+    RuleChain getEdgeTemplateRootRuleChain(TenantId tenantId);
 
-    boolean setDefaultRootEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId);
+    boolean setEdgeTemplateRootRuleChain(TenantId tenantId, RuleChainId ruleChainId);
 
-    boolean addDefaultEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId);
+    boolean setAutoAssignToEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId);
 
-    boolean removeDefaultEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId);
+    boolean unsetAutoAssignToEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId);
 
-    ListenableFuture<List<RuleChain>> findDefaultEdgeRuleChainsByTenantId(TenantId tenantId);
+    ListenableFuture<List<RuleChain>> findAutoAssignToEdgeRuleChainsByTenantId(TenantId tenantId);
 
 }

common/data/src/main/java/org/thingsboard/server/common/data/relation/RelationTypeGroup.java

@@ -23,6 +23,6 @@ public enum RelationTypeGroup {
     RULE_CHAIN,
     RULE_NODE,
     EDGE,
-    EDGE_DEFAULT_RULE_CHAIN
+    EDGE_AUTO_ASSIGN_RULE_CHAIN
 
 }

dao/src/main/java/org/thingsboard/server/dao/edge/EdgeServiceImpl.java

@@ -15,6 +15,9 @@
  */
 package org.thingsboard.server.dao.edge;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.google.common.base.Function;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
@@ -54,10 +57,13 @@ import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.UserId;
 import org.thingsboard.server.common.data.page.TextPageData;
 import org.thingsboard.server.common.data.page.TextPageLink;
+import org.thingsboard.server.common.data.page.TimePageData;
+import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntitySearchDirection;
 import org.thingsboard.server.common.data.relation.RelationTypeGroup;
 import org.thingsboard.server.common.data.rule.RuleChain;
+import org.thingsboard.server.common.data.rule.RuleChainConnectionInfo;
 import org.thingsboard.server.dao.customer.CustomerDao;
 import org.thingsboard.server.dao.entity.AbstractEntityService;
 import org.thingsboard.server.dao.exception.DataValidationException;
@@ -100,6 +106,8 @@ public class EdgeServiceImpl extends AbstractEntityService implements EdgeServic
     public static final String INCORRECT_CUSTOMER_ID = "Incorrect customerId ";
     public static final String INCORRECT_EDGE_ID = "Incorrect edgeId ";
 
+    private static final ObjectMapper mapper = new ObjectMapper();
+
     private static final int DEFAULT_LIMIT = 100;
 
     private RestTemplate restTemplate;
@@ -340,7 +348,7 @@ public class EdgeServiceImpl extends AbstractEntityService implements EdgeServic
     @Override
     public void assignDefaultRuleChainsToEdge(TenantId tenantId, EdgeId edgeId) {
         log.trace("Executing assignDefaultRuleChainsToEdge, tenantId [{}], edgeId [{}]", tenantId, edgeId);
-        ListenableFuture<List<RuleChain>> future = ruleChainService.findDefaultEdgeRuleChainsByTenantId(tenantId);
+        ListenableFuture<List<RuleChain>> future = ruleChainService.findAutoAssignToEdgeRuleChainsByTenantId(tenantId);
         Futures.addCallback(future, new FutureCallback<List<RuleChain>>() {
             @Override
             public void onSuccess(List<RuleChain> ruleChains) {
@@ -575,6 +583,56 @@ public class EdgeServiceImpl extends AbstractEntityService implements EdgeServic
         return this.restTemplate.postForEntity(EDGE_LICENSE_SERVER_ENDPOINT + "/api/license/activateInstance?licenseSecret={licenseSecret}&releaseDate={releaseDate}", (Object) null, Object.class, params);
     }
 
+    @Override
+    public String findMissingToRelatedRuleChains(TenantId tenantId, EdgeId edgeId) {
+        List<RuleChain> edgeRuleChains = findEdgeRuleChains(tenantId, edgeId);
+        List<RuleChainId> edgeRuleChainIds = edgeRuleChains.stream().map(IdBased::getId).collect(Collectors.toList());
+        ObjectNode result = mapper.createObjectNode();
+        for (RuleChain edgeRuleChain : edgeRuleChains) {
+            List<RuleChainConnectionInfo> connectionInfos =
+                    ruleChainService.loadRuleChainMetaData(edgeRuleChain.getTenantId(), edgeRuleChain.getId()).getRuleChainConnections();
+            if (connectionInfos != null && !connectionInfos.isEmpty()) {
+                List<RuleChainId> connectedRuleChains =
+                        connectionInfos.stream().map(RuleChainConnectionInfo::getTargetRuleChainId).collect(Collectors.toList());
+                List<String> missingRuleChains = new ArrayList<>();
+                for (RuleChainId connectedRuleChain : connectedRuleChains) {
+                    if (!edgeRuleChainIds.contains(connectedRuleChain)) {
+                        RuleChain ruleChainById = ruleChainService.findRuleChainById(tenantId, connectedRuleChain);
+                        missingRuleChains.add(ruleChainById.getName());
+                    }
+                }
+                if (!missingRuleChains.isEmpty()) {
+                    ArrayNode array = mapper.createArrayNode();
+                    for (String missingRuleChain : missingRuleChains) {
+                        array.add(missingRuleChain);
+                    }
+                    result.set(edgeRuleChain.getName(), array);
+                }
+            }
+        }
+        return result.toString();
+    }
+
+    private List<RuleChain> findEdgeRuleChains(TenantId tenantId, EdgeId edgeId) {
+        List<RuleChain> result = new ArrayList<>();
+        TimePageLink pageLink = new TimePageLink(DEFAULT_LIMIT);
+        TimePageData<RuleChain> pageData;
+        try {
+            do {
+                pageData = ruleChainService.findRuleChainsByTenantIdAndEdgeId(tenantId, edgeId, pageLink).get();
+                if (pageData != null && pageData.getData() != null && !pageData.getData().isEmpty()) {
+                    result.addAll(pageData.getData());
+                    if (pageData.hasNext()) {
+                        pageLink = pageData.getNextPageLink();
+                    }
+                }
+            } while (pageData != null && pageData.hasNext());
+        } catch (Exception e) {
+            log.error("[{}] Can't find edge rule chains [{}]", tenantId, edgeId, e);
+        }
+        return result;
+    }
+
     private void initRestTemplate() {
         boolean jdkHttpClientEnabled = isNotEmpty(System.getProperty("tb.proxy.jdk")) && System.getProperty("tb.proxy.jdk").equalsIgnoreCase("true");
         boolean systemProxyEnabled = isNotEmpty(System.getProperty("tb.proxy.system")) && System.getProperty("tb.proxy.system").equalsIgnoreCase("true");

dao/src/main/java/org/thingsboard/server/dao/rule/BaseRuleChainService.java

@@ -484,21 +484,21 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
     }
 
     @Override
-    public RuleChain getDefaultRootEdgeRuleChain(TenantId tenantId) {
+    public RuleChain getEdgeTemplateRootRuleChain(TenantId tenantId) {
         return getRootRuleChainByType(tenantId, RuleChainType.EDGE);
     }
 
     @Override
-    public boolean setDefaultRootEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
+    public boolean setEdgeTemplateRootRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
         RuleChain ruleChain = ruleChainDao.findById(tenantId, ruleChainId.getId());
-        RuleChain previousDefaultRootEdgeRuleChain = getDefaultRootEdgeRuleChain(ruleChain.getTenantId());
+        RuleChain previousEdgeTemplateRootRuleChain = getEdgeTemplateRootRuleChain(ruleChain.getTenantId());
-        if (previousDefaultRootEdgeRuleChain == null || !previousDefaultRootEdgeRuleChain.getId().equals(ruleChain.getId())) {
+        if (previousEdgeTemplateRootRuleChain == null || !previousEdgeTemplateRootRuleChain.getId().equals(ruleChain.getId())) {
             try {
-                if (previousDefaultRootEdgeRuleChain != null) {
+                if (previousEdgeTemplateRootRuleChain != null) {
-                    deleteRelation(tenantId, new EntityRelation(previousDefaultRootEdgeRuleChain.getTenantId(), previousDefaultRootEdgeRuleChain.getId(),
+                    deleteRelation(tenantId, new EntityRelation(previousEdgeTemplateRootRuleChain.getTenantId(), previousEdgeTemplateRootRuleChain.getId(),
                             EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
-                    previousDefaultRootEdgeRuleChain.setRoot(false);
+                    previousEdgeTemplateRootRuleChain.setRoot(false);
-                    ruleChainDao.save(tenantId, previousDefaultRootEdgeRuleChain);
+                    ruleChainDao.save(tenantId, previousEdgeTemplateRootRuleChain);
                 }
                 createRelation(tenantId, new EntityRelation(ruleChain.getTenantId(), ruleChain.getId(),
                         EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
@@ -506,7 +506,7 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
                 ruleChainDao.save(tenantId, ruleChain);
                 return true;
             } catch (Exception e) {
-                log.warn("Failed to set default root edge rule chain, ruleChainId: [{}]", ruleChainId, e);
+                log.warn("Failed to set edge template root rule chain, ruleChainId: [{}]", ruleChainId, e);
                 throw new RuntimeException(e);
             }
         }
@@ -514,34 +514,34 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
     }
 
     @Override
-    public boolean addDefaultEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
+    public boolean setAutoAssignToEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
         try {
             createRelation(tenantId, new EntityRelation(tenantId, ruleChainId,
-                    EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_DEFAULT_RULE_CHAIN));
+                    EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_AUTO_ASSIGN_RULE_CHAIN));
             return true;
         } catch (Exception e) {
-            log.warn("Failed to add default edge rule chain, ruleChainId: [{}]", ruleChainId, e);
+            log.warn("Failed to set auto assign to edge rule chain, ruleChainId: [{}]", ruleChainId, e);
             throw new RuntimeException(e);
         }
     }
 
     @Override
-    public boolean removeDefaultEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
+    public boolean unsetAutoAssignToEdgeRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
         try {
             deleteRelation(tenantId, new EntityRelation(tenantId, ruleChainId,
-                    EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_DEFAULT_RULE_CHAIN));
+                    EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_AUTO_ASSIGN_RULE_CHAIN));
             return true;
         } catch (Exception e) {
-            log.warn("Failed to remove default edge rule chain, ruleChainId: [{}]", ruleChainId, e);
+            log.warn("Failed to unset auto assign to edge rule chain, ruleChainId: [{}]", ruleChainId, e);
             throw new RuntimeException(e);
         }
     }
 
     @Override
-    public ListenableFuture<List<RuleChain>> findDefaultEdgeRuleChainsByTenantId(TenantId tenantId) {
+    public ListenableFuture<List<RuleChain>> findAutoAssignToEdgeRuleChainsByTenantId(TenantId tenantId) {
-        log.trace("Executing findDefaultEdgeRuleChainsByTenantId, tenantId [{}]", tenantId);
+        log.trace("Executing findAutoAssignToEdgeRuleChainsByTenantId, tenantId [{}]", tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
-        return ruleChainDao.findDefaultEdgeRuleChainsByTenantId(tenantId.getId());
+        return ruleChainDao.findAutoAssignToEdgeRuleChainsByTenantId(tenantId.getId());
     }
 
 
@@ -592,9 +592,9 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
                         }
                     }
                     if (ruleChain.isRoot() && RuleChainType.EDGE.equals(ruleChain.getType())) {
-                        RuleChain defaultRootEdgeRuleChain = getDefaultRootEdgeRuleChain(ruleChain.getTenantId());
+                        RuleChain edgeTemplateRootRuleChain = getEdgeTemplateRootRuleChain(ruleChain.getTenantId());
-                        if (defaultRootEdgeRuleChain != null && !defaultRootEdgeRuleChain.getId().equals(ruleChain.getId())) {
+                        if (edgeTemplateRootRuleChain != null && !edgeTemplateRootRuleChain.getId().equals(ruleChain.getId())) {
-                            throw new DataValidationException("Another default root edge rule chain is present in scope of current tenant!");
+                            throw new DataValidationException("Another edge template root rule chain is present in scope of current tenant!");
                         }
                     }
                 }

dao/src/main/java/org/thingsboard/server/dao/rule/CassandraRuleChainDao.java

@@ -103,9 +103,10 @@ public class CassandraRuleChainDao extends CassandraAbstractSearchTextDao<RuleCh
     }
 
     @Override
-    public ListenableFuture<List<RuleChain>> findDefaultEdgeRuleChainsByTenantId(UUID tenantId) {
+    public ListenableFuture<List<RuleChain>> findAutoAssignToEdgeRuleChainsByTenantId(UUID tenantId) {
-        log.debug("Try to find default edge rule chains by tenantId [{}]", tenantId);
+        log.debug("Try to find auto assign to edge rule chains by tenantId [{}]", tenantId);
-        ListenableFuture<List<EntityRelation>> relations = relationDao.findAllByFromAndType(new TenantId(tenantId), new TenantId(tenantId), EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_DEFAULT_RULE_CHAIN);
+        ListenableFuture<List<EntityRelation>> relations =
+                relationDao.findAllByFromAndType(new TenantId(tenantId), new TenantId(tenantId), EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_AUTO_ASSIGN_RULE_CHAIN);
         return Futures.transformAsync(relations, input -> {
             List<ListenableFuture<RuleChain>> ruleChainFutures = new ArrayList<>(input.size());
             for (EntityRelation relation : input) {

dao/src/main/java/org/thingsboard/server/dao/rule/RuleChainDao.java

@@ -60,10 +60,10 @@ public interface RuleChainDao extends Dao<RuleChain> {
     ListenableFuture<List<RuleChain>> findRuleChainsByTenantIdAndEdgeId(UUID tenantId, UUID edgeId, TimePageLink pageLink);
 
     /**
-     * Find default edge rule chains by tenantId.
+     * Find auto assign to edge rule chains by tenantId.
      *
      * @param tenantId the tenantId
      * @return the list of rule chain objects
      */
-    ListenableFuture<List<RuleChain>> findDefaultEdgeRuleChainsByTenantId(UUID tenantId);
+    ListenableFuture<List<RuleChain>> findAutoAssignToEdgeRuleChainsByTenantId(UUID tenantId);
 }

dao/src/main/java/org/thingsboard/server/dao/sql/rule/JpaRuleChainDao.java

@@ -25,9 +25,7 @@ import org.springframework.data.repository.CrudRepository;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.UUIDConverter;
-import org.thingsboard.server.common.data.edge.Edge;
 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.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TimePageLink;
@@ -107,9 +105,10 @@ public class JpaRuleChainDao extends JpaAbstractSearchTextDao<RuleChainEntity, R
     }
 
     @Override
-    public ListenableFuture<List<RuleChain>> findDefaultEdgeRuleChainsByTenantId(UUID tenantId) {
+    public ListenableFuture<List<RuleChain>> findAutoAssignToEdgeRuleChainsByTenantId(UUID tenantId) {
-        log.debug("Try to find default edge rule chains by tenantId [{}]", tenantId);
+        log.debug("Try to find auto assign to edge rule chains by tenantId [{}]", tenantId);
-        ListenableFuture<List<EntityRelation>> relations = relationDao.findAllByFromAndType(new TenantId(tenantId), new TenantId(tenantId), EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_DEFAULT_RULE_CHAIN);
+        ListenableFuture<List<EntityRelation>> relations =
+                relationDao.findAllByFromAndType(new TenantId(tenantId), new TenantId(tenantId), EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE_AUTO_ASSIGN_RULE_CHAIN);
         return Futures.transformAsync(relations, input -> {
             List<ListenableFuture<RuleChain>> ruleChainsFutures = new ArrayList<>(input.size());
             for (EntityRelation relation : input) {

dao/src/test/java/org/thingsboard/server/dao/service/BaseRuleChainServiceTest.java

@@ -331,24 +331,24 @@ public abstract class BaseRuleChainServiceTest extends AbstractServiceTest {
 
     @Test
     public void testGetDefaultEdgeRuleChains() throws Exception {
-        RuleChainId ruleChainId = saveRuleChainAndSetDefaultEdge("Default Edge Rule Chain 1");
+        RuleChainId ruleChainId = saveRuleChainAndSetAutoAssignToEdge("Default Edge Rule Chain 1");
-        saveRuleChainAndSetDefaultEdge("Default Edge Rule Chain 2");
+        saveRuleChainAndSetAutoAssignToEdge("Default Edge Rule Chain 2");
-        List<RuleChain> result = ruleChainService.findDefaultEdgeRuleChainsByTenantId(tenantId).get();
+        List<RuleChain> result = ruleChainService.findAutoAssignToEdgeRuleChainsByTenantId(tenantId).get();
         Assert.assertEquals(2, result.size());
 
-        ruleChainService.removeDefaultEdgeRuleChain(tenantId, ruleChainId);
+        ruleChainService.unsetAutoAssignToEdgeRuleChain(tenantId, ruleChainId);
 
-        result = ruleChainService.findDefaultEdgeRuleChainsByTenantId(tenantId).get();
+        result = ruleChainService.findAutoAssignToEdgeRuleChainsByTenantId(tenantId).get();
         Assert.assertEquals(1, result.size());
     }
 
     @Test
-    public void setDefaultRootEdgeRuleChain() throws Exception {
+    public void setEdgeTemplateRootRuleChain() throws Exception {
-        RuleChainId ruleChainId1 = saveRuleChainAndSetDefaultEdge("Default Edge Rule Chain 1");
+        RuleChainId ruleChainId1 = saveRuleChainAndSetAutoAssignToEdge("Default Edge Rule Chain 1");
-        RuleChainId ruleChainId2 = saveRuleChainAndSetDefaultEdge("Default Edge Rule Chain 2");
+        RuleChainId ruleChainId2 = saveRuleChainAndSetAutoAssignToEdge("Default Edge Rule Chain 2");
 
-        ruleChainService.setDefaultRootEdgeRuleChain(tenantId, ruleChainId1);
+        ruleChainService.setEdgeTemplateRootRuleChain(tenantId, ruleChainId1);
-        ruleChainService.setDefaultRootEdgeRuleChain(tenantId, ruleChainId2);
+        ruleChainService.setEdgeTemplateRootRuleChain(tenantId, ruleChainId2);
 
         RuleChain ruleChainById = ruleChainService.findRuleChainById(tenantId, ruleChainId1);
         Assert.assertFalse(ruleChainById.isRoot());
@@ -357,13 +357,13 @@ public abstract class BaseRuleChainServiceTest extends AbstractServiceTest {
         Assert.assertTrue(ruleChainById.isRoot());
     }
 
-    private RuleChainId saveRuleChainAndSetDefaultEdge(String name) {
+    private RuleChainId saveRuleChainAndSetAutoAssignToEdge(String name) {
         RuleChain edgeRuleChain = new RuleChain();
         edgeRuleChain.setTenantId(tenantId);
         edgeRuleChain.setType(RuleChainType.EDGE);
         edgeRuleChain.setName(name);
         RuleChain savedEdgeRuleChain = ruleChainService.saveRuleChain(edgeRuleChain);
-        ruleChainService.addDefaultEdgeRuleChain(tenantId, savedEdgeRuleChain.getId());
+        ruleChainService.setAutoAssignToEdgeRuleChain(tenantId, savedEdgeRuleChain.getId());
         return savedEdgeRuleChain.getId();
     }
 

rest-client/src/main/java/org/thingsboard/rest/client/RestClient.java

@@ -2262,9 +2262,9 @@ public class RestClient implements ClientHttpRequestInterceptor, Closeable {
                 }, params).getBody();
     }
 
-    public Optional<RuleChain> addDefaultEdgeRuleChain(RuleChainId ruleChainId) {
+    public Optional<RuleChain> setAutoAssignToEdgeRuleChain(RuleChainId ruleChainId) {
         try {
-            ResponseEntity<RuleChain> ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/defaultEdge", null, RuleChain.class, ruleChainId.getId());
+            ResponseEntity<RuleChain> ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/autoAssignToEdge", null, RuleChain.class, ruleChainId.getId());
             return Optional.ofNullable(ruleChain.getBody());
         } catch (HttpClientErrorException exception) {
             if (exception.getStatusCode() == HttpStatus.NOT_FOUND) {
@@ -2275,9 +2275,9 @@ public class RestClient implements ClientHttpRequestInterceptor, Closeable {
         }
     }
 
-    public Optional<RuleChain> removeDefaultEdgeRuleChain(RuleChainId ruleChainId) {
+    public Optional<RuleChain> unsetAutoAssignToEdgeRuleChain(RuleChainId ruleChainId) {
         try {
-            ResponseEntity<RuleChain> ruleChain = restTemplate.exchange(baseURL + "/api/ruleChain/{ruleChainId}/defaultEdge", HttpMethod.DELETE, HttpEntity.EMPTY, RuleChain.class, ruleChainId.getId());
+            ResponseEntity<RuleChain> ruleChain = restTemplate.exchange(baseURL + "/api/ruleChain/{ruleChainId}/autoAssignToEdge", HttpMethod.DELETE, HttpEntity.EMPTY, RuleChain.class, ruleChainId.getId());
             return Optional.ofNullable(ruleChain.getBody());
         } catch (HttpClientErrorException exception) {
             if (exception.getStatusCode() == HttpStatus.NOT_FOUND) {
@@ -2288,17 +2288,17 @@ public class RestClient implements ClientHttpRequestInterceptor, Closeable {
         }
     }
 
-    public List<RuleChain> getDefaultEdgeRuleChains() {
+    public List<RuleChain> getAutoAssignToEdgeRuleChains() {
-        return restTemplate.exchange(baseURL + "/api/ruleChain/defaultEdgeRuleChains",
+        return restTemplate.exchange(baseURL + "/api/ruleChain/autoAssignToEdgeRuleChains",
                 HttpMethod.GET,
                 HttpEntity.EMPTY,
                 new ParameterizedTypeReference<List<RuleChain>>() {
                 }).getBody();
     }
 
-    public Optional<RuleChain> setDefaultRootEdgeRuleChain(RuleChainId ruleChainId) {
+    public Optional<RuleChain> setRootEdgeTemplateRuleChain(RuleChainId ruleChainId) {
         try {
-            ResponseEntity<RuleChain> ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/defaultRootEdge", null, RuleChain.class, ruleChainId.getId());
+            ResponseEntity<RuleChain> ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/edgeTemplateRoot", null, RuleChain.class, ruleChainId.getId());
             return Optional.ofNullable(ruleChain.getBody());
         } catch (HttpClientErrorException exception) {
             if (exception.getStatusCode() == HttpStatus.NOT_FOUND) {
@@ -2384,7 +2384,9 @@ public class RestClient implements ClientHttpRequestInterceptor, Closeable {
     }
 
     public void syncEdge(EdgeId edgeId) {
-        restTemplate.postForEntity(baseURL + "/api/edge/sync", edgeId, EdgeId.class);
+        Map<String, String> params = new HashMap<>();
+        params.put("edgeId", edgeId.toString());
+        restTemplate.postForEntity(baseURL + "/api/edge/sync/{edgeId}", null, EdgeId.class, params);
     }
 
     @Deprecated

ui/src/app/api/edge.service.js

@@ -297,8 +297,8 @@ function EdgeService($http, $q, customerService) {
 
     function syncEdge(edgeId) {
         var deferred = $q.defer();
-        var url = '/api/edge/sync';
+        var url = '/api/edge/sync/' + edgeId;
-        $http.post(url, edgeId).then(function success(response) {
+        $http.post(url, null).then(function success(response) {
             deferred.resolve(response);
         }, function fail(response) {
             deferred.reject(response.data);

ui/src/app/api/rule-chain.service.js

@@ -40,10 +40,10 @@ function RuleChainService($http, $q, $filter, $ocLazyLoad, $translate, types, co
         getEdgesRuleChains: getEdgesRuleChains,
         assignRuleChainToEdge: assignRuleChainToEdge,
         unassignRuleChainFromEdge: unassignRuleChainFromEdge,
-        setDefaultRootEdgeRuleChain: setDefaultRootEdgeRuleChain,
+        setEdgeTemplateRootRuleChain: setEdgeTemplateRootRuleChain,
-        addDefaultEdgeRuleChain: addDefaultEdgeRuleChain,
+        setAutoAssignToEdgeRuleChain: setAutoAssignToEdgeRuleChain,
-        removeDefaultEdgeRuleChain: removeDefaultEdgeRuleChain,
+        unsetAutoAssignToEdgeRuleChain: unsetAutoAssignToEdgeRuleChain,
-        getDefaultEdgeRuleChains: getDefaultEdgeRuleChains
+        getAutoAssignToEdgeRuleChains: getAutoAssignToEdgeRuleChains
     };
 
     return service;
@@ -350,9 +350,9 @@ function RuleChainService($http, $q, $filter, $ocLazyLoad, $translate, types, co
         return deferred.promise;
     }
 
-    function setDefaultRootEdgeRuleChain(ruleChainId) {
+    function setEdgeTemplateRootRuleChain(ruleChainId) {
         var deferred = $q.defer();
-        var url = '/api/ruleChain/' + ruleChainId + '/defaultRootEdge';
+        var url = '/api/ruleChain/' + ruleChainId + '/edgeTemplateRoot';
         $http.post(url).then(function success(response) {
             deferred.resolve(response.data);
         }, function fail() {
@@ -361,9 +361,9 @@ function RuleChainService($http, $q, $filter, $ocLazyLoad, $translate, types, co
         return deferred.promise;
     }
 
-    function addDefaultEdgeRuleChain(ruleChainId) {
+    function setAutoAssignToEdgeRuleChain(ruleChainId) {
         var deferred = $q.defer();
-        var url = '/api/ruleChain/' + ruleChainId + '/defaultEdge';
+        var url = '/api/ruleChain/' + ruleChainId + '/autoAssignToEdge';
         $http.post(url, null).then(function success(response) {
             deferred.resolve(response.data);
         }, function fail() {
@@ -372,9 +372,9 @@ function RuleChainService($http, $q, $filter, $ocLazyLoad, $translate, types, co
         return deferred.promise;
     }
 
-    function removeDefaultEdgeRuleChain(ruleChainId) {
+    function unsetAutoAssignToEdgeRuleChain(ruleChainId) {
         var deferred = $q.defer();
-        var url = '/api/ruleChain/' + ruleChainId + '/defaultEdge';
+        var url = '/api/ruleChain/' + ruleChainId + '/autoAssignToEdge';
         $http.delete(url).then(function success(response) {
             deferred.resolve(response.data);
         }, function fail() {
@@ -383,9 +383,9 @@ function RuleChainService($http, $q, $filter, $ocLazyLoad, $translate, types, co
         return deferred.promise;
     }
 
-    function getDefaultEdgeRuleChains(config) {
+    function getAutoAssignToEdgeRuleChains(config) {
         var deferred = $q.defer();
-        var url = '/api/ruleChain/defaultEdgeRuleChains';
+        var url = '/api/ruleChain/autoAssignToEdgeRuleChains';
         $http.get(url, config).then(function success(response) {
             deferred.resolve(response.data);
         }, function fail() {

ui/src/app/edge/edge.directive.js

@@ -71,7 +71,7 @@ export default function EdgeDirective($compile, $templateCache, $translate, $mdD
         };
 
         scope.onEdgeSync = function (edgeId) {
-            edgeService.syncEdge(edgeId).then(
+            edgeService.syncEdge(edgeId.id).then(
                 function success() {
                     toast.showSuccess($translate.instant('edge.sync-message'), 750, angular.element(element).parent().parent(), 'bottom left');
                 },

ui/src/app/rulechain/rulechains.controller.js

@@ -97,8 +97,8 @@ export default function RuleChainsController(ruleChainService, userService, impo
 
     vm.exportRuleChain = exportRuleChain;
     vm.setRootRuleChain = setRootRuleChain;
-    vm.setAutoAssignToEdgeRuleChain = setAutoAssignToEdgeRuleChain;
+    vm.setDefaultEdgeRuleChain = setDefaultEdgeRuleChain;
-    vm.removeDefaultEdgeRuleChain = removeDefaultEdgeRuleChain;
+    vm.unsetAutoAssignToEdgeRuleChain = unsetAutoAssignToEdgeRuleChain;
     
     initController();
 
@@ -185,27 +185,27 @@ export default function RuleChainsController(ruleChainService, userService, impo
 
             ruleChainActionsList.push({
                 onAction: function ($event, item) {
-                    setAutoAssignToEdgeRuleChain($event, item);
+                    setDefaultEdgeRuleChain($event, item);
                 },
-                name: function() { return $translate.instant('rulechain.set-auto-assign-to-edge') },
+                name: function() { return $translate.instant('rulechain.set-default-edge') },
-                details: function() { return $translate.instant('rulechain.set-auto-assign-to-edge') },
+                details: function() { return $translate.instant('rulechain.set-default-edge') },
                 icon: "bookmark_outline",
                 isEnabled: isNonDefaultEdgeRuleChain
             });
 
             ruleChainActionsList.push({
                 onAction: function ($event, item) {
-                    removeDefaultEdgeRuleChain($event, item);
+                    unsetAutoAssignToEdgeRuleChain($event, item);
                 },
-                name: function() { return $translate.instant('rulechain.remove-auto-assign-to-edge') },
+                name: function() { return $translate.instant('rulechain.remove-default-edge') },
-                details: function() { return $translate.instant('rulechain.remove-auto-assign-to-edge') },
+                details: function() { return $translate.instant('rulechain.remove-default-edge') },
                 icon: "bookmark",
                 isEnabled: isDefaultEdgeRuleChain
             });
 
             ruleChainActionsList.push({
                 onAction: function ($event, item) {
-                    setDefaultRootEdgeRuleChain($event, item);
+                    setEdgeTemplateRootRuleChain($event, item);
                 },
                 name: function() { return $translate.instant('rulechain.set-default-root-edge') },
                 details: function() { return $translate.instant('rulechain.set-default-root-edge') },
@@ -339,7 +339,7 @@ export default function RuleChainsController(ruleChainService, userService, impo
 
     function mapRuleChainsWithDefaultEdges(ruleChains) {
         var deferred = $q.defer();
-        ruleChainService.getDefaultEdgeRuleChains(null).then(
+        ruleChainService.getAutoAssignToEdgeRuleChains(null).then(
             function success(response) {
                 let defaultEdgeRuleChainIds = [];
                 response.map(function (ruleChain) {
@@ -471,17 +471,17 @@ export default function RuleChainsController(ruleChainService, userService, impo
         });
     }
 
-    function setAutoAssignToEdgeRuleChain($event, ruleChain) {
+    function setDefaultEdgeRuleChain($event, ruleChain) {
         $event.stopPropagation();
         var confirm = $mdDialog.confirm()
             .targetEvent($event)
-            .title($translate.instant('rulechain.set-auto-assign-to-edge-title', {ruleChainName: ruleChain.name}))
+            .title($translate.instant('rulechain.set-default-edge-title', {ruleChainName: ruleChain.name}))
-            .htmlContent($translate.instant('rulechain.set-auto-assign-to-edge-text'))
+            .htmlContent($translate.instant('rulechain.set-default-edge-text'))
-            .ariaLabel($translate.instant('rulechain.set-auto-assign-to-edge'))
+            .ariaLabel($translate.instant('rulechain.set-default-edge'))
             .cancel($translate.instant('action.no'))
             .ok($translate.instant('action.yes'));
         $mdDialog.show(confirm).then(function () {
-            ruleChainService.addDefaultEdgeRuleChain(ruleChain.id.id).then(
+            ruleChainService.setAutoAssignToEdgeRuleChain(ruleChain.id.id).then(
                     () => {
                         vm.grid.refreshList();
                     }
@@ -489,17 +489,17 @@ export default function RuleChainsController(ruleChainService, userService, impo
         });
     }
 
-    function removeDefaultEdgeRuleChain($event, ruleChain) {
+    function unsetAutoAssignToEdgeRuleChain($event, ruleChain) {
         $event.stopPropagation();
         var confirm = $mdDialog.confirm()
             .targetEvent($event)
-            .title($translate.instant('rulechain.remove-auto-assign-to-edge-title', {ruleChainName: ruleChain.name}))
+            .title($translate.instant('rulechain.remove-default-edge-title', {ruleChainName: ruleChain.name}))
-            .htmlContent($translate.instant('rulechain.remove-auto-assign-to-edge-text'))
+            .htmlContent($translate.instant('rulechain.remove-default-edge-text'))
-            .ariaLabel($translate.instant('rulechain.remove-auto-assign-to-edge'))
+            .ariaLabel($translate.instant('rulechain.remove-default-edge'))
             .cancel($translate.instant('action.no'))
             .ok($translate.instant('action.yes'));
         $mdDialog.show(confirm).then(function () {
-            ruleChainService.removeDefaultEdgeRuleChain(ruleChain.id.id).then(
+            ruleChainService.unsetAutoAssignToEdgeRuleChain(ruleChain.id.id).then(
                 () => {
                     vm.grid.refreshList();
                 }
@@ -507,7 +507,7 @@ export default function RuleChainsController(ruleChainService, userService, impo
         });
     }
 
-    function setDefaultRootEdgeRuleChain($event, ruleChain) {
+    function setEdgeTemplateRootRuleChain($event, ruleChain) {
         $event.stopPropagation();
         var confirm = $mdDialog.confirm()
             .targetEvent($event)
@@ -517,7 +517,7 @@ export default function RuleChainsController(ruleChainService, userService, impo
             .cancel($translate.instant('action.no'))
             .ok($translate.instant('action.yes'));
         $mdDialog.show(confirm).then(function () {
-            ruleChainService.setDefaultRootEdgeRuleChain(ruleChain.id.id).then(
+            ruleChainService.setEdgeTemplateRootRuleChain(ruleChain.id.id).then(
                 () => {
                     vm.grid.refreshList();
                 }

ui/src/app/rulechain/rulechains.tpl.html

@@ -28,8 +28,8 @@
                      the-form="vm.grid.detailsForm"
                      rule-chains-scope="vm.ruleChainsScope"
                      edge="vm.edge"
-                     on-set-auto-assign-to-edge-rule-chain="vm.setAutoAssignToEdgeRuleChain(event, vm.grid.detailsConfig.currentItem)"
+                     on-set-default-edge-rule-chain="vm.setDefaultEdgeRuleChain(event, vm.grid.detailsConfig.currentItem)"
-                     on-remove-auto-assign-to-edge-rule-chain="vm.removeAutoAssignToEdgeRuleChain(event, vm.grid.detailsConfig.currentItem)"
+                     on-remove-default-edge-rule-chain="vm.unsetAutoAssignToEdgeRuleChain(event, vm.grid.detailsConfig.currentItem)"
                      on-set-root-rule-chain="vm.setRootRuleChain(event, vm.grid.detailsConfig.currentItem)"
                      on-export-rule-chain="vm.exportRuleChain(event, vm.grid.detailsConfig.currentItem)"
                      on-delete-rule-chain="vm.grid.deleteItem(event, vm.grid.detailsConfig.currentItem)">