Added EDGE backend support

@@ -89,6 +89,10 @@
             <artifactId>queue</artifactId>
             <artifactId>queue</artifactId>
         </dependency>
         </dependency>
         <dependency>
         <dependency>
+            <groupId>org.thingsboard.common</groupId>
+            <artifactId>edge-api</artifactId>
+        </dependency>
+        <dependency>
             <groupId>org.thingsboard</groupId>
             <groupId>org.thingsboard</groupId>
             <artifactId>dao</artifactId>
             <artifactId>dao</artifactId>
             <type>test-jar</type>
             <type>test-jar</type>

@@ -2,6 +2,7 @@
   "ruleChain": {
   "ruleChain": {
     "additionalInfo": null,
     "additionalInfo": null,
     "name": "Root Rule Chain",
     "name": "Root Rule Chain",
+    "type": "SYSTEM",
     "firstRuleNodeId": null,
     "firstRuleNodeId": null,
     "root": true,
     "root": true,
     "debugMode": false,
     "debugMode": false,

+--
+-- Copyright © 2016-2020 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+CREATE TABLE IF NOT EXISTS edge (
+    id varchar(31) NOT NULL CONSTRAINT edge_pkey PRIMARY KEY,
+    additional_info varchar,
+    customer_id varchar(31),
+    root_rule_chain_id varchar(31),
+    configuration varchar(10000000),
+    type varchar(255),
+    name varchar(255),
+    label varchar(255),
+    routing_key varchar(255),
+    secret varchar(255),
+    search_text varchar(255),
+    tenant_id varchar(31)
+);

@@ -56,6 +56,7 @@ import org.thingsboard.server.dao.cassandra.CassandraCluster;
 import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.dao.dashboard.DashboardService;
 import org.thingsboard.server.dao.dashboard.DashboardService;
 import org.thingsboard.server.dao.device.DeviceService;
 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.entityview.EntityViewService;
 import org.thingsboard.server.dao.event.EventService;
 import org.thingsboard.server.dao.event.EventService;
 import org.thingsboard.server.dao.nosql.CassandraBufferedRateExecutor;
 import org.thingsboard.server.dao.nosql.CassandraBufferedRateExecutor;
@@ -248,6 +249,11 @@ public class ActorSystemContext {
     @Getter
     @Getter
     private RuleChainTransactionService ruleChainTransactionService;
     private RuleChainTransactionService ruleChainTransactionService;
 
 
+    @Lazy
+    @Autowired
+    @Getter
+    private EdgeService edgeService;
+
     @Value("${cluster.partition_id}")
     @Value("${cluster.partition_id}")
     @Getter
     @Getter
     private long queuePartitionId;
     private long queuePartitionId;

@@ -60,6 +60,7 @@ import org.thingsboard.server.dao.cassandra.CassandraCluster;
 import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.dao.dashboard.DashboardService;
 import org.thingsboard.server.dao.dashboard.DashboardService;
 import org.thingsboard.server.dao.device.DeviceService;
 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.entityview.EntityViewService;
 import org.thingsboard.server.dao.nosql.CassandraStatementTask;
 import org.thingsboard.server.dao.nosql.CassandraStatementTask;
 import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.relation.RelationService;
@@ -185,15 +186,26 @@ class DefaultTbContext implements TbContext {
     }
     }
 
 
     public TbMsg alarmCreatedMsg(Alarm alarm, RuleNodeId ruleNodeId) {
     public TbMsg alarmCreatedMsg(Alarm alarm, RuleNodeId ruleNodeId) {
+        return alarmMsg(alarm, ruleNodeId, DataConstants.ENTITY_CREATED);
+    }
+
+    public TbMsg alarmUpdatedMsg(Alarm alarm, RuleNodeId ruleNodeId) {
+        return alarmMsg(alarm, ruleNodeId, DataConstants.ENTITY_UPDATED);
+    }
+
+    public TbMsg alarmClearedMsg(Alarm alarm, RuleNodeId ruleNodeId) {
+        return alarmMsg(alarm, ruleNodeId, DataConstants.ALARM_CLEAR);
+    }
+
+    private TbMsg alarmMsg(Alarm alarm, RuleNodeId ruleNodeId, String type) {
         try {
         try {
             ObjectNode entityNode = mapper.valueToTree(alarm);
             ObjectNode entityNode = mapper.valueToTree(alarm);
-            return new TbMsg(UUIDs.timeBased(), DataConstants.ENTITY_CREATED, alarm.getId(), getActionMetaData(ruleNodeId), mapper.writeValueAsString(entityNode), null, null, 0L);
+            return new TbMsg(UUIDs.timeBased(), type, alarm.getId(), getActionMetaData(ruleNodeId), mapper.writeValueAsString(entityNode), null, null, 0L);
         } catch (JsonProcessingException | IllegalArgumentException e) {
         } catch (JsonProcessingException | IllegalArgumentException e) {
-            throw new RuntimeException("Failed to process alarm created msg: " + e);
+            throw new RuntimeException("Failed to process alarm created, updated or cleared msg: " + e);
         }
         }
     }
     }
 
 
-
     @Override
     @Override
     public RuleNodeId getSelfId() {
     public RuleNodeId getSelfId() {
         return nodeCtx.getSelf().getId();
         return nodeCtx.getSelf().getId();
@@ -326,6 +338,11 @@ class DefaultTbContext implements TbContext {
     }
     }
 
 
     @Override
     @Override
+    public EdgeService getEdgeService() {
+        return mainCtx.getEdgeService();
+    }
+
+    @Override
     public EventLoopGroup getSharedEventLoop() {
     public EventLoopGroup getSharedEventLoop() {
         return mainCtx.getSharedEventLoopGroupService().getSharedEventLoopGroup();
         return mainCtx.getSharedEventLoopGroupService().getSharedEventLoopGroup();
     }
     }

@@ -24,10 +24,12 @@ import com.datastax.driver.core.utils.UUIDs;
 import java.util.Optional;
 import java.util.Optional;
 
 
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
+import com.google.common.util.concurrent.FutureCallback;
 import org.thingsboard.server.actors.ActorSystemContext;
 import org.thingsboard.server.actors.ActorSystemContext;
 import org.thingsboard.server.actors.device.DeviceActorToRuleEngineMsg;
 import org.thingsboard.server.actors.device.DeviceActorToRuleEngineMsg;
 import org.thingsboard.server.actors.service.DefaultActorService;
 import org.thingsboard.server.actors.service.DefaultActorService;
 import org.thingsboard.server.actors.shared.ComponentMsgProcessor;
 import org.thingsboard.server.actors.shared.ComponentMsgProcessor;
+import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.RuleChainId;
@@ -37,14 +39,17 @@ import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
 import org.thingsboard.server.common.data.plugin.ComponentLifecycleState;
 import org.thingsboard.server.common.data.plugin.ComponentLifecycleState;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.common.data.rule.RuleChain;
+import org.thingsboard.server.common.data.rule.RuleChainType;
 import org.thingsboard.server.common.data.rule.RuleNode;
 import org.thingsboard.server.common.data.rule.RuleNode;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.cluster.ClusterEventMsg;
 import org.thingsboard.server.common.msg.cluster.ClusterEventMsg;
 import org.thingsboard.server.common.msg.cluster.ServerAddress;
 import org.thingsboard.server.common.msg.cluster.ServerAddress;
 import org.thingsboard.server.common.msg.plugin.ComponentLifecycleMsg;
 import org.thingsboard.server.common.msg.plugin.ComponentLifecycleMsg;
 import org.thingsboard.server.common.msg.system.ServiceToRuleEngineMsg;
 import org.thingsboard.server.common.msg.system.ServiceToRuleEngineMsg;
+import org.thingsboard.server.dao.edge.EdgeService;
 import org.thingsboard.server.dao.rule.RuleChainService;
 import org.thingsboard.server.dao.rule.RuleChainService;
 
 
+import javax.annotation.Nullable;
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashMap;
@@ -65,6 +70,7 @@ public class RuleChainActorMessageProcessor extends ComponentMsgProcessor<RuleCh
     private final Map<RuleNodeId, RuleNodeCtx> nodeActors;
     private final Map<RuleNodeId, RuleNodeCtx> nodeActors;
     private final Map<RuleNodeId, List<RuleNodeRelation>> nodeRoutes;
     private final Map<RuleNodeId, List<RuleNodeRelation>> nodeRoutes;
     private final RuleChainService service;
     private final RuleChainService service;
+    private final EdgeService edgeService;
 
 
     private RuleNodeId firstId;
     private RuleNodeId firstId;
     private RuleNodeCtx firstNode;
     private RuleNodeCtx firstNode;
@@ -79,6 +85,7 @@ public class RuleChainActorMessageProcessor extends ComponentMsgProcessor<RuleCh
         this.nodeActors = new HashMap<>();
         this.nodeActors = new HashMap<>();
         this.nodeRoutes = new HashMap<>();
         this.nodeRoutes = new HashMap<>();
         this.service = systemContext.getRuleChainService();
         this.service = systemContext.getRuleChainService();
+        this.edgeService = systemContext.getEdgeService();
         this.ruleChainName = ruleChainId.toString();
         this.ruleChainName = ruleChainId.toString();
     }
     }
 
 
@@ -92,17 +99,19 @@ public class RuleChainActorMessageProcessor extends ComponentMsgProcessor<RuleCh
         if (!started) {
         if (!started) {
             RuleChain ruleChain = service.findRuleChainById(tenantId, entityId);
             RuleChain ruleChain = service.findRuleChainById(tenantId, entityId);
             if (ruleChain != null) {
             if (ruleChain != null) {
-                ruleChainName = ruleChain.getName();
-                List<RuleNode> ruleNodeList = service.getRuleChainNodes(tenantId, entityId);
-                log.trace("[{}][{}] Starting rule chain with {} nodes", tenantId, entityId, ruleNodeList.size());
-                // Creating and starting the actors;
-                for (RuleNode ruleNode : ruleNodeList) {
-                    log.trace("[{}][{}] Creating rule node [{}]: {}", entityId, ruleNode.getId(), ruleNode.getName(), ruleNode);
-                    ActorRef ruleNodeActor = createRuleNodeActor(context, ruleNode);
-                    nodeActors.put(ruleNode.getId(), new RuleNodeCtx(tenantId, self, ruleNodeActor, ruleNode));
+                if (ruleChain.getType().equals(RuleChainType.SYSTEM)) {
+                    ruleChainName = ruleChain.getName();
+                    List<RuleNode> ruleNodeList = service.getRuleChainNodes(tenantId, entityId);
+                    log.trace("[{}][{}] Starting rule chain with {} nodes", tenantId, entityId, ruleNodeList.size());
+                    // Creating and starting the actors;
+                    for (RuleNode ruleNode : ruleNodeList) {
+                        log.trace("[{}][{}] Creating rule node [{}]: {}", entityId, ruleNode.getId(), ruleNode.getName(), ruleNode);
+                        ActorRef ruleNodeActor = createRuleNodeActor(context, ruleNode);
+                        nodeActors.put(ruleNode.getId(), new RuleNodeCtx(tenantId, self, ruleNodeActor, ruleNode));
+                    }
+                    initRoutes(ruleChain, ruleNodeList);
+                    started = true;
                 }
                 }
-                initRoutes(ruleChain, ruleNodeList);
-                started = true;
             }
             }
         } else {
         } else {
             onUpdate(context);
             onUpdate(context);
@@ -113,31 +122,36 @@ public class RuleChainActorMessageProcessor extends ComponentMsgProcessor<RuleCh
     public void onUpdate(ActorContext context) {
     public void onUpdate(ActorContext context) {
         RuleChain ruleChain = service.findRuleChainById(tenantId, entityId);
         RuleChain ruleChain = service.findRuleChainById(tenantId, entityId);
         if (ruleChain != null) {
         if (ruleChain != null) {
-            ruleChainName = ruleChain.getName();
-            List<RuleNode> ruleNodeList = service.getRuleChainNodes(tenantId, entityId);
-            log.trace("[{}][{}] Updating rule chain with {} nodes", tenantId, entityId, ruleNodeList.size());
-            for (RuleNode ruleNode : ruleNodeList) {
-                RuleNodeCtx existing = nodeActors.get(ruleNode.getId());
-                if (existing == null) {
-                    log.trace("[{}][{}] Creating rule node [{}]: {}", entityId, ruleNode.getId(), ruleNode.getName(), ruleNode);
-                    ActorRef ruleNodeActor = createRuleNodeActor(context, ruleNode);
-                    nodeActors.put(ruleNode.getId(), new RuleNodeCtx(tenantId, self, ruleNodeActor, ruleNode));
-                } else {
-                    log.trace("[{}][{}] Updating rule node [{}]: {}", entityId, ruleNode.getId(), ruleNode.getName(), ruleNode);
-                    existing.setSelf(ruleNode);
-                    existing.getSelfActor().tell(new ComponentLifecycleMsg(tenantId, existing.getSelf().getId(), ComponentLifecycleEvent.UPDATED), self);
+            if (ruleChain.getType().equals(RuleChainType.SYSTEM)) {
+                ruleChainName = ruleChain.getName();
+                List<RuleNode> ruleNodeList = service.getRuleChainNodes(tenantId, entityId);
+                log.trace("[{}][{}] Updating rule chain with {} nodes", tenantId, entityId, ruleNodeList.size());
+                for (RuleNode ruleNode : ruleNodeList) {
+                    RuleNodeCtx existing = nodeActors.get(ruleNode.getId());
+                    if (existing == null) {
+                        log.trace("[{}][{}] Creating rule node [{}]: {}", entityId, ruleNode.getId(), ruleNode.getName(), ruleNode);
+                        ActorRef ruleNodeActor = createRuleNodeActor(context, ruleNode);
+                        nodeActors.put(ruleNode.getId(), new RuleNodeCtx(tenantId, self, ruleNodeActor, ruleNode));
+                    } else {
+                        log.trace("[{}][{}] Updating rule node [{}]: {}", entityId, ruleNode.getId(), ruleNode.getName(), ruleNode);
+                        existing.setSelf(ruleNode);
+                        existing.getSelfActor().tell(new ComponentLifecycleMsg(tenantId, existing.getSelf().getId(), ComponentLifecycleEvent.UPDATED), self);
+                    }
                 }
                 }
-            }
 
 
-            Set<RuleNodeId> existingNodes = ruleNodeList.stream().map(RuleNode::getId).collect(Collectors.toSet());
-            List<RuleNodeId> removedRules = nodeActors.keySet().stream().filter(node -> !existingNodes.contains(node)).collect(Collectors.toList());
-            removedRules.forEach(ruleNodeId -> {
-                log.trace("[{}][{}] Removing rule node [{}]", tenantId, entityId, ruleNodeId);
-                RuleNodeCtx removed = nodeActors.remove(ruleNodeId);
-                removed.getSelfActor().tell(new ComponentLifecycleMsg(tenantId, removed.getSelf().getId(), ComponentLifecycleEvent.DELETED), self);
-            });
+                Set<RuleNodeId> existingNodes = ruleNodeList.stream().map(RuleNode::getId).collect(Collectors.toSet());
+                List<RuleNodeId> removedRules = nodeActors.keySet().stream().filter(node -> !existingNodes.contains(node)).collect(Collectors.toList());
+                removedRules.forEach(ruleNodeId -> {
+                    log.trace("[{}][{}] Removing rule node [{}]", tenantId, entityId, ruleNodeId);
+                    RuleNodeCtx removed = nodeActors.remove(ruleNodeId);
+                    removed.getSelfActor().tell(new ComponentLifecycleMsg(tenantId, removed.getSelf().getId(), ComponentLifecycleEvent.DELETED), self);
+                });
 
 
-            initRoutes(ruleChain, ruleNodeList);
+                initRoutes(ruleChain, ruleNodeList);
+
+            }  else if (ruleChain.getType().equals(RuleChainType.EDGE)){
+                stop(context);
+            }
         }
         }
     }
     }
 
 
@@ -326,6 +340,30 @@ public class RuleChainActorMessageProcessor extends ComponentMsgProcessor<RuleCh
         if (nodeCtx != null) {
         if (nodeCtx != null) {
             nodeCtx.getSelfActor().tell(new RuleChainToRuleNodeMsg(new DefaultTbContext(systemContext, nodeCtx), msg, fromRelationType), self);
             nodeCtx.getSelfActor().tell(new RuleChainToRuleNodeMsg(new DefaultTbContext(systemContext, nodeCtx), msg, fromRelationType), self);
         }
         }
+        pushUpdatesToEdges(msg);
+    }
+
+    private void pushUpdatesToEdges(TbMsg msg) {
+        switch (msg.getType()) {
+            case DataConstants.ENTITY_CREATED:
+            case DataConstants.ENTITY_UPDATED:
+            case DataConstants.ENTITY_DELETED:
+            case DataConstants.ENTITY_ASSIGNED_TO_EDGE:
+            case DataConstants.ENTITY_UNASSIGNED_FROM_EDGE:
+            case DataConstants.ALARM_ACK:
+            case DataConstants.ALARM_CLEAR:
+                edgeService.pushEventToEdge(tenantId, msg, new FutureCallback<Void>() {
+                    @Override
+                    public void onSuccess(@Nullable Void aVoid) {
+                        log.debug("Event saved successfully!");
+                    }
+
+                    @Override
+                    public void onFailure(Throwable t) {
+                        log.debug("Failure during event save", t);
+                    }
+                });
+        }
     }
     }
 
 
     private TbMsg enrichWithRuleChainId(TbMsg tbMsg) {
     private TbMsg enrichWithRuleChainId(TbMsg tbMsg) {

@@ -39,6 +39,7 @@ 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.plugin.ComponentLifecycleEvent;
 import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
 import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.common.data.rule.RuleChain;
+import org.thingsboard.server.common.data.rule.RuleChainType;
 import org.thingsboard.server.common.msg.TbActorMsg;
 import org.thingsboard.server.common.msg.TbActorMsg;
 import org.thingsboard.server.common.msg.aware.DeviceAwareMsg;
 import org.thingsboard.server.common.msg.aware.DeviceAwareMsg;
 import org.thingsboard.server.common.msg.aware.RuleChainAwareMsg;
 import org.thingsboard.server.common.msg.aware.RuleChainAwareMsg;
@@ -139,11 +140,18 @@ public class TenantActor extends RuleChainManagerActor {
     }
     }
 
 
     private void onComponentLifecycleMsg(ComponentLifecycleMsg msg) {
     private void onComponentLifecycleMsg(ComponentLifecycleMsg msg) {
+        RuleChain ruleChain = null;
+        if (msg.getEntityId().getEntityType() == EntityType.RULE_CHAIN) {
+            ruleChain = systemContext.getRuleChainService().findRuleChainById(tenantId, new RuleChainId(msg.getEntityId().getId()));
+            if (ruleChain !=null && !RuleChainType.SYSTEM.equals(ruleChain.getType())) {
+                log.debug("[{}] Non SYSTEM rule chains are ignored and not started. Current rule chain type [{}]", tenantId, ruleChain.getType());
+                return;
+            }
+        }
+
         ActorRef target = getEntityActorRef(msg.getEntityId());
         ActorRef target = getEntityActorRef(msg.getEntityId());
         if (target != null) {
         if (target != null) {
-            if (msg.getEntityId().getEntityType() == EntityType.RULE_CHAIN) {
-                RuleChain ruleChain = systemContext.getRuleChainService().
-                        findRuleChainById(tenantId, new RuleChainId(msg.getEntityId().getId()));
+            if (msg.getEntityId().getEntityType() == EntityType.RULE_CHAIN && ruleChain != null) {
                 ruleChainManager.visit(ruleChain, target);
                 ruleChainManager.visit(ruleChain, target);
             }
             }
             target.tell(msg, ActorRef.noSender());
             target.tell(msg, ActorRef.noSender());

@@ -33,10 +33,12 @@ import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.asset.AssetInfo;
 import org.thingsboard.server.common.data.asset.AssetInfo;
 import org.thingsboard.server.common.data.asset.AssetSearchQuery;
 import org.thingsboard.server.common.data.asset.AssetSearchQuery;
 import org.thingsboard.server.common.data.audit.ActionType;
 import org.thingsboard.server.common.data.audit.ActionType;
+import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.exception.ThingsboardErrorCode;
 import org.thingsboard.server.common.data.exception.ThingsboardErrorCode;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
@@ -51,6 +53,8 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
+import static org.thingsboard.server.controller.EdgeController.EDGE_ID;
+
 @RestController
 @RestController
 @RequestMapping("/api")
 @RequestMapping("/api")
 public class AssetController extends BaseController {
 public class AssetController extends BaseController {
@@ -396,4 +400,93 @@ public class AssetController extends BaseController {
             throw handleException(e);
             throw handleException(e);
         }
         }
     }
     }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/asset/{assetId}", method = RequestMethod.POST)
+    @ResponseBody
+    public Asset assignAssetToEdge(@PathVariable(EDGE_ID) String strEdgeId,
+                                   @PathVariable(ASSET_ID) String strAssetId) throws ThingsboardException {
+        checkParameter(EDGE_ID, strEdgeId);
+        checkParameter(ASSET_ID, strAssetId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.READ);
+
+            AssetId assetId = new AssetId(toUUID(strAssetId));
+            checkAssetId(assetId, Operation.ASSIGN_TO_EDGE);
+
+            Asset savedAsset = checkNotNull(assetService.assignAssetToEdge(getTenantId(), assetId, edgeId));
+
+            logEntityAction(assetId, savedAsset,
+                    savedAsset.getCustomerId(),
+                    ActionType.ASSIGNED_TO_EDGE, null, strAssetId, strEdgeId, edge.getName());
+
+            return  savedAsset;
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.ASSET), null,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, e, strAssetId, strEdgeId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/asset/{assetId}", method = RequestMethod.DELETE)
+    @ResponseBody
+    public Asset unassignAssetFromEdge(@PathVariable(ASSET_ID) String strAssetId) throws ThingsboardException {
+        checkParameter(ASSET_ID, strAssetId);
+        try {
+            AssetId assetId = new AssetId(toUUID(strAssetId));
+            Asset asset = checkAssetId(assetId, Operation.UNASSIGN_FROM_EDGE);
+            if (asset.getEdgeId() == null || asset.getEdgeId().getId().equals(ModelConstants.NULL_UUID)) {
+                throw new IncorrectParameterException("Asset isn't assigned to any edge!");
+            }
+
+            Edge edge = checkEdgeId(asset.getEdgeId(), Operation.READ);
+
+            Asset savedAsset = checkNotNull(assetService.unassignAssetFromEdge(getTenantId(), assetId));
+
+            logEntityAction(assetId, asset,
+                    asset.getCustomerId(),
+                    ActionType.UNASSIGNED_FROM_EDGE, null, strAssetId, edge.getId().toString(), edge.getName());
+
+            return savedAsset;
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.ASSET), null,
+                    null,
+                    ActionType.UNASSIGNED_FROM_EDGE, e, strAssetId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/assets", params = {"pageSize", "page"}, method = RequestMethod.GET)
+    @ResponseBody
+    public PageData<Asset> getEdgeAssets(
+            @PathVariable("edgeId") String strEdgeId,
+            @RequestParam int pageSize,
+            @RequestParam int page,
+            @RequestParam(required = false) String type,
+            @RequestParam(required = false) String textSearch,
+            @RequestParam(required = false) String sortProperty,
+            @RequestParam(required = false) String sortOrder) throws ThingsboardException {
+        checkParameter("edgeId", strEdgeId);
+        try {
+            TenantId tenantId = getCurrentUser().getTenantId();
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            checkEdgeId(edgeId, Operation.READ);
+            PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
+            if (type != null && type.trim().length()>0) {
+                return checkNotNull(assetService.findAssetsByTenantIdAndEdgeIdAndType(tenantId, edgeId, type, pageLink));
+            } else {
+                return checkNotNull(assetService.findAssetsByTenantIdAndEdgeId(tenantId, edgeId, pageLink));
+            }
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
 }
 }

@@ -35,12 +35,14 @@ import org.thingsboard.server.common.data.alarm.AlarmInfo;
 import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.asset.AssetInfo;
 import org.thingsboard.server.common.data.asset.AssetInfo;
 import org.thingsboard.server.common.data.audit.ActionType;
 import org.thingsboard.server.common.data.audit.ActionType;
+import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.exception.ThingsboardErrorCode;
 import org.thingsboard.server.common.data.exception.ThingsboardErrorCode;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DashboardId;
 import org.thingsboard.server.common.data.id.DashboardId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
 import org.thingsboard.server.common.data.id.EntityViewId;
 import org.thingsboard.server.common.data.id.EntityViewId;
@@ -75,6 +77,7 @@ import org.thingsboard.server.dao.dashboard.DashboardService;
 import org.thingsboard.server.dao.device.ClaimDevicesService;
 import org.thingsboard.server.dao.device.ClaimDevicesService;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
 import org.thingsboard.server.dao.device.DeviceService;
 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.entityview.EntityViewService;
 import org.thingsboard.server.dao.exception.DataValidationException;
 import org.thingsboard.server.dao.exception.DataValidationException;
 import org.thingsboard.server.dao.exception.IncorrectParameterException;
 import org.thingsboard.server.dao.exception.IncorrectParameterException;
@@ -178,6 +181,9 @@ public abstract class BaseController {
     @Autowired
     @Autowired
     protected ClaimDevicesService claimDevicesService;
     protected ClaimDevicesService claimDevicesService;
 
 
+    @Autowired
+    protected EdgeService edgeService;
+
     @Value("${server.log_controller_error_stack_trace}")
     @Value("${server.log_controller_error_stack_trace}")
     @Getter
     @Getter
     private boolean logControllerErrorStackTrace;
     private boolean logControllerErrorStackTrace;
@@ -353,6 +359,9 @@ public abstract class BaseController {
                 case ENTITY_VIEW:
                 case ENTITY_VIEW:
                     checkEntityViewId(new EntityViewId(entityId.getId()), operation);
                     checkEntityViewId(new EntityViewId(entityId.getId()), operation);
                     return;
                     return;
+                case EDGE:
+                    checkEdgeId(new EdgeId(entityId.getId()), operation);
+                    return;
                 default:
                 default:
                     throw new IllegalArgumentException("Unsupported entity type: " + entityId.getEntityType());
                     throw new IllegalArgumentException("Unsupported entity type: " + entityId.getEntityType());
             }
             }
@@ -548,6 +557,17 @@ public abstract class BaseController {
         return ruleNode;
         return ruleNode;
     }
     }
 
 
+    Edge checkEdgeId(EdgeId edgeId, Operation operation) throws ThingsboardException {
+        try {
+            validateId(edgeId, "Incorrect edgeId " + edgeId);
+            Edge edge = edgeService.findEdgeById(getTenantId(), edgeId);
+            checkNotNull(edge);
+            accessControlService.checkPermission(getCurrentUser(), Resource.EDGE, operation, edgeId, edge);
+            return edge;
+        } catch (Exception e) {
+            throw handleException(e, false);
+        }
+    }
 
 
     protected String constructBaseUrl(HttpServletRequest request) {
     protected String constructBaseUrl(HttpServletRequest request) {
         String scheme = request.getScheme();
         String scheme = request.getScheme();
@@ -637,6 +657,12 @@ public abstract class BaseController {
             case ALARM_CLEAR:
             case ALARM_CLEAR:
                 msgType = DataConstants.ALARM_CLEAR;
                 msgType = DataConstants.ALARM_CLEAR;
                 break;
                 break;
+            case ASSIGNED_TO_EDGE:
+                msgType = DataConstants.ENTITY_ASSIGNED_TO_EDGE;
+                break;
+            case UNASSIGNED_FROM_EDGE:
+                msgType = DataConstants.ENTITY_UNASSIGNED_FROM_EDGE;
+                break;
         }
         }
         if (!StringUtils.isEmpty(msgType)) {
         if (!StringUtils.isEmpty(msgType)) {
             try {
             try {
@@ -656,6 +682,12 @@ public abstract class BaseController {
                     String strCustomerName = extractParameter(String.class, 2, additionalInfo);
                     String strCustomerName = extractParameter(String.class, 2, additionalInfo);
                     metaData.putValue("unassignedCustomerId", strCustomerId);
                     metaData.putValue("unassignedCustomerId", strCustomerId);
                     metaData.putValue("unassignedCustomerName", strCustomerName);
                     metaData.putValue("unassignedCustomerName", strCustomerName);
+                } else if (actionType == ActionType.ASSIGNED_TO_EDGE) {
+                    String strEdgeId = extractParameter(String.class, 1, additionalInfo);
+                    metaData.putValue("assignedEdgeId", strEdgeId);
+                } else if (actionType == ActionType.UNASSIGNED_FROM_EDGE) {
+                    String strEdgeId = extractParameter(String.class, 1, additionalInfo);
+                    metaData.putValue("unassignedEdgeId", strEdgeId);
                 }
                 }
                 ObjectNode entityNode;
                 ObjectNode entityNode;
                 if (entity != null) {
                 if (entity != null) {

@@ -32,10 +32,13 @@ import org.thingsboard.server.common.data.Dashboard;
 import org.thingsboard.server.common.data.DashboardInfo;
 import org.thingsboard.server.common.data.DashboardInfo;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.ShortCustomerInfo;
 import org.thingsboard.server.common.data.ShortCustomerInfo;
+import org.thingsboard.server.common.data.ShortEdgeInfo;
 import org.thingsboard.server.common.data.audit.ActionType;
 import org.thingsboard.server.common.data.audit.ActionType;
+import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DashboardId;
 import org.thingsboard.server.common.data.id.DashboardId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
@@ -474,4 +477,241 @@ public class DashboardController extends BaseController {
             throw handleException(e);
             throw handleException(e);
         }
         }
     }
     }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/dashboard/{dashboardId}", method = RequestMethod.POST)
+    @ResponseBody
+    public Dashboard assignDashboardToEdge(@PathVariable("edgeId") String strEdgeId,
+                                           @PathVariable(DASHBOARD_ID) String strDashboardId) throws ThingsboardException {
+        checkParameter("edgeId", strEdgeId);
+        checkParameter(DASHBOARD_ID, strDashboardId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.READ);
+
+            DashboardId dashboardId = new DashboardId(toUUID(strDashboardId));
+            checkDashboardId(dashboardId, Operation.ASSIGN_TO_EDGE);
+
+            Dashboard savedDashboard = checkNotNull(dashboardService.assignDashboardToEdge(getCurrentUser().getTenantId(), dashboardId, edgeId));
+
+            logEntityAction(dashboardId, savedDashboard,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, null, strDashboardId, strEdgeId, edge.getName());
+
+
+            return savedDashboard;
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.DASHBOARD), null,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, e, strDashboardId, strEdgeId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/dashboard/{dashboardId}", method = RequestMethod.DELETE)
+    @ResponseBody
+    public Dashboard unassignDashboardFromEdge(@PathVariable("edgeId") String strEdgeId,
+                                               @PathVariable(DASHBOARD_ID) String strDashboardId) throws ThingsboardException {
+        checkParameter("edgeId", strEdgeId);
+        checkParameter(DASHBOARD_ID, strDashboardId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.READ);
+            DashboardId dashboardId = new DashboardId(toUUID(strDashboardId));
+            Dashboard dashboard = checkDashboardId(dashboardId, Operation.UNASSIGN_FROM_EDGE);
+
+            Dashboard savedDashboard = checkNotNull(dashboardService.unassignDashboardFromEdge(getCurrentUser().getTenantId(), dashboardId, edgeId));
+
+            logEntityAction(dashboardId, dashboard,
+                    null,
+                    ActionType.UNASSIGNED_FROM_EDGE, null, strDashboardId, edge.getId().toString(), edge.getName());
+
+            return savedDashboard;
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.DASHBOARD), null,
+                    null,
+                    ActionType.UNASSIGNED_FROM_EDGE, e, strDashboardId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/dashboard/{dashboardId}/edges", method = RequestMethod.POST)
+    @ResponseBody
+    public Dashboard updateDashboardEdges(@PathVariable(DASHBOARD_ID) String strDashboardId,
+                                          @RequestBody String[] strEdgeIds) throws ThingsboardException {
+        checkParameter(DASHBOARD_ID, strDashboardId);
+        try {
+            DashboardId dashboardId = new DashboardId(toUUID(strDashboardId));
+            Dashboard dashboard = checkDashboardId(dashboardId, Operation.ASSIGN_TO_EDGE);
+
+            Set<EdgeId> edgeIds = new HashSet<>();
+            if (strEdgeIds != null) {
+                for (String strEdgeId : strEdgeIds) {
+                    edgeIds.add(new EdgeId(toUUID(strEdgeId)));
+                }
+            }
+
+            Set<EdgeId> addedEdgeIds = new HashSet<>();
+            Set<EdgeId> removedEdgeIds = new HashSet<>();
+            for (EdgeId edgeId : edgeIds) {
+                if (!dashboard.isAssignedToEdge(edgeId)) {
+                    addedEdgeIds.add(edgeId);
+                }
+            }
+
+            Set<ShortEdgeInfo> assignedEdges = dashboard.getAssignedEdges();
+            if (assignedEdges != null) {
+                for (ShortEdgeInfo edgeInfo : assignedEdges) {
+                    if (!edgeIds.contains(edgeInfo.getEdgeId())) {
+                        removedEdgeIds.add(edgeInfo.getEdgeId());
+                    }
+                }
+            }
+
+            if (addedEdgeIds.isEmpty() && removedEdgeIds.isEmpty()) {
+                return dashboard;
+            } else {
+                Dashboard savedDashboard = null;
+                for (EdgeId edgeId : addedEdgeIds) {
+                    savedDashboard = checkNotNull(dashboardService.assignDashboardToEdge(getCurrentUser().getTenantId(), dashboardId, edgeId));
+                    ShortEdgeInfo edgeInfo = savedDashboard.getAssignedEdgeInfo(edgeId);
+                    logEntityAction(dashboardId, savedDashboard,
+                            null,
+                            ActionType.ASSIGNED_TO_EDGE, null, strDashboardId, edgeId.toString(), edgeInfo.getTitle());
+                }
+                for (EdgeId edgeId : removedEdgeIds) {
+                    ShortEdgeInfo edgeInfo = dashboard.getAssignedEdgeInfo(edgeId);
+                    savedDashboard = checkNotNull(dashboardService.unassignDashboardFromEdge(getCurrentUser().getTenantId(), dashboardId, edgeId));
+                    logEntityAction(dashboardId, dashboard,
+                            null,
+                            ActionType.UNASSIGNED_FROM_EDGE, null, strDashboardId, edgeId.toString(), edgeInfo.getTitle());
+
+                }
+                return savedDashboard;
+            }
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.DASHBOARD), null,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, e, strDashboardId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/dashboard/{dashboardId}/edges/add", method = RequestMethod.POST)
+    @ResponseBody
+    public Dashboard addDashboardEdges(@PathVariable(DASHBOARD_ID) String strDashboardId,
+                                       @RequestBody String[] strEdgeIds) throws ThingsboardException {
+        checkParameter(DASHBOARD_ID, strDashboardId);
+        try {
+            DashboardId dashboardId = new DashboardId(toUUID(strDashboardId));
+            Dashboard dashboard = checkDashboardId(dashboardId, Operation.ASSIGN_TO_EDGE);
+
+            Set<EdgeId> edgeIds = new HashSet<>();
+            if (strEdgeIds != null) {
+                for (String strEdgeId : strEdgeIds) {
+                    EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+                    if (!dashboard.isAssignedToEdge(edgeId)) {
+                        edgeIds.add(edgeId);
+                    }
+                }
+            }
+
+            if (edgeIds.isEmpty()) {
+                return dashboard;
+            } else {
+                Dashboard savedDashboard = null;
+                for (EdgeId edgeId : edgeIds) {
+                    savedDashboard = checkNotNull(dashboardService.assignDashboardToEdge(getCurrentUser().getTenantId(), dashboardId, edgeId));
+                    ShortEdgeInfo edgeInfo = savedDashboard.getAssignedEdgeInfo(edgeId);
+                    logEntityAction(dashboardId, savedDashboard,
+                            null,
+                            ActionType.ASSIGNED_TO_EDGE, null, strDashboardId, edgeId.toString(), edgeInfo.getTitle());
+                }
+                return savedDashboard;
+            }
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.DASHBOARD), null,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, e, strDashboardId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/dashboard/{dashboardId}/edges/remove", method = RequestMethod.POST)
+    @ResponseBody
+    public Dashboard removeDashboardEdges(@PathVariable(DASHBOARD_ID) String strDashboardId,
+                                          @RequestBody String[] strEdgeIds) throws ThingsboardException {
+        checkParameter(DASHBOARD_ID, strDashboardId);
+        try {
+            DashboardId dashboardId = new DashboardId(toUUID(strDashboardId));
+            Dashboard dashboard = checkDashboardId(dashboardId, Operation.UNASSIGN_FROM_EDGE);
+
+            Set<EdgeId> edgeIds = new HashSet<>();
+            if (strEdgeIds != null) {
+                for (String strEdgeId : strEdgeIds) {
+                    EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+                    if (dashboard.isAssignedToEdge(edgeId)) {
+                        edgeIds.add(edgeId);
+                    }
+                }
+            }
+
+            if (edgeIds.isEmpty()) {
+                return dashboard;
+            } else {
+                Dashboard savedDashboard = null;
+                for (EdgeId edgeId : edgeIds) {
+                    ShortEdgeInfo edgeInfo = dashboard.getAssignedEdgeInfo(edgeId);
+                    savedDashboard = checkNotNull(dashboardService.unassignDashboardFromEdge(getCurrentUser().getTenantId(), dashboardId, edgeId));
+                    logEntityAction(dashboardId, dashboard,
+                            null,
+                            ActionType.UNASSIGNED_FROM_EDGE, null, strDashboardId, edgeId.toString(), edgeInfo.getTitle());
+
+                }
+                return savedDashboard;
+            }
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.DASHBOARD), null,
+                    null,
+                    ActionType.UNASSIGNED_FROM_EDGE, e, strDashboardId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/dashboards", params = {"pageSize", "page"}, method = RequestMethod.GET)
+    @ResponseBody
+    public PageData<DashboardInfo> getEdgeDashboards(
+            @PathVariable("edgeId") String strEdgeId,
+            @RequestParam int pageSize,
+            @RequestParam int page,
+            @RequestParam(required = false) String type,
+            @RequestParam(required = false) String textSearch,
+            @RequestParam(required = false) String sortProperty,
+            @RequestParam(required = false) String sortOrder) throws ThingsboardException {
+        checkParameter("edgeId", strEdgeId);
+        try {
+            TenantId tenantId = getCurrentUser().getTenantId();
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            checkEdgeId(edgeId, Operation.READ);
+            PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
+            return checkNotNull(dashboardService.findDashboardsByTenantIdAndEdgeId(tenantId, edgeId, pageLink));
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
 }
 }

@@ -33,9 +33,11 @@ import org.springframework.web.context.request.async.DeferredResult;
 import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.audit.ActionType;
 import org.thingsboard.server.common.data.audit.ActionType;
 import org.thingsboard.server.common.data.device.DeviceSearchQuery;
 import org.thingsboard.server.common.data.device.DeviceSearchQuery;
+import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
@@ -55,6 +57,8 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
+import static org.thingsboard.server.controller.EdgeController.EDGE_ID;
+
 @RestController
 @RestController
 @RequestMapping("/api")
 @RequestMapping("/api")
 public class DeviceController extends BaseController {
 public class DeviceController extends BaseController {
@@ -541,4 +545,88 @@ public class DeviceController extends BaseController {
         }
         }
         return DataConstants.DEFAULT_SECRET_KEY;
         return DataConstants.DEFAULT_SECRET_KEY;
     }
     }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/device/{deviceId}", method = RequestMethod.POST)
+    @ResponseBody
+    public Device assignDeviceToEdge(@PathVariable(EDGE_ID) String strEdgeId,
+                                     @PathVariable(DEVICE_ID) String strDeviceId) throws ThingsboardException {
+        checkParameter(EDGE_ID, strEdgeId);
+        checkParameter(DEVICE_ID, strDeviceId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.READ);
+
+            DeviceId deviceId = new DeviceId(toUUID(strDeviceId));
+            checkDeviceId(deviceId, Operation.ASSIGN_TO_EDGE);
+
+            Device savedDevice = checkNotNull(deviceService.assignDeviceToEdge(getCurrentUser().getTenantId(), deviceId, edgeId));
+
+            logEntityAction(deviceId, savedDevice,
+                    savedDevice.getCustomerId(),
+                    ActionType.ASSIGNED_TO_EDGE, null, strDeviceId, strEdgeId, edge.getName());
+
+            return savedDevice;
+        } catch (Exception e) {
+            logEntityAction(emptyId(EntityType.DEVICE), null,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, e, strDeviceId, strEdgeId);
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/device/{deviceId}", method = RequestMethod.DELETE)
+    @ResponseBody
+    public Device unassignDeviceFromEdge(@PathVariable(DEVICE_ID) String strDeviceId) throws ThingsboardException {
+        checkParameter(DEVICE_ID, strDeviceId);
+        try {
+            DeviceId deviceId = new DeviceId(toUUID(strDeviceId));
+            Device device = checkDeviceId(deviceId, Operation.UNASSIGN_FROM_EDGE);
+            if (device.getEdgeId() == null || device.getEdgeId().getId().equals(ModelConstants.NULL_UUID)) {
+                throw new IncorrectParameterException("Device isn't assigned to any edge!");
+            }
+            Edge edge = checkEdgeId(device.getEdgeId(), Operation.READ);
+
+            Device savedDevice = checkNotNull(deviceService.unassignDeviceFromEdge(getCurrentUser().getTenantId(), deviceId));
+
+            logEntityAction(deviceId, device,
+                    device.getCustomerId(),
+                    ActionType.UNASSIGNED_FROM_EDGE, null, strDeviceId, edge.getId().toString(), edge.getName());
+
+            return savedDevice;
+        } catch (Exception e) {
+            logEntityAction(emptyId(EntityType.DEVICE), null,
+                    null,
+                    ActionType.UNASSIGNED_FROM_EDGE, e, strDeviceId);
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/devices", params = {"pageSize", "page"}, method = RequestMethod.GET)
+    @ResponseBody
+    public PageData<Device> getEdgeDevices(
+            @PathVariable("edgeId") String strEdgeId,
+            @RequestParam int pageSize,
+            @RequestParam int page,
+            @RequestParam(required = false) String type,
+            @RequestParam(required = false) String textSearch,
+            @RequestParam(required = false) String sortProperty,
+            @RequestParam(required = false) String sortOrder) throws ThingsboardException {
+        checkParameter("edgeId", strEdgeId);
+        try {
+            TenantId tenantId = getCurrentUser().getTenantId();
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            checkEdgeId(edgeId, Operation.READ);
+            PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
+            if (type != null && type.trim().length()>0) {
+                return checkNotNull(deviceService.findDevicesByTenantIdAndEdgeIdAndType(tenantId, edgeId, type, pageLink));
+            } else {
+                return checkNotNull(deviceService.findDevicesByTenantIdAndEdgeId(tenantId, edgeId, pageLink));
+            }
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.controller;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
+import org.thingsboard.server.common.data.Customer;
+import org.thingsboard.server.common.data.EntitySubtype;
+import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.audit.ActionType;
+import org.thingsboard.server.common.data.edge.Edge;
+import org.thingsboard.server.common.data.edge.EdgeSearchQuery;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.id.CustomerId;
+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.PageData;
+import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.rule.RuleChain;
+import org.thingsboard.server.dao.exception.IncorrectParameterException;
+import org.thingsboard.server.dao.model.ModelConstants;
+import org.thingsboard.server.service.security.model.SecurityUser;
+import org.thingsboard.server.service.security.permission.Operation;
+import org.thingsboard.server.service.security.permission.Resource;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/api")
+public class EdgeController extends BaseController {
+
+    public static final String EDGE_ID = "edgeId";
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}", method = RequestMethod.GET)
+    @ResponseBody
+    public Edge getEdgeById(@PathVariable(EDGE_ID) String strEdgeId) throws ThingsboardException {
+        checkParameter(EDGE_ID, strEdgeId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            return checkEdgeId(edgeId, Operation.READ);
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge", method = RequestMethod.POST)
+    @ResponseBody
+    public Edge saveEdge(@RequestBody Edge edge) throws ThingsboardException {
+        try {
+            TenantId tenantId = getCurrentUser().getTenantId();
+            edge.setTenantId(tenantId);
+            boolean created = edge.getId() == null;
+
+            Operation operation = created ? Operation.CREATE : Operation.WRITE;
+
+            accessControlService.checkPermission(getCurrentUser(), Resource.EDGE, operation,
+                    edge.getId(), edge);
+
+            Edge result = checkNotNull(edgeService.saveEdge(edge));
+
+            if (created) {
+                RuleChain rootTenantRuleChain = ruleChainService.getRootTenantRuleChain(tenantId);
+                ruleChainService.assignRuleChainToEdge(tenantId, rootTenantRuleChain.getId(), result.getId());
+                edgeService.setRootRuleChain(tenantId, result, rootTenantRuleChain.getId());
+            }
+
+            logEntityAction(result.getId(), result, null, created ? ActionType.ADDED : ActionType.UPDATED, null);
+            return result;
+        } catch (Exception e) {
+            logEntityAction(emptyId(EntityType.EDGE), edge,
+                    null, edge.getId() == null ? ActionType.ADDED : ActionType.UPDATED, e);
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}", method = RequestMethod.DELETE)
+    @ResponseStatus(value = HttpStatus.OK)
+    public void deleteEdge(@PathVariable(EDGE_ID) String strEdgeId) throws ThingsboardException {
+        checkParameter(EDGE_ID, strEdgeId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.DELETE);
+            edgeService.deleteEdge(getTenantId(), edgeId);
+
+            logEntityAction(edgeId, edge,
+                    null,
+                    ActionType.DELETED, null, strEdgeId);
+
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.EDGE),
+                    null,
+                    null,
+                    ActionType.DELETED, e, strEdgeId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edges", params = {"pageSize", "page"}, method = RequestMethod.GET)
+    @ResponseBody
+    public PageData<Edge> getEdges(@RequestParam int pageSize,
+                                   @RequestParam int page,
+                                   @RequestParam(required = false) String textSearch,
+                                   @RequestParam(required = false) String sortProperty,
+                                   @RequestParam(required = false) String sortOrder) throws ThingsboardException {
+        try {
+            PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
+            TenantId tenantId = getCurrentUser().getTenantId();
+            return checkNotNull(edgeService.findEdgesByTenantId(tenantId, pageLink));
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/customer/{customerId}/edge/{edgeId}", method = RequestMethod.POST)
+    @ResponseBody
+    public Edge assignEdgeToCustomer(@PathVariable("customerId") String strCustomerId,
+                                     @PathVariable(EDGE_ID) String strEdgeId) throws ThingsboardException {
+        checkParameter("customerId", strCustomerId);
+        checkParameter(EDGE_ID, strEdgeId);
+        try {
+            CustomerId customerId = new CustomerId(toUUID(strCustomerId));
+            Customer customer = checkCustomerId(customerId, Operation.READ);
+
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            checkEdgeId(edgeId, Operation.ASSIGN_TO_CUSTOMER);
+
+            Edge savedEdge = checkNotNull(edgeService.assignEdgeToCustomer(getCurrentUser().getTenantId(), edgeId, customerId));
+
+            logEntityAction(edgeId, savedEdge,
+                    savedEdge.getCustomerId(),
+                    ActionType.ASSIGNED_TO_CUSTOMER, null, strEdgeId, strCustomerId, customer.getName());
+
+            return savedEdge;
+        } catch (Exception e) {
+            logEntityAction(emptyId(EntityType.EDGE), null,
+                    null,
+                    ActionType.ASSIGNED_TO_CUSTOMER, e, strEdgeId, strCustomerId);
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/customer/edge/{edgeId}", method = RequestMethod.DELETE)
+    @ResponseBody
+    public Edge unassignEdgeFromCustomer(@PathVariable(EDGE_ID) String strEdgeId) throws ThingsboardException {
+        checkParameter(EDGE_ID, strEdgeId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.UNASSIGN_FROM_CUSTOMER);
+            if (edge.getCustomerId() == null || edge.getCustomerId().getId().equals(ModelConstants.NULL_UUID)) {
+                throw new IncorrectParameterException("Edge isn't assigned to any customer!");
+            }
+            Customer customer = checkCustomerId(edge.getCustomerId(), Operation.READ);
+
+            Edge savedEdge = checkNotNull(edgeService.unassignEdgeFromCustomer(getCurrentUser().getTenantId(), edgeId));
+
+            logEntityAction(edgeId, edge,
+                    edge.getCustomerId(),
+                    ActionType.UNASSIGNED_FROM_CUSTOMER, null, strEdgeId, customer.getId().toString(), customer.getName());
+
+            return savedEdge;
+        } catch (Exception e) {
+            logEntityAction(emptyId(EntityType.EDGE), null,
+                    null,
+                    ActionType.UNASSIGNED_FROM_CUSTOMER, e, strEdgeId);
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/customer/public/edge/{edgeId}", method = RequestMethod.POST)
+    @ResponseBody
+    public Edge assignEdgeToPublicCustomer(@PathVariable(EDGE_ID) String strEdgeId) throws ThingsboardException {
+        checkParameter(EDGE_ID, strEdgeId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.ASSIGN_TO_CUSTOMER);
+            Customer publicCustomer = customerService.findOrCreatePublicCustomer(edge.getTenantId());
+            Edge savedEdge = checkNotNull(edgeService.assignEdgeToCustomer(getCurrentUser().getTenantId(), edgeId, publicCustomer.getId()));
+
+            logEntityAction(edgeId, savedEdge,
+                    savedEdge.getCustomerId(),
+                    ActionType.ASSIGNED_TO_CUSTOMER, null, strEdgeId, publicCustomer.getId().toString(), publicCustomer.getName());
+
+            return savedEdge;
+        } catch (Exception e) {
+            logEntityAction(emptyId(EntityType.EDGE), null,
+                    null,
+                    ActionType.ASSIGNED_TO_CUSTOMER, e, strEdgeId);
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/tenant/edges", params = {"pageSize", "page"}, method = RequestMethod.GET)
+    @ResponseBody
+    public PageData<Edge> getTenantEdges(
+            @RequestParam int pageSize,
+            @RequestParam int page,
+            @RequestParam(required = false) String type,
+            @RequestParam(required = false) String textSearch,
+            @RequestParam(required = false) String sortProperty,
+            @RequestParam(required = false) String sortOrder) throws ThingsboardException {
+        try {
+            TenantId tenantId = getCurrentUser().getTenantId();
+            PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
+            if (type != null && type.trim().length() > 0) {
+                return checkNotNull(edgeService.findEdgesByTenantIdAndType(tenantId, type, pageLink));
+            } else {
+                return checkNotNull(edgeService.findEdgesByTenantId(tenantId, pageLink));
+            }
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/tenant/edges", params = {"edgeName"}, method = RequestMethod.GET)
+    @ResponseBody
+    public Edge getTenantEdge(
+            @RequestParam String edgeName) throws ThingsboardException {
+        try {
+            TenantId tenantId = getCurrentUser().getTenantId();
+            return checkNotNull(edgeService.findEdgeByTenantIdAndName(tenantId, edgeName));
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/{ruleChainId}/root", method = RequestMethod.POST)
+    @ResponseBody
+    public Edge setRootRuleChain(@PathVariable(EDGE_ID) String strEdgeId,
+                                 @PathVariable("ruleChainId") String strRuleChainId) throws ThingsboardException {
+        checkParameter(EDGE_ID, strEdgeId);
+        checkParameter("ruleChainId", strRuleChainId);
+        try {
+            RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
+            checkRuleChain(ruleChainId, Operation.WRITE);
+
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.WRITE);
+            accessControlService.checkPermission(getCurrentUser(), Resource.EDGE, Operation.WRITE,
+                    edge.getId(), edge);
+
+            Edge updatedEdge = edgeService.setRootRuleChain(getTenantId(), edge, ruleChainId);
+
+            logEntityAction(updatedEdge.getId(), updatedEdge, null, ActionType.UPDATED, null);
+
+            return updatedEdge;
+        } catch (Exception e) {
+            logEntityAction(emptyId(EntityType.EDGE),
+                    null,
+                    null,
+                    ActionType.UPDATED, e, strEdgeId);
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/customer/{customerId}/edges", params = {"pageSize", "page"}, method = RequestMethod.GET)
+    @ResponseBody
+    public PageData<Edge> getCustomerEdges(
+            @PathVariable("customerId") String strCustomerId,
+            @RequestParam int pageSize,
+            @RequestParam int page,
+            @RequestParam(required = false) String type,
+            @RequestParam(required = false) String textSearch,
+            @RequestParam(required = false) String sortProperty,
+            @RequestParam(required = false) String sortOrder) throws ThingsboardException {
+        checkParameter("customerId", strCustomerId);
+        try {
+            TenantId tenantId = getCurrentUser().getTenantId();
+            CustomerId customerId = new CustomerId(toUUID(strCustomerId));
+            checkCustomerId(customerId, Operation.READ);
+            PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
+            if (type != null && type.trim().length() > 0) {
+                return checkNotNull(edgeService.findEdgesByTenantIdAndCustomerIdAndType(tenantId, customerId, type, pageLink));
+            } else {
+                return checkNotNull(edgeService.findEdgesByTenantIdAndCustomerId(tenantId, customerId, pageLink));
+            }
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/edges", params = {"edgeIds"}, method = RequestMethod.GET)
+    @ResponseBody
+    public List<Edge> getEdgesByIds(
+            @RequestParam("edgeIds") String[] strEdgeIds) throws ThingsboardException {
+        checkArrayParameter("edgeIds", strEdgeIds);
+        try {
+            SecurityUser user = getCurrentUser();
+            TenantId tenantId = user.getTenantId();
+            CustomerId customerId = user.getCustomerId();
+            List<EdgeId> edgeIds = new ArrayList<>();
+            for (String strEdgeId : strEdgeIds) {
+                edgeIds.add(new EdgeId(toUUID(strEdgeId)));
+            }
+            ListenableFuture<List<Edge>> edges;
+            if (customerId == null || customerId.isNullUid()) {
+                edges = edgeService.findEdgesByTenantIdAndIdsAsync(tenantId, edgeIds);
+            } else {
+                edges = edgeService.findEdgesByTenantIdCustomerIdAndIdsAsync(tenantId, customerId, edgeIds);
+            }
+            return checkNotNull(edges.get());
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/edges", method = RequestMethod.POST)
+    @ResponseBody
+    public List<Edge> findByQuery(@RequestBody EdgeSearchQuery query) throws ThingsboardException {
+        checkNotNull(query);
+        checkNotNull(query.getParameters());
+        checkNotNull(query.getEdgeTypes());
+        checkEntityId(query.getParameters().getEntityId(), Operation.READ);
+        try {
+            List<Edge> edges = checkNotNull(edgeService.findEdgesByQuery(getCurrentUser().getTenantId(), query).get());
+            edges = edges.stream().filter(edge -> {
+                try {
+                    accessControlService.checkPermission(getCurrentUser(), Resource.EDGE, Operation.READ, edge.getId(), edge);
+                    return true;
+                } catch (ThingsboardException e) {
+                    return false;
+                }
+            }).collect(Collectors.toList());
+            return edges;
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
+    @RequestMapping(value = "/edge/types", method = RequestMethod.GET)
+    @ResponseBody
+    public List<EntitySubtype> getEdgeTypes() throws ThingsboardException {
+        try {
+            SecurityUser user = getCurrentUser();
+            TenantId tenantId = user.getTenantId();
+            ListenableFuture<List<EntitySubtype>> edgeTypes = edgeService.findEdgeTypesByTenantId(tenantId);
+            return checkNotNull(edgeTypes.get());
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+}

@@ -31,9 +31,11 @@ import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.bind.annotation.RestController;
 import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.audit.ActionType;
 import org.thingsboard.server.common.data.audit.ActionType;
+import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.entityview.EntityViewSearchQuery;
 import org.thingsboard.server.common.data.entityview.EntityViewSearchQuery;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityViewId;
 import org.thingsboard.server.common.data.id.EntityViewId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -55,6 +57,7 @@ import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
 import static org.thingsboard.server.controller.CustomerController.CUSTOMER_ID;
 import static org.thingsboard.server.controller.CustomerController.CUSTOMER_ID;
+import static org.thingsboard.server.controller.EdgeController.EDGE_ID;
 
 
 /**
 /**
  * Created by Victor Basanets on 8/28/2017.
  * Created by Victor Basanets on 8/28/2017.
@@ -426,4 +429,84 @@ public class EntityViewController extends BaseController {
             throw handleException(e);
             throw handleException(e);
         }
         }
     }
     }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/entityView/{entityViewId}", method = RequestMethod.POST)
+    @ResponseBody
+    public EntityView assignEntityViewToEdge(@PathVariable(EDGE_ID) String strEdgeId,
+                                             @PathVariable(ENTITY_VIEW_ID) String strEntityViewId) throws ThingsboardException {
+        checkParameter(EDGE_ID, strEdgeId);
+        checkParameter(ENTITY_VIEW_ID, strEntityViewId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.READ);
+
+            EntityViewId entityViewId = new EntityViewId(toUUID(strEntityViewId));
+            checkEntityViewId(entityViewId, Operation.ASSIGN_TO_EDGE);
+
+            EntityView savedEntityView = checkNotNull(entityViewService.assignEntityViewToEdge(getTenantId(), entityViewId, edgeId));
+            logEntityAction(entityViewId, savedEntityView,
+                    savedEntityView.getCustomerId(),
+                    ActionType.ASSIGNED_TO_EDGE, null, strEntityViewId, strEdgeId, edge.getName());
+            return savedEntityView;
+        } catch (Exception e) {
+            logEntityAction(emptyId(EntityType.ENTITY_VIEW), null,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, e, strEntityViewId, strEdgeId);
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/entityView/{entityViewId}", method = RequestMethod.DELETE)
+    @ResponseBody
+    public EntityView unassignEntityViewFromEdge(@PathVariable(ENTITY_VIEW_ID) String strEntityViewId) throws ThingsboardException {
+        checkParameter(ENTITY_VIEW_ID, strEntityViewId);
+        try {
+            EntityViewId entityViewId = new EntityViewId(toUUID(strEntityViewId));
+            EntityView entityView = checkEntityViewId(entityViewId, Operation.UNASSIGN_FROM_EDGE);
+            if (entityView.getEdgeId() == null || entityView.getEdgeId().getId().equals(ModelConstants.NULL_UUID)) {
+                throw new IncorrectParameterException("Entity View isn't assigned to any edge!");
+            }
+            Edge edge = checkEdgeId(entityView.getEdgeId(), Operation.READ);
+            EntityView savedEntityView = checkNotNull(entityViewService.unassignEntityViewFromEdge(getTenantId(), entityViewId));
+            logEntityAction(entityViewId, entityView,
+                    entityView.getCustomerId(),
+                    ActionType.UNASSIGNED_FROM_EDGE, null, strEntityViewId, edge.getId().toString(), edge.getName());
+
+            return savedEntityView;
+        } catch (Exception e) {
+            logEntityAction(emptyId(EntityType.ENTITY_VIEW), null,
+                    null,
+                    ActionType.UNASSIGNED_FROM_EDGE, e, strEntityViewId);
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/entityViews", params = {"pageSize", "page"}, method = RequestMethod.GET)
+    @ResponseBody
+    public PageData<EntityView> getEdgeEntityViews(
+            @PathVariable("edgeId") String strEdgeId,
+            @RequestParam int pageSize,
+            @RequestParam int page,
+            @RequestParam(required = false) String type,
+            @RequestParam(required = false) String textSearch,
+            @RequestParam(required = false) String sortProperty,
+            @RequestParam(required = false) String sortOrder) throws ThingsboardException {
+        checkParameter("edgeId", strEdgeId);
+        try {
+            TenantId tenantId = getCurrentUser().getTenantId();
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            checkEdgeId(edgeId, Operation.READ);
+            PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
+            if (type != null && type.trim().length()>0) {
+                return checkNotNull(entityViewService.findEntityViewsByTenantIdAndEdgeIdAndType(tenantId, edgeId, type, pageLink));
+            } else {
+                return checkNotNull(entityViewService.findEntityViewsByTenantIdAndEdgeId(tenantId, edgeId, pageLink));
+            }
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
 }
 }

@@ -40,16 +40,21 @@ import org.thingsboard.server.actors.tenant.DebugTbRateLimits;
 import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 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.audit.ActionType;
 import org.thingsboard.server.common.data.audit.ActionType;
+import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.RuleNodeId;
 import org.thingsboard.server.common.data.id.RuleNodeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
 import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
 import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.common.data.rule.RuleChainMetaData;
 import org.thingsboard.server.common.data.rule.RuleChainMetaData;
+import org.thingsboard.server.common.data.rule.RuleChainType;
 import org.thingsboard.server.common.data.rule.RuleNode;
 import org.thingsboard.server.common.data.rule.RuleNode;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsgMetaData;
 import org.thingsboard.server.common.msg.TbMsgMetaData;
@@ -59,6 +64,7 @@ import org.thingsboard.server.service.script.RuleNodeJsScriptEngine;
 import org.thingsboard.server.service.security.permission.Operation;
 import org.thingsboard.server.service.security.permission.Operation;
 import org.thingsboard.server.service.security.permission.Resource;
 import org.thingsboard.server.service.security.permission.Resource;
 
 
+import java.util.HashSet;
 import java.util.List;
 import java.util.List;
 import java.util.Map;
 import java.util.Map;
 import java.util.Set;
 import java.util.Set;
@@ -225,13 +231,19 @@ public class RuleChainController extends BaseController {
     public PageData<RuleChain> getRuleChains(
     public PageData<RuleChain> getRuleChains(
             @RequestParam int pageSize,
             @RequestParam int pageSize,
             @RequestParam int page,
             @RequestParam int page,
+            @RequestParam(value = "type", required = false) String typeStr,
             @RequestParam(required = false) String textSearch,
             @RequestParam(required = false) String textSearch,
             @RequestParam(required = false) String sortProperty,
             @RequestParam(required = false) String sortProperty,
             @RequestParam(required = false) String sortOrder) throws ThingsboardException {
             @RequestParam(required = false) String sortOrder) throws ThingsboardException {
         try {
         try {
             TenantId tenantId = getCurrentUser().getTenantId();
             TenantId tenantId = getCurrentUser().getTenantId();
             PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
             PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
-            return checkNotNull(ruleChainService.findTenantRuleChains(tenantId, pageLink));
+            if (typeStr != null && typeStr.trim().length() > 0) {
+                RuleChainType type = RuleChainType.valueOf(typeStr);
+                return checkNotNull(ruleChainService.findTenantRuleChainsByType(tenantId, type, pageLink));
+            } else {
+                return checkNotNull(ruleChainService.findTenantRuleChains(tenantId, pageLink));
+            }
         } catch (Exception e) {
         } catch (Exception e) {
             throw handleException(e);
             throw handleException(e);
         }
         }
@@ -372,4 +384,242 @@ public class RuleChainController extends BaseController {
         return objectMapper.writeValueAsString(msgData);
         return objectMapper.writeValueAsString(msgData);
     }
     }
 
 
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/ruleChain/{ruleChainId}", method = RequestMethod.POST)
+    @ResponseBody
+    public RuleChain assignRuleChainToEdge(@PathVariable("edgeId") String strEdgeId,
+                                           @PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
+        checkParameter("edgeId", strEdgeId);
+        checkParameter(RULE_CHAIN_ID, strRuleChainId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.READ);
+
+            RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
+            checkRuleChain(ruleChainId, Operation.ASSIGN_TO_EDGE);
+
+            RuleChain savedRuleChain = checkNotNull(ruleChainService.assignRuleChainToEdge(getCurrentUser().getTenantId(), ruleChainId, edgeId));
+
+            logEntityAction(ruleChainId, savedRuleChain,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, null, strRuleChainId, strEdgeId, edge.getName());
+
+
+            return savedRuleChain;
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.RULE_CHAIN), null,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, e, strRuleChainId, strEdgeId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/ruleChain/{ruleChainId}", method = RequestMethod.DELETE)
+    @ResponseBody
+    public RuleChain unassignRuleChainFromEdge(@PathVariable("edgeId") String strEdgeId,
+                                               @PathVariable(RULE_CHAIN_ID) String strRuleChainId) throws ThingsboardException {
+        checkParameter("edgeId", strEdgeId);
+        checkParameter(RULE_CHAIN_ID, strRuleChainId);
+        try {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            Edge edge = checkEdgeId(edgeId, Operation.READ);
+            RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
+            RuleChain ruleChain = checkRuleChain(ruleChainId, Operation.UNASSIGN_FROM_EDGE);
+
+            RuleChain savedRuleChain = checkNotNull(ruleChainService.unassignRuleChainFromEdge(getCurrentUser().getTenantId(), ruleChainId, edgeId));
+
+            logEntityAction(ruleChainId, ruleChain,
+                    null,
+                    ActionType.UNASSIGNED_FROM_EDGE, null, strRuleChainId, edge.getId().toString(), edge.getName());
+
+            return savedRuleChain;
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.RULE_CHAIN), null,
+                    null,
+                    ActionType.UNASSIGNED_FROM_EDGE, e, strRuleChainId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/ruleChain/{ruleChainId}/edges", method = RequestMethod.POST)
+    @ResponseBody
+    public RuleChain updateRuleChainEdges(@PathVariable(RULE_CHAIN_ID) String strRuleChainId,
+                                          @RequestBody String[] strEdgeIds) throws ThingsboardException {
+        checkParameter(RULE_CHAIN_ID, strRuleChainId);
+        try {
+            RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
+            RuleChain ruleChain = checkRuleChain(ruleChainId, Operation.ASSIGN_TO_EDGE);
+
+            Set<EdgeId> edgeIds = new HashSet<>();
+            if (strEdgeIds != null) {
+                for (String strEdgeId : strEdgeIds) {
+                    edgeIds.add(new EdgeId(toUUID(strEdgeId)));
+                }
+            }
+
+            Set<EdgeId> addedEdgeIds = new HashSet<>();
+            Set<EdgeId> removedEdgeIds = new HashSet<>();
+            for (EdgeId edgeId : edgeIds) {
+                if (!ruleChain.isAssignedToEdge(edgeId)) {
+                    addedEdgeIds.add(edgeId);
+                }
+            }
+
+            Set<ShortEdgeInfo> assignedEdges = ruleChain.getAssignedEdges();
+            if (assignedEdges != null) {
+                for (ShortEdgeInfo edgeInfo : assignedEdges) {
+                    if (!edgeIds.contains(edgeInfo.getEdgeId())) {
+                        removedEdgeIds.add(edgeInfo.getEdgeId());
+                    }
+                }
+            }
+
+            if (addedEdgeIds.isEmpty() && removedEdgeIds.isEmpty()) {
+                return ruleChain;
+            } else {
+                RuleChain savedRuleChain = null;
+                for (EdgeId edgeId : addedEdgeIds) {
+                    savedRuleChain = checkNotNull(ruleChainService.assignRuleChainToEdge(getCurrentUser().getTenantId(), ruleChainId, edgeId));
+                    ShortEdgeInfo edgeInfo = savedRuleChain.getAssignedEdgeInfo(edgeId);
+                    logEntityAction(ruleChainId, savedRuleChain,
+                            null,
+                            ActionType.ASSIGNED_TO_EDGE, null, strRuleChainId, edgeId.toString(), edgeInfo.getTitle());
+                }
+                for (EdgeId edgeId : removedEdgeIds) {
+                    ShortEdgeInfo edgeInfo = ruleChain.getAssignedEdgeInfo(edgeId);
+                    savedRuleChain = checkNotNull(ruleChainService.unassignRuleChainFromEdge(getCurrentUser().getTenantId(), ruleChainId, edgeId));
+                    logEntityAction(ruleChainId, ruleChain,
+                            null,
+                            ActionType.UNASSIGNED_FROM_EDGE, null, strRuleChainId, edgeId.toString(), edgeInfo.getTitle());
+
+                }
+                return savedRuleChain;
+            }
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.RULE_CHAIN), null,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, e, strRuleChainId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/ruleChain/{ruleChainId}/edges/add", method = RequestMethod.POST)
+    @ResponseBody
+    public RuleChain addRuleChainEdges(@PathVariable(RULE_CHAIN_ID) String strRuleChainId,
+                                       @RequestBody String[] strEdgeIds) throws ThingsboardException {
+        checkParameter(RULE_CHAIN_ID, strRuleChainId);
+        try {
+            RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
+            RuleChain ruleChain = checkRuleChain(ruleChainId, Operation.ASSIGN_TO_EDGE);
+
+            Set<EdgeId> edgeIds = new HashSet<>();
+            if (strEdgeIds != null) {
+                for (String strEdgeId : strEdgeIds) {
+                    EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+                    if (!ruleChain.isAssignedToEdge(edgeId)) {
+                        edgeIds.add(edgeId);
+                    }
+                }
+            }
+
+            if (edgeIds.isEmpty()) {
+                return ruleChain;
+            } else {
+                RuleChain savedRuleChain = null;
+                for (EdgeId edgeId : edgeIds) {
+                    savedRuleChain = checkNotNull(ruleChainService.assignRuleChainToEdge(getCurrentUser().getTenantId(), ruleChainId, edgeId));
+                    ShortEdgeInfo edgeInfo = savedRuleChain.getAssignedEdgeInfo(edgeId);
+                    logEntityAction(ruleChainId, savedRuleChain,
+                            null,
+                            ActionType.ASSIGNED_TO_EDGE, null, strRuleChainId, edgeId.toString(), edgeInfo.getTitle());
+                }
+                return savedRuleChain;
+            }
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.RULE_CHAIN), null,
+                    null,
+                    ActionType.ASSIGNED_TO_EDGE, e, strRuleChainId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/ruleChain/{ruleChainId}/edges/remove", method = RequestMethod.POST)
+    @ResponseBody
+    public RuleChain removeRuleChainEdges(@PathVariable(RULE_CHAIN_ID) String strRuleChainId,
+                                          @RequestBody String[] strEdgeIds) throws ThingsboardException {
+        checkParameter(RULE_CHAIN_ID, strRuleChainId);
+        try {
+            RuleChainId ruleChainId = new RuleChainId(toUUID(strRuleChainId));
+            RuleChain ruleChain = checkRuleChain(ruleChainId, Operation.UNASSIGN_FROM_EDGE);
+
+            Set<EdgeId> edgeIds = new HashSet<>();
+            if (strEdgeIds != null) {
+                for (String strEdgeId : strEdgeIds) {
+                    EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+                    if (ruleChain.isAssignedToEdge(edgeId)) {
+                        edgeIds.add(edgeId);
+                    }
+                }
+            }
+
+            if (edgeIds.isEmpty()) {
+                return ruleChain;
+            } else {
+                RuleChain savedRuleChain = null;
+                for (EdgeId edgeId : edgeIds) {
+                    ShortEdgeInfo edgeInfo = ruleChain.getAssignedEdgeInfo(edgeId);
+                    savedRuleChain = checkNotNull(ruleChainService.unassignRuleChainFromEdge(getCurrentUser().getTenantId(), ruleChainId, edgeId));
+                    logEntityAction(ruleChainId, ruleChain,
+                            null,
+                            ActionType.UNASSIGNED_FROM_EDGE, null, strRuleChainId, edgeId.toString(), edgeInfo.getTitle());
+
+                }
+                return savedRuleChain;
+            }
+        } catch (Exception e) {
+
+            logEntityAction(emptyId(EntityType.RULE_CHAIN), null,
+                    null,
+                    ActionType.UNASSIGNED_FROM_EDGE, e, strRuleChainId);
+
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/ruleChains", params = {"pageSize", "page"}, method = RequestMethod.GET)
+    @ResponseBody
+    public PageData<RuleChain> getEdgeRuleChains(
+            @PathVariable("edgeId") String strEdgeId,
+            @RequestParam int pageSize,
+            @RequestParam int page,
+            @RequestParam(required = false) String textSearch,
+            @RequestParam(required = false) String sortProperty,
+            @RequestParam(required = false) String sortOrder,
+            @RequestParam(required = false) Long startTime,
+            @RequestParam(required = false) Long endTime) throws ThingsboardException {
+        checkParameter("edgeId", strEdgeId);
+        try {
+            TenantId tenantId = getCurrentUser().getTenantId();
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            checkEdgeId(edgeId, Operation.READ);
+            TimePageLink pageLink = createTimePageLink(pageSize, page, textSearch, sortProperty, sortOrder, startTime, endTime);
+            return checkNotNull(ruleChainService.findRuleChainsByTenantIdAndEdgeId(tenantId, edgeId, pageLink));
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.edge;
+
+import lombok.Data;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.actors.service.ActorService;
+import org.thingsboard.server.dao.alarm.AlarmService;
+import org.thingsboard.server.dao.asset.AssetService;
+import org.thingsboard.server.dao.attributes.AttributesService;
+import org.thingsboard.server.dao.customer.CustomerService;
+import org.thingsboard.server.dao.dashboard.DashboardService;
+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.relation.RelationService;
+
+@Component
+@Data
+public class EdgeContextComponent {
+
+    @Lazy
+    @Autowired
+    private EdgeService edgeService;
+
+    @Lazy
+    @Autowired
+    private AssetService assetService;
+
+    @Lazy
+    @Autowired
+    private DeviceService deviceService;
+
+    @Lazy
+    @Autowired
+    private EntityViewService entityViewService;
+
+    @Lazy
+    @Autowired
+    private AttributesService attributesService;
+
+    @Lazy
+    @Autowired
+    private CustomerService customerService;
+
+    @Lazy
+    @Autowired
+    private RelationService relationService;
+
+    @Lazy
+    @Autowired
+    private AlarmService alarmService;
+
+    @Lazy
+    @Autowired
+    private DashboardService dashboardService;
+
+    @Lazy
+    @Autowired
+    private ActorService actorService;
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.edge.rpc;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.io.Resources;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.stub.StreamObserver;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.stereotype.Service;
+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.gen.edge.EdgeRpcServiceGrpc;
+import org.thingsboard.server.gen.edge.RequestMsg;
+import org.thingsboard.server.gen.edge.ResponseMsg;
+import org.thingsboard.server.service.edge.EdgeContextComponent;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.io.File;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+@Service
+@Slf4j
+@ConditionalOnProperty(prefix = "edges.rpc", value = "enabled", havingValue = "true")
+public class EdgeGrpcService extends EdgeRpcServiceGrpc.EdgeRpcServiceImplBase {
+
+    private final Map<EdgeId, EdgeGrpcSession> sessions = new ConcurrentHashMap<>();
+    private static final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Value("${edges.rpc.port}")
+    private int rpcPort;
+    @Value("${edges.rpc.ssl.enabled}")
+    private boolean sslEnabled;
+    @Value("${edges.rpc.ssl.cert}")
+    private String certFileResource;
+    @Value("${edges.rpc.ssl.privateKey}")
+    private String privateKeyResource;
+
+    @Autowired
+    private EdgeContextComponent ctx;
+
+    private Server server;
+
+    private ExecutorService executor;
+
+    @PostConstruct
+    public void init() {
+        log.info("Initializing Edge RPC service!");
+        ServerBuilder builder = ServerBuilder.forPort(rpcPort).addService(this);
+        if (sslEnabled) {
+            try {
+                File certFile = new File(Resources.getResource(certFileResource).toURI());
+                File privateKeyFile = new File(Resources.getResource(privateKeyResource).toURI());
+                builder.useTransportSecurity(certFile, privateKeyFile);
+            } catch (Exception e) {
+                log.error("Unable to set up SSL context. Reason: " + e.getMessage(), e);
+                throw new RuntimeException("Unable to set up SSL context!", e);
+            }
+        }
+        server = builder.build();
+        log.info("Going to start Edge RPC server using port: {}", rpcPort);
+        try {
+            server.start();
+        } catch (IOException e) {
+            log.error("Failed to start Edge RPC server!", e);
+            throw new RuntimeException("Failed to start Edge RPC server!");
+        }
+        log.info("Edge RPC service initialized!");
+        executor = Executors.newSingleThreadExecutor();
+        processHandleMessages();
+    }
+
+    @PreDestroy
+    public void destroy() {
+        if (server != null) {
+            server.shutdownNow();
+        }
+    }
+
+    @Override
+    public StreamObserver<RequestMsg> handleMsgs(StreamObserver<ResponseMsg> outputStream) {
+        return new EdgeGrpcSession(ctx, outputStream, this::onEdgeConnect, this::onEdgeDisconnect, objectMapper).getInputStream();
+    }
+
+    private void onEdgeConnect(EdgeId edgeId, EdgeGrpcSession edgeGrpcSession) {
+        sessions.put(edgeId, edgeGrpcSession);
+    }
+
+    private void processHandleMessages() {
+        executor.submit(() -> {
+            while (!Thread.interrupted()) {
+                try {
+                    for (EdgeGrpcSession session : sessions.values()) {
+                        session.processHandleMessages();
+                    }
+                } catch (Exception e) {
+                    log.warn("Failed to process messages handling!", e);
+                }
+            }
+        });
+    }
+
+    private void onEdgeDisconnect(EdgeId edgeId) {
+        sessions.remove(edgeId);
+    }
+
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.edge.rpc;
+
+import com.datastax.driver.core.utils.UUIDs;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.protobuf.ByteString;
+import io.grpc.stub.StreamObserver;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.common.data.Customer;
+import org.thingsboard.server.common.data.Dashboard;
+import org.thingsboard.server.common.data.DataConstants;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.EntityView;
+import org.thingsboard.server.common.data.Event;
+import org.thingsboard.server.common.data.User;
+import org.thingsboard.server.common.data.alarm.Alarm;
+import org.thingsboard.server.common.data.alarm.AlarmSeverity;
+import org.thingsboard.server.common.data.alarm.AlarmStatus;
+import org.thingsboard.server.common.data.asset.Asset;
+import org.thingsboard.server.common.data.edge.Edge;
+import org.thingsboard.server.common.data.edge.EdgeQueueEntry;
+import org.thingsboard.server.common.data.id.AssetId;
+import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.EdgeId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.EntityViewId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.kv.AttributeKvEntry;
+import org.thingsboard.server.common.data.kv.BaseAttributeKvEntry;
+import org.thingsboard.server.common.data.kv.DataType;
+import org.thingsboard.server.common.data.kv.LongDataEntry;
+import org.thingsboard.server.common.data.page.PageData;
+import org.thingsboard.server.common.data.page.TimePageLink;
+import org.thingsboard.server.common.data.relation.EntityRelation;
+import org.thingsboard.server.common.data.relation.RelationTypeGroup;
+import org.thingsboard.server.common.data.rule.NodeConnectionInfo;
+import org.thingsboard.server.common.data.rule.RuleChain;
+import org.thingsboard.server.common.data.rule.RuleChainConnectionInfo;
+import org.thingsboard.server.common.data.rule.RuleChainMetaData;
+import org.thingsboard.server.common.data.rule.RuleNode;
+import org.thingsboard.server.common.msg.TbMsg;
+import org.thingsboard.server.common.msg.TbMsgDataType;
+import org.thingsboard.server.common.msg.TbMsgMetaData;
+import org.thingsboard.server.common.msg.cluster.SendToClusterMsg;
+import org.thingsboard.server.common.msg.session.SessionMsgType;
+import org.thingsboard.server.common.msg.system.ServiceToRuleEngineMsg;
+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.ConnectRequestMsg;
+import org.thingsboard.server.gen.edge.ConnectResponseCode;
+import org.thingsboard.server.gen.edge.ConnectResponseMsg;
+import org.thingsboard.server.gen.edge.CustomerUpdateMsg;
+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.EdgeConfiguration;
+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.NodeConnectionInfoProto;
+import org.thingsboard.server.gen.edge.RequestMsg;
+import org.thingsboard.server.gen.edge.RequestMsgType;
+import org.thingsboard.server.gen.edge.ResponseMsg;
+import org.thingsboard.server.gen.edge.RuleChainConnectionInfoProto;
+import org.thingsboard.server.gen.edge.RuleChainMetadataUpdateMsg;
+import org.thingsboard.server.gen.edge.RuleChainUpdateMsg;
+import org.thingsboard.server.gen.edge.RuleNodeProto;
+import org.thingsboard.server.gen.edge.UpdateMsgType;
+import org.thingsboard.server.gen.edge.UplinkMsg;
+import org.thingsboard.server.gen.edge.UplinkResponseMsg;
+import org.thingsboard.server.gen.edge.UserUpdateMsg;
+import org.thingsboard.server.service.edge.EdgeContextComponent;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+import static org.thingsboard.server.gen.edge.UpdateMsgType.ENTITY_CREATED_RPC_MESSAGE;
+
+@Slf4j
+@Data
+public final class EdgeGrpcSession implements Cloneable {
+
+    private static final ReentrantLock entityCreationLock = new ReentrantLock();
+
+    private final UUID sessionId;
+    private final BiConsumer<EdgeId, EdgeGrpcSession> sessionOpenListener;
+    private final Consumer<EdgeId> sessionCloseListener;
+    private final ObjectMapper objectMapper;
+
+    private EdgeContextComponent ctx;
+    private Edge edge;
+    private StreamObserver<RequestMsg> inputStream;
+    private StreamObserver<ResponseMsg> outputStream;
+    private boolean connected;
+
+    EdgeGrpcSession(EdgeContextComponent ctx, StreamObserver<ResponseMsg> outputStream, BiConsumer<EdgeId, EdgeGrpcSession> sessionOpenListener,
+                    Consumer<EdgeId> sessionCloseListener, ObjectMapper objectMapper) {
+        this.sessionId = UUID.randomUUID();
+        this.ctx = ctx;
+        this.outputStream = outputStream;
+        this.sessionOpenListener = sessionOpenListener;
+        this.sessionCloseListener = sessionCloseListener;
+        this.objectMapper = objectMapper;
+        initInputStream();
+    }
+
+    private void initInputStream() {
+        this.inputStream = new StreamObserver<RequestMsg>() {
+            @Override
+            public void onNext(RequestMsg requestMsg) {
+                if (!connected && requestMsg.getMsgType().equals(RequestMsgType.CONNECT_RPC_MESSAGE)) {
+                    ConnectResponseMsg responseMsg = processConnect(requestMsg.getConnectRequestMsg());
+                    outputStream.onNext(ResponseMsg.newBuilder()
+                            .setConnectResponseMsg(responseMsg)
+                            .build());
+                    if (ConnectResponseCode.ACCEPTED != responseMsg.getResponseCode()) {
+                        outputStream.onError(new RuntimeException(responseMsg.getErrorMsg()));
+                    }
+                }
+                if (connected) {
+                    if (requestMsg.getMsgType().equals(RequestMsgType.UPLINK_RPC_MESSAGE) && requestMsg.hasUplinkMsg()) {
+                        outputStream.onNext(ResponseMsg.newBuilder()
+                                .setUplinkResponseMsg(processUplinkMsg(requestMsg.getUplinkMsg()))
+                                .build());
+                    }
+                }
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                log.error("Failed to deliver message from client!", t);
+            }
+
+            @Override
+            public void onCompleted() {
+                sessionCloseListener.accept(edge.getId());
+                outputStream.onCompleted();
+            }
+        };
+    }
+
+
+    void processHandleMessages() throws ExecutionException, InterruptedException {
+        Long queueStartTs = getQueueStartTs().get();
+        // TODO: this 100 value must be changed properly
+        TimePageLink pageLink = new TimePageLink(30, 0, "", null, queueStartTs + 1000, null);
+        PageData<Event> pageData;
+        UUID ifOffset = null;
+        do {
+            pageData = ctx.getEdgeService().findQueueEvents(edge.getTenantId(), edge.getId(), pageLink);
+            if (!pageData.getData().isEmpty()) {
+                log.trace("[{}] [{}] event(s) are going to be processed.", this.sessionId, pageData.getData().size());
+                for (Event event : pageData.getData()) {
+                    log.trace("[{}] Processing event [{}]", this.sessionId, event);
+                    EdgeQueueEntry entry;
+                    try {
+                        entry = objectMapper.treeToValue(event.getBody(), EdgeQueueEntry.class);
+
+                        UpdateMsgType msgType = getResponseMsgType(entry.getType());
+                        switch (msgType) {
+                            case ENTITY_DELETED_RPC_MESSAGE:
+                            case ENTITY_UPDATED_RPC_MESSAGE:
+                            case ENTITY_CREATED_RPC_MESSAGE:
+                            case ALARM_ACK_RPC_MESSAGE:
+                            case ALARM_CLEAR_RPC_MESSAGE:
+                                processEntityCRUDMessage(entry, msgType);
+                                break;
+                            case RULE_CHAIN_CUSTOM_MESSAGE:
+                                processCustomDownlinkMessage(entry);
+                                break;
+                        }
+                        if (ENTITY_CREATED_RPC_MESSAGE.equals(msgType)) {
+                            pushEntityAttributesToEdge(entry);
+                        }
+                    } catch (Exception e) {
+                        log.error("Exception during processing records from queue", e);
+                    }
+                    ifOffset = event.getUuidId();
+                }
+            }
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        if (ifOffset != null) {
+            Long newStartTs = UUIDs.unixTimestamp(ifOffset);
+            updateQueueStartTs(newStartTs);
+        }
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            log.error("Error during sleep", e);
+        }
+    }
+
+    private void pushEntityAttributesToEdge(EdgeQueueEntry entry) throws IOException {
+        EntityId entityId = null;
+        String entityName = null;
+        switch (entry.getEntityType()) {
+            case EDGE:
+                entityId = objectMapper.readValue(entry.getData(), Edge.class).getId();
+                break;
+            case DEVICE:
+                entityId = objectMapper.readValue(entry.getData(), Device.class).getId();
+                break;
+            case ASSET:
+                entityId = objectMapper.readValue(entry.getData(), Asset.class).getId();
+                break;
+            case ENTITY_VIEW:
+                entityId = objectMapper.readValue(entry.getData(), EntityView.class).getId();
+                break;
+            case DASHBOARD:
+                entityId = objectMapper.readValue(entry.getData(), Dashboard.class).getId();
+                break;
+        }
+        if (entityId != null) {
+            ListenableFuture<List<AttributeKvEntry>> ssAttrFuture = ctx.getAttributesService().findAll(edge.getTenantId(), entityId, DataConstants.SERVER_SCOPE);
+            EntityId finalEntityId = entityId;
+            Futures.transform(ssAttrFuture, ssAttributes -> {
+                if (ssAttributes != null && !ssAttributes.isEmpty()) {
+                    try {
+                        TbMsgMetaData metaData = new TbMsgMetaData();
+                        ObjectNode entityNode = objectMapper.createObjectNode();
+                        metaData.putValue("scope", DataConstants.SERVER_SCOPE);
+                        for (AttributeKvEntry attr : ssAttributes) {
+                            if (attr.getDataType() == DataType.BOOLEAN) {
+                                entityNode.put(attr.getKey(), attr.getBooleanValue().get());
+                            } else if (attr.getDataType() == DataType.DOUBLE) {
+                                entityNode.put(attr.getKey(), attr.getDoubleValue().get());
+                            } else if (attr.getDataType() == DataType.LONG) {
+                                entityNode.put(attr.getKey(), attr.getLongValue().get());
+                            } else {
+                                entityNode.put(attr.getKey(), attr.getValueAsString());
+                            }
+                        }
+                        TbMsg tbMsg = new TbMsg(UUIDs.timeBased(), DataConstants.ATTRIBUTES_UPDATED, finalEntityId, metaData, TbMsgDataType.JSON
+                                , objectMapper.writeValueAsString(entityNode)
+                                , null, null, 0L);
+                        log.debug("Sending donwlink entity data msg, entityName [{}], tbMsg [{}]", entityName, tbMsg);
+                        outputStream.onNext(ResponseMsg.newBuilder()
+                                .setDownlinkMsg(constructDownlinkEntityDataMsg(entityName, tbMsg))
+                                .build());
+                    } catch (Exception e) {
+                        log.error("[{}] Failed to send attribute updates to the edge", edge.getName(), e);
+                    }
+                }
+                return null;
+            });
+            ListenableFuture<List<AttributeKvEntry>> shAttrFuture = ctx.getAttributesService().findAll(edge.getTenantId(), entityId, DataConstants.SHARED_SCOPE);
+            ListenableFuture<List<AttributeKvEntry>> clAttrFuture = ctx.getAttributesService().findAll(edge.getTenantId(), entityId, DataConstants.CLIENT_SCOPE);
+        }
+    }
+
+    private void processCustomDownlinkMessage(EdgeQueueEntry entry) throws IOException {
+        log.trace("Executing processCustomDownlinkMessage, entry [{}]", entry);
+        TbMsg tbMsg = objectMapper.readValue(entry.getData(), TbMsg.class);
+        String entityName = null;
+        switch (entry.getEntityType()) {
+            case DEVICE:
+                Device device = ctx.getDeviceService().findDeviceById(edge.getTenantId(), new DeviceId(tbMsg.getOriginator().getId()));
+                entityName = device.getName();
+                break;
+            case ASSET:
+                Asset asset = ctx.getAssetService().findAssetById(edge.getTenantId(), new AssetId(tbMsg.getOriginator().getId()));
+                entityName = asset.getName();
+                break;
+            case ENTITY_VIEW:
+                EntityView entityView = ctx.getEntityViewService().findEntityViewById(edge.getTenantId(), new EntityViewId(tbMsg.getOriginator().getId()));
+                entityName = entityView.getName();
+                break;
+
+        }
+        if (entityName != null) {
+            log.debug("Sending donwlink entity data msg, entityName [{}], tbMsg [{}]", entityName, tbMsg);
+            outputStream.onNext(ResponseMsg.newBuilder()
+                    .setDownlinkMsg(constructDownlinkEntityDataMsg(entityName, tbMsg))
+                    .build());
+        }
+    }
+
+    private void processEntityCRUDMessage(EdgeQueueEntry entry, UpdateMsgType msgType) throws java.io.IOException {
+        log.trace("Executing processEntityCRUDMessage, entry [{}], msgType [{}]", entry, msgType);
+        switch (entry.getEntityType()) {
+            case EDGE:
+                Edge edge = objectMapper.readValue(entry.getData(), Edge.class);
+                onEdgeUpdated(msgType, edge);
+                break;
+            case DEVICE:
+                Device device = objectMapper.readValue(entry.getData(), Device.class);
+                onDeviceUpdated(msgType, device);
+                break;
+            case ASSET:
+                Asset asset = objectMapper.readValue(entry.getData(), Asset.class);
+                onAssetUpdated(msgType, asset);
+                break;
+            case ENTITY_VIEW:
+                EntityView entityView = objectMapper.readValue(entry.getData(), EntityView.class);
+                onEntityViewUpdated(msgType, entityView);
+                break;
+            case DASHBOARD:
+                Dashboard dashboard = objectMapper.readValue(entry.getData(), Dashboard.class);
+                onDashboardUpdated(msgType, dashboard);
+                break;
+            case RULE_CHAIN:
+                RuleChain ruleChain = objectMapper.readValue(entry.getData(), RuleChain.class);
+                onRuleChainUpdated(msgType, ruleChain);
+                break;
+            case RULE_CHAIN_METADATA:
+                RuleChainMetaData ruleChainMetaData = objectMapper.readValue(entry.getData(), RuleChainMetaData.class);
+                onRuleChainMetadataUpdated(msgType, ruleChainMetaData);
+                break;
+            case ALARM:
+                Alarm alarm = objectMapper.readValue(entry.getData(), Alarm.class);
+                onAlarmUpdated(msgType, alarm);
+                break;
+        }
+    }
+
+    private void updateQueueStartTs(Long newStartTs) {
+        List<AttributeKvEntry> attributes = Collections.singletonList(new BaseAttributeKvEntry(new LongDataEntry("queueStartTs", newStartTs), System.currentTimeMillis()));
+        ctx.getAttributesService().save(edge.getTenantId(), edge.getId(), DataConstants.SERVER_SCOPE, attributes);
+    }
+
+    private ListenableFuture<Long> getQueueStartTs() {
+        ListenableFuture<Optional<AttributeKvEntry>> future =
+                ctx.getAttributesService().find(edge.getTenantId(), edge.getId(), DataConstants.SERVER_SCOPE, "queueStartTs");
+        return Futures.transform(future, attributeKvEntryOpt -> {
+            if (attributeKvEntryOpt != null && attributeKvEntryOpt.isPresent()) {
+                AttributeKvEntry attributeKvEntry = attributeKvEntryOpt.get();
+                return attributeKvEntry.getLongValue().isPresent() ? attributeKvEntry.getLongValue().get() : 0L;
+            } else {
+                return 0L;
+            }
+        });
+    }
+
+    private void onEdgeUpdated(UpdateMsgType msgType, Edge edge) {
+        // TODO: voba add configuration update to edge
+        this.edge = edge;
+    }
+
+    private void onDeviceUpdated(UpdateMsgType msgType, Device device) {
+        EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
+                .setDeviceUpdateMsg(constructDeviceUpdatedMsg(msgType, device))
+                .build();
+        outputStream.onNext(ResponseMsg.newBuilder()
+                .setEntityUpdateMsg(entityUpdateMsg)
+                .build());
+    }
+
+    private void onAssetUpdated(UpdateMsgType msgType, Asset asset) {
+        EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
+                .setAssetUpdateMsg(constructAssetUpdatedMsg(msgType, asset))
+                .build();
+        outputStream.onNext(ResponseMsg.newBuilder()
+                .setEntityUpdateMsg(entityUpdateMsg)
+                .build());
+    }
+
+    private void onEntityViewUpdated(UpdateMsgType msgType, EntityView entityView) {
+        EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
+                .setEntityViewUpdateMsg(constructEntityViewUpdatedMsg(msgType, entityView))
+                .build();
+        outputStream.onNext(ResponseMsg.newBuilder()
+                .setEntityUpdateMsg(entityUpdateMsg)
+                .build());
+    }
+
+    private void onRuleChainUpdated(UpdateMsgType msgType, RuleChain ruleChain) {
+        EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
+                .setRuleChainUpdateMsg(constructRuleChainUpdatedMsg(msgType, ruleChain))
+                .build();
+        outputStream.onNext(ResponseMsg.newBuilder()
+                .setEntityUpdateMsg(entityUpdateMsg)
+                .build());
+    }
+
+    private void onRuleChainMetadataUpdated(UpdateMsgType msgType, RuleChainMetaData ruleChainMetaData) {
+        RuleChainMetadataUpdateMsg ruleChainMetadataUpdateMsg = constructRuleChainMetadataUpdatedMsg(msgType, ruleChainMetaData);
+        if (ruleChainMetadataUpdateMsg != null) {
+            EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
+                    .setRuleChainMetadataUpdateMsg(ruleChainMetadataUpdateMsg)
+                    .build();
+            outputStream.onNext(ResponseMsg.newBuilder()
+                    .setEntityUpdateMsg(entityUpdateMsg)
+                    .build());
+        }
+    }
+
+    private void onDashboardUpdated(UpdateMsgType msgType, Dashboard dashboard) {
+        EntityUpdateMsg entityUpdateMsg = EntityUpdateMsg.newBuilder()
+                .setDashboardUpdateMsg(constructDashboardUpdatedMsg(msgType, dashboard))
+                .build();
+        outputStream.onNext(ResponseMsg.newBuilder()
+                .setEntityUpdateMsg(entityUpdateMsg)
+                .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.getType())
+                .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) {
+        if (msgType.equals(SessionMsgType.POST_TELEMETRY_REQUEST.name()) ||
+                msgType.equals(SessionMsgType.POST_ATTRIBUTES_REQUEST.name()) ||
+                msgType.equals(DataConstants.ATTRIBUTES_UPDATED) ||
+                msgType.equals(DataConstants.ATTRIBUTES_DELETED)) {
+            return UpdateMsgType.RULE_CHAIN_CUSTOM_MESSAGE;
+        } else {
+            switch (msgType) {
+                case DataConstants.ENTITY_UPDATED:
+                    return UpdateMsgType.ENTITY_UPDATED_RPC_MESSAGE;
+                case DataConstants.ENTITY_CREATED:
+                case DataConstants.ENTITY_ASSIGNED_TO_EDGE:
+                    return ENTITY_CREATED_RPC_MESSAGE;
+                case DataConstants.ENTITY_DELETED:
+                case DataConstants.ENTITY_UNASSIGNED_FROM_EDGE:
+                    return UpdateMsgType.ENTITY_DELETED_RPC_MESSAGE;
+                case DataConstants.ALARM_ACK:
+                    return UpdateMsgType.ALARM_ACK_RPC_MESSAGE;
+                case DataConstants.ALARM_CLEAR:
+                    return UpdateMsgType.ALARM_CLEAR_RPC_MESSAGE;
+                default:
+                    throw new RuntimeException("Unsupported msgType [" + msgType + "]");
+            }
+        }
+    }
+
+    private RuleChainUpdateMsg constructRuleChainUpdatedMsg(UpdateMsgType msgType, RuleChain ruleChain) {
+        RuleChainUpdateMsg.Builder builder = RuleChainUpdateMsg.newBuilder()
+                .setMsgType(msgType)
+                .setIdMSB(ruleChain.getId().getId().getMostSignificantBits())
+                .setIdLSB(ruleChain.getId().getId().getLeastSignificantBits())
+                .setName(ruleChain.getName())
+                .setRoot(ruleChain.getId().equals(edge.getRootRuleChainId()))
+                .setDebugMode(ruleChain.isDebugMode())
+                .setConfiguration(JacksonUtil.toString(ruleChain.getConfiguration()));
+        if (ruleChain.getFirstRuleNodeId() != null) {
+            builder.setFirstRuleNodeIdMSB(ruleChain.getFirstRuleNodeId().getId().getMostSignificantBits())
+                    .setFirstRuleNodeIdLSB(ruleChain.getFirstRuleNodeId().getId().getLeastSignificantBits());
+        }
+        return builder.build();
+    }
+
+    private DownlinkMsg constructDownlinkEntityDataMsg(String entityName, TbMsg tbMsg) {
+        EntityDataProto entityData = EntityDataProto.newBuilder()
+                .setEntityName(entityName)
+                .setTbMsg(ByteString.copyFrom(TbMsg.toBytes(tbMsg))).build();
+
+        DownlinkMsg.Builder builder = DownlinkMsg.newBuilder()
+                .addAllEntityData(Collections.singletonList(entityData));
+
+        return builder.build();
+    }
+
+    private RuleChainMetadataUpdateMsg constructRuleChainMetadataUpdatedMsg(UpdateMsgType msgType, RuleChainMetaData ruleChainMetaData) {
+        try {
+            RuleChainMetadataUpdateMsg.Builder builder = RuleChainMetadataUpdateMsg.newBuilder()
+                    .setRuleChainIdMSB(ruleChainMetaData.getRuleChainId().getId().getMostSignificantBits())
+                    .setRuleChainIdLSB(ruleChainMetaData.getRuleChainId().getId().getLeastSignificantBits())
+                    .addAllNodes(constructNodes(ruleChainMetaData.getNodes()))
+                    .addAllConnections(constructConnections(ruleChainMetaData.getConnections()))
+                    .addAllRuleChainConnections(constructRuleChainConnections(ruleChainMetaData.getRuleChainConnections()));
+            if (ruleChainMetaData.getFirstNodeIndex() != null) {
+                builder.setFirstNodeIndex(ruleChainMetaData.getFirstNodeIndex());
+            }
+            builder.setMsgType(msgType);
+            return builder.build();
+        } catch (JsonProcessingException ex) {
+            log.error("Can't construct RuleChainMetadataUpdateMsg", ex);
+        }
+        return null;
+    }
+
+    private List<RuleChainConnectionInfoProto> constructRuleChainConnections(List<RuleChainConnectionInfo> ruleChainConnections) throws JsonProcessingException {
+        List<RuleChainConnectionInfoProto> result = new ArrayList<>();
+        if (ruleChainConnections != null && !ruleChainConnections.isEmpty()) {
+            for (RuleChainConnectionInfo ruleChainConnectionInfo : ruleChainConnections) {
+                result.add(constructRuleChainConnection(ruleChainConnectionInfo));
+            }
+        }
+        return result;
+    }
+
+    private RuleChainConnectionInfoProto constructRuleChainConnection(RuleChainConnectionInfo ruleChainConnectionInfo) throws JsonProcessingException {
+        return RuleChainConnectionInfoProto.newBuilder()
+                .setFromIndex(ruleChainConnectionInfo.getFromIndex())
+                .setTargetRuleChainIdMSB(ruleChainConnectionInfo.getTargetRuleChainId().getId().getMostSignificantBits())
+                .setTargetRuleChainIdLSB(ruleChainConnectionInfo.getTargetRuleChainId().getId().getLeastSignificantBits())
+                .setType(ruleChainConnectionInfo.getType())
+                .setAdditionalInfo(objectMapper.writeValueAsString(ruleChainConnectionInfo.getAdditionalInfo()))
+                .build();
+    }
+
+    private List<NodeConnectionInfoProto> constructConnections(List<NodeConnectionInfo> connections) {
+        List<NodeConnectionInfoProto> result = new ArrayList<>();
+        if (connections != null && !connections.isEmpty()) {
+            for (NodeConnectionInfo connection : connections) {
+                result.add(constructConnection(connection));
+            }
+        }
+        return result;
+    }
+
+    private NodeConnectionInfoProto constructConnection(NodeConnectionInfo connection) {
+        return NodeConnectionInfoProto.newBuilder()
+                .setFromIndex(connection.getFromIndex())
+                .setToIndex(connection.getToIndex())
+                .setType(connection.getType())
+                .build();
+    }
+
+    private List<RuleNodeProto> constructNodes(List<RuleNode> nodes) throws JsonProcessingException {
+        List<RuleNodeProto> result = new ArrayList<>();
+        if (nodes != null && !nodes.isEmpty()) {
+            for (RuleNode node : nodes) {
+                result.add(constructNode(node));
+            }
+        }
+        return result;
+    }
+
+    private RuleNodeProto constructNode(RuleNode node) throws JsonProcessingException {
+        return RuleNodeProto.newBuilder()
+                .setIdMSB(node.getId().getId().getMostSignificantBits())
+                .setIdLSB(node.getId().getId().getLeastSignificantBits())
+                .setType(node.getType())
+                .setName(node.getName())
+                .setDebugMode(node.isDebugMode())
+                .setConfiguration(objectMapper.writeValueAsString(node.getConfiguration()))
+                .setAdditionalInfo(objectMapper.writeValueAsString(node.getAdditionalInfo()))
+                .build();
+    }
+
+    private DashboardUpdateMsg constructDashboardUpdatedMsg(UpdateMsgType msgType, Dashboard dashboard) {
+        dashboard = ctx.getDashboardService().findDashboardById(edge.getTenantId(), dashboard.getId());
+        DashboardUpdateMsg.Builder builder = DashboardUpdateMsg.newBuilder()
+                .setMsgType(msgType)
+                .setIdMSB(dashboard.getId().getId().getMostSignificantBits())
+                .setIdLSB(dashboard.getId().getId().getLeastSignificantBits())
+                .setTitle(dashboard.getTitle())
+                .setConfiguration(JacksonUtil.toString(dashboard.getConfiguration()));
+        return builder.build();
+    }
+
+    private CustomerUpdateMsg constructCustomerUpdatedMsg(UpdateMsgType msgType, Customer customer) {
+        CustomerUpdateMsg.Builder builder = CustomerUpdateMsg.newBuilder()
+                .setMsgType(msgType);
+        return builder.build();
+    }
+
+    private UserUpdateMsg constructUserUpdatedMsg(UpdateMsgType msgType, User user) {
+        UserUpdateMsg.Builder builder = UserUpdateMsg.newBuilder()
+                .setMsgType(msgType);
+        return builder.build();
+    }
+
+    private DeviceUpdateMsg constructDeviceUpdatedMsg(UpdateMsgType msgType, Device device) {
+        DeviceUpdateMsg.Builder builder = DeviceUpdateMsg.newBuilder()
+                .setMsgType(msgType)
+                .setName(device.getName())
+                .setType(device.getType());
+        return builder.build();
+    }
+
+    private AssetUpdateMsg constructAssetUpdatedMsg(UpdateMsgType msgType, Asset asset) {
+        AssetUpdateMsg.Builder builder = AssetUpdateMsg.newBuilder()
+                .setMsgType(msgType)
+                .setName(asset.getName())
+                .setType(asset.getType());
+        return builder.build();
+    }
+
+    private EntityViewUpdateMsg constructEntityViewUpdatedMsg(UpdateMsgType msgType, EntityView entityView) {
+        String relatedName;
+        String relatedType;
+        org.thingsboard.server.gen.edge.EntityType relatedEntityType;
+        if (entityView.getEntityId().getEntityType().equals(EntityType.DEVICE)) {
+            Device device = ctx.getDeviceService().findDeviceById(entityView.getTenantId(), new DeviceId(entityView.getEntityId().getId()));
+            relatedName = device.getName();
+            relatedType = device.getType();
+            relatedEntityType = org.thingsboard.server.gen.edge.EntityType.DEVICE;
+        } else {
+            Asset asset = ctx.getAssetService().findAssetById(entityView.getTenantId(), new AssetId(entityView.getEntityId().getId()));
+            relatedName = asset.getName();
+            relatedType = asset.getType();
+            relatedEntityType = org.thingsboard.server.gen.edge.EntityType.ASSET;
+        }
+        EntityViewUpdateMsg.Builder builder = EntityViewUpdateMsg.newBuilder()
+                .setMsgType(msgType)
+                .setName(entityView.getName())
+                .setType(entityView.getType())
+                .setRelatedName(relatedName)
+                .setRelatedType(relatedType)
+                .setRelatedEntityType(relatedEntityType);
+        return builder.build();
+    }
+
+    private UplinkResponseMsg processUplinkMsg(UplinkMsg uplinkMsg) {
+        try {
+            if (uplinkMsg.getEntityDataList() != null && !uplinkMsg.getEntityDataList().isEmpty()) {
+                for (EntityDataProto entityData : uplinkMsg.getEntityDataList()) {
+                    TbMsg tbMsg = null;
+                    TbMsg originalTbMsg = TbMsg.fromBytes(entityData.getTbMsg().toByteArray());
+                    switch (originalTbMsg.getOriginator().getEntityType()) {
+                        case DEVICE:
+                            String deviceName = entityData.getEntityName();
+                            String deviceType = entityData.getEntityType();
+                            Device device = getOrCreateDevice(deviceName, deviceType);
+                            if (device != null) {
+                                tbMsg = new TbMsg(UUIDs.timeBased(), originalTbMsg.getType(), device.getId(), originalTbMsg.getMetaData().copy(),
+                                        originalTbMsg.getDataType(), originalTbMsg.getData(), null, null, 0L);
+                            }
+                            break;
+                        case ASSET:
+                            String assetName = entityData.getEntityName();
+                            Asset asset = ctx.getAssetService().findAssetByTenantIdAndName(edge.getTenantId(), assetName);
+                            if (asset != null) {
+                                tbMsg = new TbMsg(UUIDs.timeBased(), originalTbMsg.getType(), asset.getId(), originalTbMsg.getMetaData().copy(),
+                                        originalTbMsg.getDataType(), originalTbMsg.getData(), null, null, 0L);
+                            }
+                            break;
+                        case ENTITY_VIEW:
+                            String entityViewName = entityData.getEntityName();
+                            EntityView entityView = ctx.getEntityViewService().findEntityViewByTenantIdAndName(edge.getTenantId(), entityViewName);
+                            if (entityView != null) {
+                                tbMsg = new TbMsg(UUIDs.timeBased(), originalTbMsg.getType(), entityView.getId(), originalTbMsg.getMetaData().copy(),
+                                        originalTbMsg.getDataType(), originalTbMsg.getData(), null, null, 0L);
+                            }
+                            break;
+                    }
+                    if (tbMsg != null) {
+                        ctx.getActorService().onMsg(new SendToClusterMsg(tbMsg.getOriginator(), new ServiceToRuleEngineMsg(edge.getTenantId(), tbMsg)));
+                    }
+                }
+            }
+            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;
+                    }
+                }
+            }
+            if (uplinkMsg.getAlarmUpdatemsgList() != null && !uplinkMsg.getAlarmUpdatemsgList().isEmpty()) {
+                for (AlarmUpdateMsg alarmUpdateMsg : uplinkMsg.getAlarmUpdatemsgList()) {
+                    onAlarmUpdate(alarmUpdateMsg);
+                }
+            }
+        } catch (Exception e) {
+            return UplinkResponseMsg.newBuilder().setSuccess(false).setErrorMsg(e.getMessage()).build();
+        }
+
+        return UplinkResponseMsg.newBuilder().setSuccess(true).build();
+    }
+
+    private EntityId getAlarmOriginator(String entityName, org.thingsboard.server.common.data.EntityType entityType) {
+        switch (entityType) {
+            case DEVICE:
+                return ctx.getDeviceService().findDeviceByTenantIdAndName(edge.getTenantId(), entityName).getId();
+            case ASSET:
+                return ctx.getAssetService().findAssetByTenantIdAndName(edge.getTenantId(), entityName).getId();
+            case ENTITY_VIEW:
+                return ctx.getEntityViewService().findEntityViewByTenantIdAndName(edge.getTenantId(), entityName).getId();
+            default:
+                return null;
+        }
+    }
+
+    private void onAlarmUpdate(AlarmUpdateMsg alarmUpdateMsg) {
+        EntityId originatorId = getAlarmOriginator(alarmUpdateMsg.getOriginatorName(), org.thingsboard.server.common.data.EntityType.valueOf(alarmUpdateMsg.getOriginatorType()));
+        if (originatorId != null) {
+            try {
+                Alarm existentAlarm = ctx.getAlarmService().findLatestByOriginatorAndType(edge.getTenantId(), originatorId, alarmUpdateMsg.getType()).get();
+                switch (alarmUpdateMsg.getMsgType()) {
+                    case ENTITY_CREATED_RPC_MESSAGE:
+                    case ENTITY_UPDATED_RPC_MESSAGE:
+                        if (existentAlarm == null) {
+                            existentAlarm = new Alarm();
+                            existentAlarm.setTenantId(edge.getTenantId());
+                            existentAlarm.setType(alarmUpdateMsg.getName());
+                            existentAlarm.setOriginator(originatorId);
+                            existentAlarm.setSeverity(AlarmSeverity.valueOf(alarmUpdateMsg.getSeverity()));
+                            existentAlarm.setStatus(AlarmStatus.valueOf(alarmUpdateMsg.getStatus()));
+                            existentAlarm.setStartTs(alarmUpdateMsg.getStartTs());
+                            existentAlarm.setAckTs(alarmUpdateMsg.getAckTs());
+                            existentAlarm.setClearTs(alarmUpdateMsg.getClearTs());
+                            existentAlarm.setPropagate(alarmUpdateMsg.getPropagate());
+                        }
+                        existentAlarm.setEndTs(alarmUpdateMsg.getEndTs());
+                        existentAlarm.setDetails(objectMapper.readTree(alarmUpdateMsg.getDetails()));
+                        ctx.getAlarmService().createOrUpdateAlarm(existentAlarm);
+                        break;
+                    case ALARM_ACK_RPC_MESSAGE:
+                        if (existentAlarm != null) {
+                            ctx.getAlarmService().ackAlarm(edge.getTenantId(), existentAlarm.getId(), alarmUpdateMsg.getAckTs());
+                        }
+                        break;
+                    case ALARM_CLEAR_RPC_MESSAGE:
+                        if (existentAlarm != null) {
+                            ctx.getAlarmService().clearAlarm(edge.getTenantId(), existentAlarm.getId(), objectMapper.readTree(alarmUpdateMsg.getDetails()), alarmUpdateMsg.getAckTs());
+                        }
+                        break;
+                    case ENTITY_DELETED_RPC_MESSAGE:
+                        if (existentAlarm != null) {
+                            ctx.getAlarmService().deleteAlarm(edge.getTenantId(), existentAlarm.getId());
+                        }
+                        break;
+                }
+            } catch (Exception e) {
+                log.error("Error during finding existent alarm", e);
+            }
+        }
+    }
+
+    private Device getOrCreateDevice(String deviceName, String deviceType) {
+        Device device = ctx.getDeviceService().findDeviceByTenantIdAndName(edge.getTenantId(), deviceName);
+        if (device == null) {
+            entityCreationLock.lock();
+            try {
+                return processGetOrCreateDevice(deviceName, deviceType);
+            } finally {
+                entityCreationLock.unlock();
+            }
+        }
+        return device;
+    }
+
+    private Device processGetOrCreateDevice(String deviceName, String deviceType) {
+        Device device = ctx.getDeviceService().findDeviceByTenantIdAndName(edge.getTenantId(), deviceName);
+        if (device == null) {
+            device = new Device();
+            device.setName(deviceName);
+            device.setType(deviceType);
+            device.setTenantId(edge.getTenantId());
+            device.setCustomerId(edge.getCustomerId());
+            device = ctx.getDeviceService().saveDevice(device);
+            device = ctx.getDeviceService().assignDeviceToEdge(edge.getTenantId(), device.getId(), edge.getId());
+            createRelationFromEdge(device.getId());
+            ctx.getActorService().onDeviceAdded(device);
+            pushDeviceCreatedEventToRuleEngine(device);
+        }
+        return device;
+    }
+
+    private void pushDeviceCreatedEventToRuleEngine(Device device) {
+        try {
+            ObjectNode entityNode = objectMapper.valueToTree(device);
+            TbMsg msg = new TbMsg(UUIDs.timeBased(), DataConstants.ENTITY_CREATED, device.getId(), deviceActionTbMsgMetaData(device), objectMapper.writeValueAsString(entityNode), null, null, 0L);
+            ctx.getActorService().onMsg(new SendToClusterMsg(device.getId(), new ServiceToRuleEngineMsg(edge.getTenantId(), msg)));
+        } catch (JsonProcessingException | IllegalArgumentException e) {
+            log.warn("[{}] Failed to push device action to rule engine: {}", device.getId(), DataConstants.ENTITY_CREATED, e);
+        }
+    }
+
+    private TbMsgMetaData deviceActionTbMsgMetaData(Device device) {
+        TbMsgMetaData metaData = getTbMsgMetaData();
+        CustomerId customerId = device.getCustomerId();
+        if (customerId != null && !customerId.isNullUid()) {
+            metaData.putValue("customerId", customerId.toString());
+        }
+        return metaData;
+    }
+
+    private TbMsgMetaData getTbMsgMetaData() {
+        TbMsgMetaData metaData = new TbMsgMetaData();
+        metaData.putValue("edgeId", edge.getId().toString());
+        metaData.putValue("edgeName", edge.getName());
+        return metaData;
+    }
+
+    private ConnectResponseMsg processConnect(ConnectRequestMsg request) {
+        Optional<Edge> optional = ctx.getEdgeService().findEdgeByRoutingKey(TenantId.SYS_TENANT_ID, request.getEdgeRoutingKey());
+        if (optional.isPresent()) {
+            edge = optional.get();
+            try {
+                if (edge.getSecret().equals(request.getEdgeSecret())) {
+                    connected = true;
+                    sessionOpenListener.accept(edge.getId(), this);
+                    return ConnectResponseMsg.newBuilder()
+                            .setResponseCode(ConnectResponseCode.ACCEPTED)
+                            .setErrorMsg("")
+                            .setConfiguration(constructEdgeConfigProto(edge)).build();
+                }
+                return ConnectResponseMsg.newBuilder()
+                        .setResponseCode(ConnectResponseCode.BAD_CREDENTIALS)
+                        .setErrorMsg("Failed to validate the edge!")
+                        .setConfiguration(EdgeConfiguration.getDefaultInstance()).build();
+            } catch (Exception e) {
+                log.error("[{}] Failed to process edge connection!", request.getEdgeRoutingKey(), e);
+                return ConnectResponseMsg.newBuilder()
+                        .setResponseCode(ConnectResponseCode.SERVER_UNAVAILABLE)
+                        .setErrorMsg("Failed to process edge connection!")
+                        .setConfiguration(EdgeConfiguration.getDefaultInstance()).build();
+            }
+        }
+        return ConnectResponseMsg.newBuilder()
+                .setResponseCode(ConnectResponseCode.BAD_CREDENTIALS)
+                .setErrorMsg("Failed to find the edge! Routing key: " + request.getEdgeRoutingKey())
+                .setConfiguration(EdgeConfiguration.getDefaultInstance()).build();
+    }
+
+    private void createRelationFromEdge(EntityId entityId) {
+        EntityRelation relation = new EntityRelation();
+        relation.setFrom(edge.getId());
+        relation.setTo(entityId);
+        relation.setTypeGroup(RelationTypeGroup.COMMON);
+        relation.setType(EntityRelation.EDGE_TYPE);
+        ctx.getRelationService().saveRelation(edge.getTenantId(), relation);
+    }
+
+    private EdgeConfiguration constructEdgeConfigProto(Edge edge) throws JsonProcessingException {
+        return EdgeConfiguration.newBuilder()
+                .setTenantIdMSB(edge.getTenantId().getId().getMostSignificantBits())
+                .setTenantIdLSB(edge.getTenantId().getId().getLeastSignificantBits())
+                .setName(edge.getName())
+                .setRoutingKey(edge.getRoutingKey())
+                .setType(edge.getType().toString())
+                .build();
+    }
+}

@@ -211,6 +211,8 @@ public class SqlDatabaseUpgradeService implements DatabaseEntitiesUpgradeService
             case "2.4.3":
             case "2.4.3":
                 try (Connection conn = DriverManager.getConnection(dbUrl, dbUserName, dbPassword)) {
                 try (Connection conn = DriverManager.getConnection(dbUrl, dbUserName, dbPassword)) {
                     log.info("Updating schema ...");
                     log.info("Updating schema ...");
+                    schemaUpdateFile = Paths.get(installScripts.getDataDir(), "upgrade", "2.5.0", SCHEMA_UPDATE_SQL);
+                    loadSql(schemaUpdateFile, conn);
                     try {
                     try {
                         conn.createStatement().execute("ALTER TABLE attribute_kv ADD COLUMN json_v json;");
                         conn.createStatement().execute("ALTER TABLE attribute_kv ADD COLUMN json_v json;");
                     } catch (Exception e) {
                     } catch (Exception e) {
@@ -221,6 +223,24 @@ public class SqlDatabaseUpgradeService implements DatabaseEntitiesUpgradeService
                             }
                             }
                         }
                         }
                     }
                     }
+                    try {
+                        conn.createStatement().execute("ALTER TABLE asset ADD edge_id varchar(31)"); //NOSONAR, ignoring because method used to execute thingsboard database upgrade script
+                    } catch (Exception e) {}
+                    try {
+                        conn.createStatement().execute("ALTER TABLE device ADD edge_id varchar(31)"); //NOSONAR, ignoring because method used to execute thingsboard database upgrade script
+                    } catch (Exception e) {}
+                    try {
+                        conn.createStatement().execute("ALTER TABLE entity_view ADD edge_id varchar(31)"); //NOSONAR, ignoring because method used to execute thingsboard database upgrade script
+                    } catch (Exception e) {}
+                    try {
+                        conn.createStatement().execute("ALTER TABLE dashboard ADD assigned_edges varchar(1000000)"); //NOSONAR, ignoring because method used to execute thingsboard database upgrade script
+                    } catch (Exception e) {}
+                    try {
+                        conn.createStatement().execute("ALTER TABLE rule_chain ADD assigned_edges varchar(1000000)"); //NOSONAR, ignoring because method used to execute thingsboard database upgrade script
+                    } catch (Exception e) {}
+                    try {
+                        conn.createStatement().execute("ALTER TABLE rule_chain ADD type varchar(255) DEFAULT 'SYSTEM'"); //NOSONAR, ignoring because method used to execute thingsboard database upgrade script
+                    } catch (Exception e) {}
                     log.info("Schema updated.");
                     log.info("Schema updated.");
                 }
                 }
                 break;
                 break;

@@ -30,10 +30,12 @@ import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.EntityView;
 import org.thingsboard.server.common.data.EntityView;
 import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.Tenant;
 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.exception.ThingsboardException;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
 import org.thingsboard.server.common.data.id.EntityViewId;
 import org.thingsboard.server.common.data.id.EntityViewId;
@@ -47,6 +49,7 @@ import org.thingsboard.server.dao.alarm.AlarmService;
 import org.thingsboard.server.dao.asset.AssetService;
 import org.thingsboard.server.dao.asset.AssetService;
 import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.dao.device.DeviceService;
 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.entityview.EntityViewService;
 import org.thingsboard.server.dao.rule.RuleChainService;
 import org.thingsboard.server.dao.rule.RuleChainService;
 import org.thingsboard.server.dao.tenant.TenantService;
 import org.thingsboard.server.dao.tenant.TenantService;
@@ -74,6 +77,7 @@ public class AccessValidator {
     public static final String SYSTEM_ADMINISTRATOR_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION = "System administrator is not allowed to perform this operation!";
     public static final String SYSTEM_ADMINISTRATOR_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION = "System administrator is not allowed to perform this operation!";
     public static final String DEVICE_WITH_REQUESTED_ID_NOT_FOUND = "Device with requested id wasn't found!";
     public static final String DEVICE_WITH_REQUESTED_ID_NOT_FOUND = "Device with requested id wasn't found!";
     public static final String ENTITY_VIEW_WITH_REQUESTED_ID_NOT_FOUND = "Entity-view with requested id wasn't found!";
     public static final String ENTITY_VIEW_WITH_REQUESTED_ID_NOT_FOUND = "Entity-view with requested id wasn't found!";
+    public static final String EDGE_WITH_REQUESTED_ID_NOT_FOUND = "Edge with requested id wasn't found!";
 
 
     @Autowired
     @Autowired
     protected TenantService tenantService;
     protected TenantService tenantService;
@@ -100,6 +104,9 @@ public class AccessValidator {
     protected EntityViewService entityViewService;
     protected EntityViewService entityViewService;
 
 
     @Autowired
     @Autowired
+    protected EdgeService edgeService;
+
+    @Autowired
     protected AccessControlService accessControlService;
     protected AccessControlService accessControlService;
 
 
     private ExecutorService executor;
     private ExecutorService executor;
@@ -175,6 +182,9 @@ public class AccessValidator {
             case ENTITY_VIEW:
             case ENTITY_VIEW:
                 validateEntityView(currentUser, operation, entityId, callback);
                 validateEntityView(currentUser, operation, entityId, callback);
                 return;
                 return;
+            case EDGE:
+                validateEdge(currentUser, operation, entityId, callback);
+                return;
             default:
             default:
                 //TODO: add support of other entities
                 //TODO: add support of other entities
                 throw new IllegalStateException("Not Implemented!");
                 throw new IllegalStateException("Not Implemented!");
@@ -328,6 +338,26 @@ public class AccessValidator {
         }
         }
     }
     }
 
 
+    private void validateEdge(final SecurityUser currentUser, Operation operation, EntityId entityId, FutureCallback<ValidationResult> callback) {
+        if (currentUser.isSystemAdmin()) {
+            callback.onSuccess(ValidationResult.accessDenied(SYSTEM_ADMINISTRATOR_IS_NOT_ALLOWED_TO_PERFORM_THIS_OPERATION));
+        } else {
+            ListenableFuture<Edge> edgeFuture = edgeService.findEdgeByIdAsync(currentUser.getTenantId(), new EdgeId(entityId.getId()));
+            Futures.addCallback(edgeFuture, getCallback(callback, edge -> {
+                if (edge == null) {
+                    return ValidationResult.entityNotFound(EDGE_WITH_REQUESTED_ID_NOT_FOUND);
+                } else {
+                    try {
+                        accessControlService.checkPermission(currentUser, Resource.EDGE, operation, entityId, edge);
+                    } catch (ThingsboardException e) {
+                        return ValidationResult.accessDenied(e.getMessage());
+                    }
+                    return ValidationResult.ok(edge);
+                }
+            }), executor);
+        }
+    }
+
     private <T, V> FutureCallback<T> getCallback(FutureCallback<ValidationResult> callback, Function<T, ValidationResult<V>> transformer) {
     private <T, V> FutureCallback<T> getCallback(FutureCallback<ValidationResult> callback, Function<T, ValidationResult<V>> transformer) {
         return new FutureCallback<T>() {
         return new FutureCallback<T>() {
             @Override
             @Override

@@ -37,6 +37,7 @@ public class CustomerUserPermissions extends AbstractPermissions {
         put(Resource.CUSTOMER, customerPermissionChecker);
         put(Resource.CUSTOMER, customerPermissionChecker);
         put(Resource.DASHBOARD, customerDashboardPermissionChecker);
         put(Resource.DASHBOARD, customerDashboardPermissionChecker);
         put(Resource.ENTITY_VIEW, customerEntityPermissionChecker);
         put(Resource.ENTITY_VIEW, customerEntityPermissionChecker);
+        put(Resource.EDGE, customerEntityPermissionChecker);
         put(Resource.USER, userPermissionChecker);
         put(Resource.USER, userPermissionChecker);
         put(Resource.WIDGETS_BUNDLE, widgetsPermissionChecker);
         put(Resource.WIDGETS_BUNDLE, widgetsPermissionChecker);
         put(Resource.WIDGET_TYPE, widgetsPermissionChecker);
         put(Resource.WIDGET_TYPE, widgetsPermissionChecker);

@@ -18,6 +18,7 @@ package org.thingsboard.server.service.security.permission;
 public enum Operation {
 public enum Operation {
 
 
     ALL, CREATE, READ, WRITE, DELETE, ASSIGN_TO_CUSTOMER, UNASSIGN_FROM_CUSTOMER, RPC_CALL,
     ALL, CREATE, READ, WRITE, DELETE, ASSIGN_TO_CUSTOMER, UNASSIGN_FROM_CUSTOMER, RPC_CALL,
-    READ_CREDENTIALS, WRITE_CREDENTIALS, READ_ATTRIBUTES, WRITE_ATTRIBUTES, READ_TELEMETRY, WRITE_TELEMETRY, CLAIM_DEVICES
+    READ_CREDENTIALS, WRITE_CREDENTIALS, READ_ATTRIBUTES, WRITE_ATTRIBUTES, READ_TELEMETRY, WRITE_TELEMETRY, CLAIM_DEVICES,
+    ASSIGN_TO_EDGE, UNASSIGN_FROM_EDGE
 
 
 }
 }

@@ -27,6 +27,7 @@ public enum Resource {
     CUSTOMER(EntityType.CUSTOMER),
     CUSTOMER(EntityType.CUSTOMER),
     DASHBOARD(EntityType.DASHBOARD),
     DASHBOARD(EntityType.DASHBOARD),
     ENTITY_VIEW(EntityType.ENTITY_VIEW),
     ENTITY_VIEW(EntityType.ENTITY_VIEW),
+    EDGE(EntityType.EDGE),
     TENANT(EntityType.TENANT),
     TENANT(EntityType.TENANT),
     RULE_CHAIN(EntityType.RULE_CHAIN),
     RULE_CHAIN(EntityType.RULE_CHAIN),
     USER(EntityType.USER),
     USER(EntityType.USER),

@@ -37,6 +37,7 @@ public class TenantAdminPermissions extends AbstractPermissions {
         put(Resource.CUSTOMER, tenantEntityPermissionChecker);
         put(Resource.CUSTOMER, tenantEntityPermissionChecker);
         put(Resource.DASHBOARD, tenantEntityPermissionChecker);
         put(Resource.DASHBOARD, tenantEntityPermissionChecker);
         put(Resource.ENTITY_VIEW, tenantEntityPermissionChecker);
         put(Resource.ENTITY_VIEW, tenantEntityPermissionChecker);
+        put(Resource.EDGE, tenantEntityPermissionChecker);
         put(Resource.TENANT, tenantPermissionChecker);
         put(Resource.TENANT, tenantPermissionChecker);
         put(Resource.RULE_CHAIN, tenantEntityPermissionChecker);
         put(Resource.RULE_CHAIN, tenantEntityPermissionChecker);
         put(Resource.USER, userPermissionChecker);
         put(Resource.USER, userPermissionChecker);

@@ -26,6 +26,7 @@
     </appender>
     </appender>
 
 
     <logger name="org.thingsboard.server" level="INFO" />
     <logger name="org.thingsboard.server" level="INFO" />
+    <logger name="org.thingsboard.server.service.edge" level="TRACE" />
     <logger name="akka" level="INFO" />
     <logger name="akka" level="INFO" />
 
 
     <root level="INFO">
     <root level="INFO">

@@ -294,6 +294,9 @@ caffeine:
     securitySettings:
     securitySettings:
       timeToLiveInMinutes: 1440
       timeToLiveInMinutes: 1440
       maxSize: 1
       maxSize: 1
+    edges:
+      timeToLiveInMinutes: 1440
+      maxSize: 100000
 
 
 redis:
 redis:
   # standalone or cluster
   # standalone or cluster
@@ -558,6 +561,17 @@ transport:
     bind_port: "${COAP_BIND_PORT:5683}"
     bind_port: "${COAP_BIND_PORT:5683}"
     timeout: "${COAP_TIMEOUT:10000}"
     timeout: "${COAP_TIMEOUT:10000}"
 
 
+# Edges parameters
+edges:
+  rpc:
+    enabled: "${EDGES_RPC_ENABLED:true}"
+    port: "${EDGES_RPC_PORT:60061}"
+    ssl:
+      # Enable/disable SSL support
+      enabled: "${EDGES_RPC_SSL_ENABLED:false}"
+      cert: "${EDGES_RPC_SSL_CERT:certChainFile.pem}"
+      privateKey: "${EDGES_RPC_SSL_PRIVATE_KEY:privateKeyFile.pem}"
+
 swagger:
 swagger:
   api_path_regex: "${SWAGGER_API_PATH_REGEX:/api.*}"
   api_path_regex: "${SWAGGER_API_PATH_REGEX:/api.*}"
   security_path_regex: "${SWAGGER_SECURITY_PATH_REGEX:/api.*}"
   security_path_regex: "${SWAGGER_SECURITY_PATH_REGEX:/api.*}"

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.controller;
+
+import com.datastax.driver.core.utils.UUIDs;
+import com.fasterxml.jackson.core.type.TypeReference;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.Customer;
+import org.thingsboard.server.common.data.EntitySubtype;
+import org.thingsboard.server.common.data.Tenant;
+import org.thingsboard.server.common.data.User;
+import org.thingsboard.server.common.data.edge.Edge;
+import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.page.PageData;
+import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.page.PageData;
+import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.security.Authority;
+import org.thingsboard.server.dao.model.ModelConstants;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.thingsboard.server.dao.model.ModelConstants.NULL_UUID;
+
+public abstract class BaseEdgeControllerTest extends AbstractControllerTest {
+
+    private IdComparator<Edge> idComparator = new IdComparator<>();
+
+    private Tenant savedTenant;
+    private User tenantAdmin;
+
+    @Before
+    public void beforeTest() throws Exception {
+        loginSysAdmin();
+
+        Tenant tenant = new Tenant();
+        tenant.setTitle("My tenant");
+        savedTenant = doPost("/api/tenant", tenant, Tenant.class);
+        Assert.assertNotNull(savedTenant);
+
+        tenantAdmin = new User();
+        tenantAdmin.setAuthority(Authority.TENANT_ADMIN);
+        tenantAdmin.setTenantId(savedTenant.getId());
+        tenantAdmin.setEmail("tenant2@thingsboard.org");
+        tenantAdmin.setFirstName("Joe");
+        tenantAdmin.setLastName("Downs");
+
+        tenantAdmin = createUserAndLogin(tenantAdmin, "testPassword1");
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        loginSysAdmin();
+
+        doDelete("/api/tenant/" + savedTenant.getId().getId().toString())
+                .andExpect(status().isOk());
+    }
+
+    @Test
+    public void testSaveEdge() throws Exception {
+        Edge edge = new Edge();
+        edge.setName("My edge");
+        edge.setType("default");
+        Edge savedEdge = doPost("/api/edge", edge, Edge.class);
+
+        Assert.assertNotNull(savedEdge);
+        Assert.assertNotNull(savedEdge.getId());
+        Assert.assertTrue(savedEdge.getCreatedTime() > 0);
+        Assert.assertEquals(savedTenant.getId(), savedEdge.getTenantId());
+        Assert.assertNotNull(savedEdge.getCustomerId());
+        Assert.assertEquals(NULL_UUID, savedEdge.getCustomerId().getId());
+        Assert.assertEquals(edge.getName(), savedEdge.getName());
+
+        savedEdge.setName("My new edge");
+        doPost("/api/edge", savedEdge, Edge.class);
+
+        Edge foundEdge = doGet("/api/edge/" + savedEdge.getId().getId().toString(), Edge.class);
+        Assert.assertEquals(foundEdge.getName(), savedEdge.getName());
+    }
+
+    @Test
+    public void testFindEdgeById() throws Exception {
+        Edge edge = new Edge();
+        edge.setName("My edge");
+        edge.setType("default");
+        Edge savedEdge = doPost("/api/edge", edge, Edge.class);
+        Edge foundEdge = doGet("/api/edge/" + savedEdge.getId().getId().toString(), Edge.class);
+        Assert.assertNotNull(foundEdge);
+        Assert.assertEquals(savedEdge, foundEdge);
+    }
+
+    @Test
+    public void testFindEdgeTypesByTenantId() throws Exception {
+        List<Edge> edges = new ArrayList<>();
+        for (int i = 0; i < 3; i++) {
+            Edge edge = new Edge();
+            edge.setName("My edge B" + i);
+            edge.setType("typeB");
+            edges.add(doPost("/api/edge", edge, Edge.class));
+        }
+        for (int i = 0; i < 7; i++) {
+            Edge edge = new Edge();
+            edge.setName("My edge C" + i);
+            edge.setType("typeC");
+            edges.add(doPost("/api/edge", edge, Edge.class));
+        }
+        for (int i = 0; i < 9; i++) {
+            Edge edge = new Edge();
+            edge.setName("My edge A" + i);
+            edge.setType("typeA");
+            edges.add(doPost("/api/edge", edge, Edge.class));
+        }
+        List<EntitySubtype> edgeTypes = doGetTyped("/api/edge/types",
+                new TypeReference<List<EntitySubtype>>() {
+                });
+
+        Assert.assertNotNull(edgeTypes);
+        Assert.assertEquals(3, edgeTypes.size());
+        Assert.assertEquals("typeA", edgeTypes.get(0).getType());
+        Assert.assertEquals("typeB", edgeTypes.get(1).getType());
+        Assert.assertEquals("typeC", edgeTypes.get(2).getType());
+    }
+
+    @Test
+    public void testDeleteEdge() throws Exception {
+        Edge edge = new Edge();
+        edge.setName("My edge");
+        edge.setType("default");
+        Edge savedEdge = doPost("/api/edge", edge, Edge.class);
+
+        doDelete("/api/edge/" + savedEdge.getId().getId().toString())
+                .andExpect(status().isOk());
+
+        doGet("/api/edge/" + savedEdge.getId().getId().toString())
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    public void testSaveEdgeWithEmptyType() throws Exception {
+        Edge edge = new Edge();
+        edge.setName("My edge");
+        doPost("/api/edge", edge)
+                .andExpect(status().isBadRequest())
+                .andExpect(statusReason(containsString("Edge type should be specified")));
+    }
+
+    @Test
+    public void testSaveEdgeWithEmptyName() throws Exception {
+        Edge edge = new Edge();
+        edge.setType("default");
+        doPost("/api/edge", edge)
+                .andExpect(status().isBadRequest())
+                .andExpect(statusReason(containsString("Edge name should be specified")));
+    }
+
+    @Test
+    public void testAssignUnassignEdgeToCustomer() throws Exception {
+        Edge edge = new Edge();
+        edge.setName("My edge");
+        edge.setType("default");
+        Edge savedEdge = doPost("/api/edge", edge, Edge.class);
+
+        Customer customer = new Customer();
+        customer.setTitle("My customer");
+        Customer savedCustomer = doPost("/api/customer", customer, Customer.class);
+
+        Edge assignedEdge = doPost("/api/customer/" + savedCustomer.getId().getId().toString()
+                + "/edge/" + savedEdge.getId().getId().toString(), Edge.class);
+        Assert.assertEquals(savedCustomer.getId(), assignedEdge.getCustomerId());
+
+        Edge foundEdge = doGet("/api/edge/" + savedEdge.getId().getId().toString(), Edge.class);
+        Assert.assertEquals(savedCustomer.getId(), foundEdge.getCustomerId());
+
+        Edge unassignedEdge =
+                doDelete("/api/customer/edge/" + savedEdge.getId().getId().toString(), Edge.class);
+        Assert.assertEquals(ModelConstants.NULL_UUID, unassignedEdge.getCustomerId().getId());
+
+        foundEdge = doGet("/api/edge/" + savedEdge.getId().getId().toString(), Edge.class);
+        Assert.assertEquals(ModelConstants.NULL_UUID, foundEdge.getCustomerId().getId());
+    }
+
+    @Test
+    public void testAssignEdgeToNonExistentCustomer() throws Exception {
+        Edge edge = new Edge();
+        edge.setName("My edge");
+        edge.setType("default");
+        Edge savedEdge = doPost("/api/edge", edge, Edge.class);
+
+        doPost("/api/customer/" + UUIDs.timeBased().toString()
+                + "/edge/" + savedEdge.getId().getId().toString())
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    public void testAssignEdgeToCustomerFromDifferentTenant() throws Exception {
+        loginSysAdmin();
+
+        Tenant tenant2 = new Tenant();
+        tenant2.setTitle("Different tenant");
+        Tenant savedTenant2 = doPost("/api/tenant", tenant2, Tenant.class);
+        Assert.assertNotNull(savedTenant2);
+
+        User tenantAdmin2 = new User();
+        tenantAdmin2.setAuthority(Authority.TENANT_ADMIN);
+        tenantAdmin2.setTenantId(savedTenant2.getId());
+        tenantAdmin2.setEmail("tenant3@thingsboard.org");
+        tenantAdmin2.setFirstName("Joe");
+        tenantAdmin2.setLastName("Downs");
+
+        tenantAdmin2 = createUserAndLogin(tenantAdmin2, "testPassword1");
+
+        Customer customer = new Customer();
+        customer.setTitle("Different customer");
+        Customer savedCustomer = doPost("/api/customer", customer, Customer.class);
+
+        login(tenantAdmin.getEmail(), "testPassword1");
+
+        Edge edge = new Edge();
+        edge.setName("My edge");
+        edge.setType("default");
+        Edge savedEdge = doPost("/api/edge", edge, Edge.class);
+
+        doPost("/api/customer/" + savedCustomer.getId().getId().toString()
+                + "/edge/" + savedEdge.getId().getId().toString())
+                .andExpect(status().isForbidden());
+
+        loginSysAdmin();
+
+        doDelete("/api/tenant/" + savedTenant2.getId().getId().toString())
+                .andExpect(status().isOk());
+    }
+
+    @Test
+    public void testFindTenantEdges() throws Exception {
+        List<Edge> edges = new ArrayList<>();
+        for (int i = 0; i < 178; i++) {
+            Edge edge = new Edge();
+            edge.setName("Edge" + i);
+            edge.setType("default");
+            edges.add(doPost("/api/edge", edge, Edge.class));
+        }
+        List<Edge> loadedEdges = new ArrayList<>();
+        PageLink pageLink = new PageLink(23);
+        PageData<Edge> pageData = null;
+        do {
+            pageData = doGetTypedWithPageLink("/api/tenant/edges?",
+                    new TypeReference<PageData<Edge>>() {
+                    }, pageLink);
+            loadedEdges.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(edges, idComparator);
+        Collections.sort(loadedEdges, idComparator);
+
+        Assert.assertEquals(edges, loadedEdges);
+    }
+
+    @Test
+    public void testFindTenantEdgesByName() throws Exception {
+        String title1 = "Edge title 1";
+        List<Edge> edgesTitle1 = new ArrayList<>();
+        for (int i = 0; i < 143; i++) {
+            Edge edge = new Edge();
+            String suffix = RandomStringUtils.randomAlphanumeric(15);
+            String name = title1 + suffix;
+            name = i % 2 == 0 ? name.toLowerCase() : name.toUpperCase();
+            edge.setName(name);
+            edge.setType("default");
+            edgesTitle1.add(doPost("/api/edge", edge, Edge.class));
+        }
+        String title2 = "Edge title 2";
+        List<Edge> edgesTitle2 = new ArrayList<>();
+        for (int i = 0; i < 75; i++) {
+            Edge edge = new Edge();
+            String suffix = RandomStringUtils.randomAlphanumeric(15);
+            String name = title2 + suffix;
+            name = i % 2 == 0 ? name.toLowerCase() : name.toUpperCase();
+            edge.setName(name);
+            edge.setType("default");
+            edgesTitle2.add(doPost("/api/edge", edge, Edge.class));
+        }
+
+        List<Edge> loadedEdgesTitle1 = new ArrayList<>();
+        PageLink pageLink = new PageLink(15, 0, title1);
+        PageData<Edge> pageData = null;
+        do {
+            pageData = doGetTypedWithPageLink("/api/tenant/edges?",
+                    new TypeReference<PageData<Edge>>() {
+                    }, pageLink);
+            loadedEdgesTitle1.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(edgesTitle1, idComparator);
+        Collections.sort(loadedEdgesTitle1, idComparator);
+
+        Assert.assertEquals(edgesTitle1, loadedEdgesTitle1);
+
+        List<Edge> loadedEdgesTitle2 = new ArrayList<>();
+        pageLink = new PageLink(4, 0, title2);
+        do {
+            pageData = doGetTypedWithPageLink("/api/tenant/edges?",
+                    new TypeReference<PageData<Edge>>() {
+                    }, pageLink);
+            loadedEdgesTitle2.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(edgesTitle2, idComparator);
+        Collections.sort(loadedEdgesTitle2, idComparator);
+
+        Assert.assertEquals(edgesTitle2, loadedEdgesTitle2);
+
+        for (Edge edge : loadedEdgesTitle1) {
+            doDelete("/api/edge/" + edge.getId().getId().toString())
+                    .andExpect(status().isOk());
+        }
+
+        pageLink = new PageLink(4, 0, title1);
+        pageData = doGetTypedWithPageLink("/api/tenant/edges?",
+                new TypeReference<PageData<Edge>>() {
+                }, pageLink);
+        Assert.assertFalse(pageData.hasNext());
+        Assert.assertEquals(0, pageData.getData().size());
+
+        for (Edge edge : loadedEdgesTitle2) {
+            doDelete("/api/edge/" + edge.getId().getId().toString())
+                    .andExpect(status().isOk());
+        }
+
+        pageLink = new PageLink(4, 0, title2);
+        pageData = doGetTypedWithPageLink("/api/tenant/edges?",
+                new TypeReference<PageData<Edge>>() {
+                }, pageLink);
+        Assert.assertFalse(pageData.hasNext());
+        Assert.assertEquals(0, pageData.getData().size());
+    }
+
+    @Test
+    public void testFindTenantEdgesByType() throws Exception {
+        String title1 = "Edge title 1";
+        String type1 = "typeA";
+        List<Edge> edgesType1 = new ArrayList<>();
+        for (int i = 0; i < 143; i++) {
+            Edge edge = new Edge();
+            String suffix = RandomStringUtils.randomAlphanumeric(15);
+            String name = title1 + suffix;
+            name = i % 2 == 0 ? name.toLowerCase() : name.toUpperCase();
+            edge.setName(name);
+            edge.setType(type1);
+            edgesType1.add(doPost("/api/edge", edge, Edge.class));
+        }
+        String title2 = "Edge title 2";
+        String type2 = "typeB";
+        List<Edge> edgesType2 = new ArrayList<>();
+        for (int i = 0; i < 75; i++) {
+            Edge edge = new Edge();
+            String suffix = RandomStringUtils.randomAlphanumeric(15);
+            String name = title2 + suffix;
+            name = i % 2 == 0 ? name.toLowerCase() : name.toUpperCase();
+            edge.setName(name);
+            edge.setType(type2);
+            edgesType2.add(doPost("/api/edge", edge, Edge.class));
+        }
+
+        List<Edge> loadedEdgesType1 = new ArrayList<>();
+        PageLink pageLink = new PageLink(15);
+        PageData<Edge> pageData = null;
+        do {
+            pageData = doGetTypedWithPageLink("/api/tenant/edges?type={type}&",
+                    new TypeReference<PageData<Edge>>() {
+                    }, pageLink, type1);
+            loadedEdgesType1.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(edgesType1, idComparator);
+        Collections.sort(loadedEdgesType1, idComparator);
+
+        Assert.assertEquals(edgesType1, loadedEdgesType1);
+
+        List<Edge> loadedEdgesType2 = new ArrayList<>();
+        pageLink = new PageLink(4);
+        do {
+            pageData = doGetTypedWithPageLink("/api/tenant/edges?type={type}&",
+                    new TypeReference<PageData<Edge>>() {
+                    }, pageLink, type2);
+            loadedEdgesType2.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(edgesType2, idComparator);
+        Collections.sort(loadedEdgesType2, idComparator);
+
+        Assert.assertEquals(edgesType2, loadedEdgesType2);
+
+        for (Edge edge : loadedEdgesType1) {
+            doDelete("/api/edge/" + edge.getId().getId().toString())
+                    .andExpect(status().isOk());
+        }
+
+        pageLink = new PageLink(4);
+        pageData = doGetTypedWithPageLink("/api/tenant/edges?type={type}&",
+                new TypeReference<PageData<Edge>>() {
+                }, pageLink, type1);
+        Assert.assertFalse(pageData.hasNext());
+        Assert.assertEquals(0, pageData.getData().size());
+
+        for (Edge edge : loadedEdgesType2) {
+            doDelete("/api/edge/" + edge.getId().getId().toString())
+                    .andExpect(status().isOk());
+        }
+
+        pageLink = new PageLink(4);
+        pageData = doGetTypedWithPageLink("/api/tenant/edges?type={type}&",
+                new TypeReference<PageData<Edge>>() {
+                }, pageLink, type2);
+        Assert.assertFalse(pageData.hasNext());
+        Assert.assertEquals(0, pageData.getData().size());
+    }
+
+    @Test
+    public void testFindCustomerEdges() throws Exception {
+        Customer customer = new Customer();
+        customer.setTitle("Test customer");
+        customer = doPost("/api/customer", customer, Customer.class);
+        CustomerId customerId = customer.getId();
+
+        List<Edge> edges = new ArrayList<>();
+        for (int i = 0; i < 128; i++) {
+            Edge edge = new Edge();
+            edge.setName("Edge" + i);
+            edge.setType("default");
+            edge = doPost("/api/edge", edge, Edge.class);
+            edges.add(doPost("/api/customer/" + customerId.getId().toString()
+                    + "/edge/" + edge.getId().getId().toString(), Edge.class));
+        }
+
+        List<Edge> loadedEdges = new ArrayList<>();
+        PageLink pageLink = new PageLink(23);
+        PageData<Edge> pageData = null;
+        do {
+            pageData = doGetTypedWithPageLink("/api/customer/" + customerId.getId().toString() + "/edges?",
+                    new TypeReference<PageData<Edge>>() {
+                    }, pageLink);
+            loadedEdges.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(edges, idComparator);
+        Collections.sort(loadedEdges, idComparator);
+
+        Assert.assertEquals(edges, loadedEdges);
+    }
+
+    @Test
+    public void testFindCustomerEdgesByName() throws Exception {
+        Customer customer = new Customer();
+        customer.setTitle("Test customer");
+        customer = doPost("/api/customer", customer, Customer.class);
+        CustomerId customerId = customer.getId();
+
+        String title1 = "Edge title 1";
+        List<Edge> edgesTitle1 = new ArrayList<>();
+        for (int i = 0; i < 125; i++) {
+            Edge edge = new Edge();
+            String suffix = RandomStringUtils.randomAlphanumeric(15);
+            String name = title1 + suffix;
+            name = i % 2 == 0 ? name.toLowerCase() : name.toUpperCase();
+            edge.setName(name);
+            edge.setType("default");
+            edge = doPost("/api/edge", edge, Edge.class);
+            edgesTitle1.add(doPost("/api/customer/" + customerId.getId().toString()
+                    + "/edge/" + edge.getId().getId().toString(), Edge.class));
+        }
+        String title2 = "Edge title 2";
+        List<Edge> edgesTitle2 = new ArrayList<>();
+        for (int i = 0; i < 143; i++) {
+            Edge edge = new Edge();
+            String suffix = RandomStringUtils.randomAlphanumeric(15);
+            String name = title2 + suffix;
+            name = i % 2 == 0 ? name.toLowerCase() : name.toUpperCase();
+            edge.setName(name);
+            edge.setType("default");
+            edge = doPost("/api/edge", edge, Edge.class);
+            edgesTitle2.add(doPost("/api/customer/" + customerId.getId().toString()
+                    + "/edge/" + edge.getId().getId().toString(), Edge.class));
+        }
+
+        List<Edge> loadedEdgesTitle1 = new ArrayList<>();
+        PageLink pageLink = new PageLink(15,0, title1);
+        PageData<Edge> pageData = null;
+        do {
+            pageData = doGetTypedWithPageLink("/api/customer/" + customerId.getId().toString() + "/edges?",
+                    new TypeReference<PageData<Edge>>() {
+                    }, pageLink);
+            loadedEdgesTitle1.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(edgesTitle1, idComparator);
+        Collections.sort(loadedEdgesTitle1, idComparator);
+
+        Assert.assertEquals(edgesTitle1, loadedEdgesTitle1);
+
+        List<Edge> loadedEdgesTitle2 = new ArrayList<>();
+        pageLink = new PageLink(4,0, title2);
+        do {
+            pageData = doGetTypedWithPageLink("/api/customer/" + customerId.getId().toString() + "/edges?",
+                    new TypeReference<PageData<Edge>>() {
+                    }, pageLink);
+            loadedEdgesTitle2.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(edgesTitle2, idComparator);
+        Collections.sort(loadedEdgesTitle2, idComparator);
+
+        Assert.assertEquals(edgesTitle2, loadedEdgesTitle2);
+
+        for (Edge edge : loadedEdgesTitle1) {
+            doDelete("/api/customer/edge/" + edge.getId().getId().toString())
+                    .andExpect(status().isOk());
+        }
+
+        pageLink = new PageLink(4, 0, title1);
+        pageData = doGetTypedWithPageLink("/api/customer/" + customerId.getId().toString() + "/edges?",
+                new TypeReference<PageData<Edge>>() {
+                }, pageLink);
+        Assert.assertFalse(pageData.hasNext());
+        Assert.assertEquals(0, pageData.getData().size());
+
+        for (Edge edge : loadedEdgesTitle2) {
+            doDelete("/api/customer/edge/" + edge.getId().getId().toString())
+                    .andExpect(status().isOk());
+        }
+
+        pageLink = new PageLink(4, 0, title2);
+        pageData = doGetTypedWithPageLink("/api/customer/" + customerId.getId().toString() + "/edges?",
+                new TypeReference<PageData<Edge>>() {
+                }, pageLink);
+        Assert.assertFalse(pageData.hasNext());
+        Assert.assertEquals(0, pageData.getData().size());
+    }
+
+    @Test
+    public void testFindCustomerEdgesByType() throws Exception {
+        Customer customer = new Customer();
+        customer.setTitle("Test customer");
+        customer = doPost("/api/customer", customer, Customer.class);
+        CustomerId customerId = customer.getId();
+
+        String title1 = "Edge title 1";
+        String type1 = "typeC";
+        List<Edge> edgesType1 = new ArrayList<>();
+        for (int i = 0; i < 125; i++) {
+            Edge edge = new Edge();
+            String suffix = RandomStringUtils.randomAlphanumeric(15);
+            String name = title1 + suffix;
+            name = i % 2 == 0 ? name.toLowerCase() : name.toUpperCase();
+            edge.setName(name);
+            edge.setType(type1);
+            edge = doPost("/api/edge", edge, Edge.class);
+            edgesType1.add(doPost("/api/customer/" + customerId.getId().toString()
+                    + "/edge/" + edge.getId().getId().toString(), Edge.class));
+        }
+        String title2 = "Edge title 2";
+        String type2 = "typeD";
+        List<Edge> edgesType2 = new ArrayList<>();
+        for (int i = 0; i < 143; i++) {
+            Edge edge = new Edge();
+            String suffix = RandomStringUtils.randomAlphanumeric(15);
+            String name = title2 + suffix;
+            name = i % 2 == 0 ? name.toLowerCase() : name.toUpperCase();
+            edge.setName(name);
+            edge.setType(type2);
+            edge = doPost("/api/edge", edge, Edge.class);
+            edgesType2.add(doPost("/api/customer/" + customerId.getId().toString()
+                    + "/edge/" + edge.getId().getId().toString(), Edge.class));
+        }
+
+        List<Edge> loadedEdgesType1 = new ArrayList<>();
+        PageLink pageLink = new PageLink(15, 0, title1);
+        PageData<Edge> pageData = null;
+        do {
+            pageData = doGetTypedWithPageLink("/api/customer/" + customerId.getId().toString() + "/edges?type={type}&",
+                    new TypeReference<PageData<Edge>>() {
+                    }, pageLink, type1);
+            loadedEdgesType1.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(edgesType1, idComparator);
+        Collections.sort(loadedEdgesType1, idComparator);
+
+        Assert.assertEquals(edgesType1, loadedEdgesType1);
+
+        List<Edge> loadedEdgesType2 = new ArrayList<>();
+        pageLink = new PageLink(4, 0, title2);
+        do {
+            pageData = doGetTypedWithPageLink("/api/customer/" + customerId.getId().toString() + "/edges?type={type}&",
+                    new TypeReference<PageData<Edge>>() {
+                    }, pageLink, type2);
+            loadedEdgesType2.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(edgesType2, idComparator);
+        Collections.sort(loadedEdgesType2, idComparator);
+
+        Assert.assertEquals(edgesType2, loadedEdgesType2);
+
+        for (Edge edge : loadedEdgesType1) {
+            doDelete("/api/customer/edge/" + edge.getId().getId().toString())
+                    .andExpect(status().isOk());
+        }
+
+        pageLink = new PageLink(4, 0, title1);
+        pageData = doGetTypedWithPageLink("/api/customer/" + customerId.getId().toString() + "/edges?type={type}&",
+                new TypeReference<PageData<Edge>>() {
+                }, pageLink, type1);
+        Assert.assertFalse(pageData.hasNext());
+        Assert.assertEquals(0, pageData.getData().size());
+
+        for (Edge edge : loadedEdgesType2) {
+            doDelete("/api/customer/edge/" + edge.getId().getId().toString())
+                    .andExpect(status().isOk());
+        }
+
+        pageLink = new PageLink(4, 0, title2);
+        pageData = doGetTypedWithPageLink("/api/customer/" + customerId.getId().toString() + "/edges?type={type}&",
+                new TypeReference<PageData<Edge>>() {
+                }, pageLink, type2);
+        Assert.assertFalse(pageData.hasNext());
+        Assert.assertEquals(0, pageData.getData().size());
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.controller.sql;
+
+import org.thingsboard.server.controller.BaseEdgeControllerTest;
+import org.thingsboard.server.dao.service.DaoSqlTest;
+
+@DaoSqlTest
+public class EdgeControllerSqlTest extends BaseEdgeControllerTest {
+}

@@ -22,6 +22,7 @@ import org.thingsboard.server.common.data.asset.AssetInfo;
 import org.thingsboard.server.common.data.asset.AssetSearchQuery;
 import org.thingsboard.server.common.data.asset.AssetSearchQuery;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
@@ -74,4 +75,12 @@ public interface AssetService {
     ListenableFuture<List<Asset>> findAssetsByQuery(TenantId tenantId, AssetSearchQuery query);
     ListenableFuture<List<Asset>> findAssetsByQuery(TenantId tenantId, AssetSearchQuery query);
 
 
     ListenableFuture<List<EntitySubtype>> findAssetTypesByTenantId(TenantId tenantId);
     ListenableFuture<List<EntitySubtype>> findAssetTypesByTenantId(TenantId tenantId);
+
+    Asset assignAssetToEdge(TenantId tenantId, AssetId assetId, EdgeId edgeId);
+
+    Asset unassignAssetFromEdge(TenantId tenantId, AssetId assetId);
+
+    PageData<Asset> findAssetsByTenantIdAndEdgeId(TenantId tenantId, EdgeId edgeId, PageLink pageLink);
+
+    PageData<Asset> findAssetsByTenantIdAndEdgeIdAndType(TenantId tenantId, EdgeId edgeId, String type, PageLink pageLink);
 }
 }

@@ -20,6 +20,7 @@ import org.thingsboard.server.common.data.Dashboard;
 import org.thingsboard.server.common.data.DashboardInfo;
 import org.thingsboard.server.common.data.DashboardInfo;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DashboardId;
 import org.thingsboard.server.common.data.id.DashboardId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
@@ -53,4 +54,13 @@ public interface DashboardService {
 
 
     void updateCustomerDashboards(TenantId tenantId, CustomerId customerId);
     void updateCustomerDashboards(TenantId tenantId, CustomerId customerId);
 
 
+    Dashboard assignDashboardToEdge(TenantId tenantId, DashboardId dashboardId, EdgeId edgeId);
+
+    Dashboard unassignDashboardFromEdge(TenantId tenantId, DashboardId dashboardId, EdgeId edgeId);
+
+    void unassignEdgeDashboards(TenantId tenantId, EdgeId edgeId);
+
+    void updateEdgeDashboards(TenantId tenantId, EdgeId edgeId);
+
+    PageData<DashboardInfo> findDashboardsByTenantIdAndEdgeId(TenantId tenantId, EdgeId edgeId, PageLink pageLink);
 }
 }

@@ -22,6 +22,7 @@ import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.device.DeviceSearchQuery;
 import org.thingsboard.server.common.data.device.DeviceSearchQuery;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
@@ -76,4 +77,11 @@ public interface DeviceService {
 
 
     ListenableFuture<List<EntitySubtype>> findDeviceTypesByTenantId(TenantId tenantId);
     ListenableFuture<List<EntitySubtype>> findDeviceTypesByTenantId(TenantId tenantId);
 
 
+    Device assignDeviceToEdge(TenantId tenantId, DeviceId deviceId, EdgeId edgeId);
+
+    Device unassignDeviceFromEdge(TenantId tenantId, DeviceId deviceId);
+
+    PageData<Device> findDevicesByTenantIdAndEdgeId(TenantId tenantId, EdgeId edgeId, PageLink pageLink);
+
+    PageData<Device> findDevicesByTenantIdAndEdgeIdAndType(TenantId tenantId, EdgeId edgeId, String type, PageLink pageLink);
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.edge;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.thingsboard.server.common.data.EntitySubtype;
+import org.thingsboard.server.common.data.Event;
+import org.thingsboard.server.common.data.edge.Edge;
+import org.thingsboard.server.common.data.edge.EdgeSearchQuery;
+import org.thingsboard.server.common.data.id.CustomerId;
+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.PageData;
+import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.page.TimePageLink;
+import org.thingsboard.server.common.msg.TbMsg;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Optional;
+
+public interface EdgeService {
+
+    Edge findEdgeById(TenantId tenantId, EdgeId edgeId);
+
+    ListenableFuture<Edge> findEdgeByIdAsync(TenantId tenantId, EdgeId edgeId);
+
+    Edge findEdgeByTenantIdAndName(TenantId tenantId, String name);
+
+    Optional<Edge> findEdgeByRoutingKey(TenantId tenantId, String routingKey);
+
+    Edge saveEdge(Edge edge);
+
+    Edge assignEdgeToCustomer(TenantId tenantId, EdgeId edgeId, CustomerId customerId);
+
+    Edge unassignEdgeFromCustomer(TenantId tenantId, EdgeId edgeId);
+
+    void deleteEdge(TenantId tenantId, EdgeId edgeId);
+
+    PageData<Edge> findEdgesByTenantId(TenantId tenantId, PageLink pageLink);
+
+    PageData<Edge> findEdgesByTenantIdAndType(TenantId tenantId, String type, PageLink pageLink);
+
+    ListenableFuture<List<Edge>> findEdgesByTenantIdAndIdsAsync(TenantId tenantId, List<EdgeId> edgeIds);
+
+    void deleteEdgesByTenantId(TenantId tenantId);
+
+    PageData<Edge> findEdgesByTenantIdAndCustomerId(TenantId tenantId, CustomerId customerId, PageLink pageLink);
+
+    PageData<Edge> findEdgesByTenantIdAndCustomerIdAndType(TenantId tenantId, CustomerId customerId, String type, PageLink pageLink);
+
+    ListenableFuture<List<Edge>> findEdgesByTenantIdCustomerIdAndIdsAsync(TenantId tenantId, CustomerId customerId, List<EdgeId> edgeIds);
+
+    void unassignCustomerEdges(TenantId tenantId, CustomerId customerId);
+
+    ListenableFuture<List<Edge>> findEdgesByQuery(TenantId tenantId, EdgeSearchQuery query);
+
+    ListenableFuture<List<EntitySubtype>> findEdgeTypesByTenantId(TenantId tenantId);
+
+    void pushEventToEdge(TenantId tenantId, TbMsg tbMsg, FutureCallback<Void> callback);
+
+    PageData<Event> findQueueEvents(TenantId tenantId, EdgeId edgeId, TimePageLink pageLink);
+
+    Edge setRootRuleChain(TenantId tenantId, Edge edge, RuleChainId ruleChainId) throws IOException;
+}

@@ -19,9 +19,9 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntityView;
 import org.thingsboard.server.common.data.EntityView;
 import org.thingsboard.server.common.data.EntityViewInfo;
 import org.thingsboard.server.common.data.EntityViewInfo;
-import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.entityview.EntityViewSearchQuery;
 import org.thingsboard.server.common.data.entityview.EntityViewSearchQuery;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityViewId;
 import org.thingsboard.server.common.data.id.EntityViewId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -76,4 +76,12 @@ public interface EntityViewService {
     void deleteEntityViewsByTenantId(TenantId tenantId);
     void deleteEntityViewsByTenantId(TenantId tenantId);
 
 
     ListenableFuture<List<EntitySubtype>> findEntityViewTypesByTenantId(TenantId tenantId);
     ListenableFuture<List<EntitySubtype>> findEntityViewTypesByTenantId(TenantId tenantId);
+
+    EntityView assignEntityViewToEdge(TenantId tenantId, EntityViewId entityViewId, EdgeId edgeId);
+
+    EntityView unassignEntityViewFromEdge(TenantId tenantId, EntityViewId entityViewId);
+
+    PageData<EntityView> findEntityViewsByTenantIdAndEdgeId(TenantId tenantId, EdgeId edgeId, PageLink pageLink);
+
+    PageData<EntityView> findEntityViewsByTenantIdAndEdgeIdAndType(TenantId tenantId, EdgeId edgeId, String type, PageLink pageLink);
 }
 }

@@ -16,14 +16,17 @@
 package org.thingsboard.server.dao.rule;
 package org.thingsboard.server.dao.rule;
 
 
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.RuleNodeId;
 import org.thingsboard.server.common.data.id.RuleNodeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.common.data.rule.RuleChainMetaData;
 import org.thingsboard.server.common.data.rule.RuleChainMetaData;
+import org.thingsboard.server.common.data.rule.RuleChainType;
 import org.thingsboard.server.common.data.rule.RuleNode;
 import org.thingsboard.server.common.data.rule.RuleNode;
 
 
 import java.util.List;
 import java.util.List;
@@ -59,8 +62,19 @@ public interface RuleChainService {
 
 
     PageData<RuleChain> findTenantRuleChains(TenantId tenantId, PageLink pageLink);
     PageData<RuleChain> findTenantRuleChains(TenantId tenantId, PageLink pageLink);
 
 
+    PageData<RuleChain> findTenantRuleChainsByType(TenantId tenantId, RuleChainType type, PageLink pageLink);
+
     void deleteRuleChainById(TenantId tenantId, RuleChainId ruleChainId);
     void deleteRuleChainById(TenantId tenantId, RuleChainId ruleChainId);
 
 
     void deleteRuleChainsByTenantId(TenantId tenantId);
     void deleteRuleChainsByTenantId(TenantId tenantId);
 
 
+    RuleChain assignRuleChainToEdge(TenantId tenantId, RuleChainId ruleChainId, EdgeId edgeId);
+
+    RuleChain unassignRuleChainFromEdge(TenantId tenantId, RuleChainId ruleChainId, EdgeId edgeId);
+
+    void unassignEdgeRuleChains(TenantId tenantId, EdgeId edgeId);
+
+    void updateEdgeRuleChains(TenantId tenantId, EdgeId edgeId);
+
+    PageData<RuleChain> findRuleChainsByTenantIdAndEdgeId(TenantId tenantId, EdgeId edgeId, PageLink pageLink);
 }
 }

@@ -22,6 +22,7 @@ public class CacheConstants {
     public static final String SESSIONS_CACHE = "sessions";
     public static final String SESSIONS_CACHE = "sessions";
     public static final String ASSET_CACHE = "assets";
     public static final String ASSET_CACHE = "assets";
     public static final String ENTITY_VIEW_CACHE = "entityViews";
     public static final String ENTITY_VIEW_CACHE = "entityViews";
+    public static final String EDGE_CACHE = "edges";
     public static final String CLAIM_DEVICES_CACHE = "claimDevices";
     public static final String CLAIM_DEVICES_CACHE = "claimDevices";
     public static final String SECURITY_SETTINGS_CACHE = "securitySettings";
     public static final String SECURITY_SETTINGS_CACHE = "securitySettings";
 }
 }

@@ -16,8 +16,12 @@
 package org.thingsboard.server.common.data;
 package org.thingsboard.server.common.data;
 
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Getter;
+import lombok.Setter;
+import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DashboardId;
 import org.thingsboard.server.common.data.id.DashboardId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 
 
 import java.util.*;
 import java.util.*;
@@ -28,6 +32,9 @@ public class DashboardInfo extends SearchTextBased<DashboardId> implements HasNa
     private String title;
     private String title;
     private Set<ShortCustomerInfo> assignedCustomers;
     private Set<ShortCustomerInfo> assignedCustomers;
 
 
+    @Getter @Setter
+    private Set<ShortEdgeInfo> assignedEdges;
+
     public DashboardInfo() {
     public DashboardInfo() {
         super();
         super();
     }
     }
@@ -116,6 +123,55 @@ public class DashboardInfo extends SearchTextBased<DashboardId> implements HasNa
         }
         }
     }
     }
 
 
+    public boolean isAssignedToEdge(EdgeId edgeId) {
+        return this.assignedEdges != null && this.assignedEdges.contains(new ShortEdgeInfo(edgeId, null, null));
+    }
+
+    public ShortEdgeInfo getAssignedEdgeInfo(EdgeId edgeId) {
+        if (this.assignedEdges != null) {
+            for (ShortEdgeInfo edgeInfo : this.assignedEdges) {
+                if (edgeInfo.getEdgeId().equals(edgeId)) {
+                    return edgeInfo;
+                }
+            }
+        }
+        return null;
+    }
+
+    public boolean addAssignedEdge(Edge edge) {
+        ShortEdgeInfo edgeInfo = edge.toShortEdgeInfo();
+        if (this.assignedEdges != null && this.assignedEdges.contains(edgeInfo)) {
+            return false;
+        } else {
+            if (this.assignedEdges == null) {
+                this.assignedEdges = new HashSet<>();
+            }
+            this.assignedEdges.add(edgeInfo);
+            return true;
+        }
+    }
+
+    public boolean updateAssignedEdge(Edge edge) {
+        ShortEdgeInfo edgeInfo = edge.toShortEdgeInfo();
+        if (this.assignedEdges != null && this.assignedEdges.contains(edgeInfo)) {
+            this.assignedEdges.remove(edgeInfo);
+            this.assignedEdges.add(edgeInfo);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public boolean removeAssignedEdge(Edge edge) {
+        ShortEdgeInfo edgeInfo = edge.toShortEdgeInfo();
+        if (this.assignedEdges != null && this.assignedEdges.contains(edgeInfo)) {
+            this.assignedEdges.remove(edgeInfo);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
     @Override
     @Override
     @JsonProperty(access = JsonProperty.Access.READ_ONLY)
     @JsonProperty(access = JsonProperty.Access.READ_ONLY)
     public String getName() {
     public String getName() {

@@ -57,6 +57,8 @@ public class DataConstants {
     public static final String ATTRIBUTES_DELETED = "ATTRIBUTES_DELETED";
     public static final String ATTRIBUTES_DELETED = "ATTRIBUTES_DELETED";
     public static final String ALARM_ACK = "ALARM_ACK";
     public static final String ALARM_ACK = "ALARM_ACK";
     public static final String ALARM_CLEAR = "ALARM_CLEAR";
     public static final String ALARM_CLEAR = "ALARM_CLEAR";
+    public static final String ENTITY_ASSIGNED_TO_EDGE = "ENTITY_ASSIGNED_TO_EDGE";
+    public static final String ENTITY_UNASSIGNED_FROM_EDGE = "ENTITY_UNASSIGNED_FROM_EDGE";
 
 
     public static final String RPC_CALL_FROM_SERVER_TO_DEVICE = "RPC_CALL_FROM_SERVER_TO_DEVICE";
     public static final String RPC_CALL_FROM_SERVER_TO_DEVICE = "RPC_CALL_FROM_SERVER_TO_DEVICE";
 
 
@@ -64,4 +66,5 @@ public class DataConstants {
     public static final String SECRET_KEY_FIELD_NAME = "secretKey";
     public static final String SECRET_KEY_FIELD_NAME = "secretKey";
     public static final String DURATION_MS_FIELD_NAME = "durationMs";
     public static final String DURATION_MS_FIELD_NAME = "durationMs";
 
 
+    public static final String EDGE_QUEUE_EVENT_TYPE = "EDGE_QUEUE";
 }
 }

@@ -18,6 +18,7 @@ package org.thingsboard.server.common.data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 
 
 @EqualsAndHashCode(callSuper = true)
 @EqualsAndHashCode(callSuper = true)
@@ -27,6 +28,7 @@ public class Device extends SearchTextBasedWithAdditionalInfo<DeviceId> implemen
 
 
     private TenantId tenantId;
     private TenantId tenantId;
     private CustomerId customerId;
     private CustomerId customerId;
+    private EdgeId edgeId;
     private String name;
     private String name;
     private String type;
     private String type;
     private String label;
     private String label;
@@ -46,6 +48,7 @@ public class Device extends SearchTextBasedWithAdditionalInfo<DeviceId> implemen
         this.name = device.getName();
         this.name = device.getName();
         this.type = device.getType();
         this.type = device.getType();
         this.label = device.getLabel();
         this.label = device.getLabel();
+        this.edgeId = device.getEdgeId();
     }
     }
 
 
     public TenantId getTenantId() {
     public TenantId getTenantId() {
@@ -64,6 +67,14 @@ public class Device extends SearchTextBasedWithAdditionalInfo<DeviceId> implemen
         this.customerId = customerId;
         this.customerId = customerId;
     }
     }
 
 
+    public EdgeId getEdgeId() {
+        return edgeId;
+    }
+
+    public void setEdgeId(EdgeId edgeId) {
+        this.edgeId = edgeId;
+    }
+
     @Override
     @Override
     public String getName() {
     public String getName() {
         return name;
         return name;
@@ -101,6 +112,8 @@ public class Device extends SearchTextBasedWithAdditionalInfo<DeviceId> implemen
         builder.append(tenantId);
         builder.append(tenantId);
         builder.append(", customerId=");
         builder.append(", customerId=");
         builder.append(customerId);
         builder.append(customerId);
+        builder.append(", edgeId=");
+        builder.append(edgeId);
         builder.append(", name=");
         builder.append(", name=");
         builder.append(name);
         builder.append(name);
         builder.append(", type=");
         builder.append(", type=");

@@ -19,5 +19,5 @@ package org.thingsboard.server.common.data;
  * @author Andrew Shvayka
  * @author Andrew Shvayka
  */
  */
 public enum EntityType {
 public enum EntityType {
-    TENANT, CUSTOMER, USER, DASHBOARD, ASSET, DEVICE, ALARM, RULE_CHAIN, RULE_NODE, ENTITY_VIEW, WIDGETS_BUNDLE, WIDGET_TYPE
+    TENANT, CUSTOMER, USER, DASHBOARD, ASSET, DEVICE, ALARM, RULE_CHAIN, RULE_NODE, ENTITY_VIEW, WIDGETS_BUNDLE, WIDGET_TYPE, EDGE
 }
 }

@@ -19,6 +19,7 @@ import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityViewId;
 import org.thingsboard.server.common.data.id.EntityViewId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -39,6 +40,7 @@ public class EntityView extends SearchTextBasedWithAdditionalInfo<EntityViewId>
     private EntityId entityId;
     private EntityId entityId;
     private TenantId tenantId;
     private TenantId tenantId;
     private CustomerId customerId;
     private CustomerId customerId;
+    private EdgeId edgeId;
     private String name;
     private String name;
     private String type;
     private String type;
     private TelemetryEntityView keys;
     private TelemetryEntityView keys;

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+import org.thingsboard.server.common.data.id.EdgeId;
+import org.thingsboard.server.common.data.id.RuleChainId;
+
+@AllArgsConstructor
+public class ShortEdgeInfo {
+
+    @Getter @Setter
+    private EdgeId edgeId;
+
+    @Getter @Setter
+    private String title;
+
+    @Getter @Setter
+    private RuleChainId rootRuleChainId;
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        ShortEdgeInfo that = (ShortEdgeInfo) o;
+
+        return edgeId.equals(that.edgeId);
+    }
+
+    @Override
+    public int hashCode() {
+        return edgeId.hashCode();
+    }
+}

@@ -20,6 +20,7 @@ import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 
 
 @EqualsAndHashCode(callSuper = true)
 @EqualsAndHashCode(callSuper = true)
@@ -29,6 +30,7 @@ public class Asset extends SearchTextBasedWithAdditionalInfo<AssetId> implements
 
 
     private TenantId tenantId;
     private TenantId tenantId;
     private CustomerId customerId;
     private CustomerId customerId;
+    private EdgeId edgeId;
     private String name;
     private String name;
     private String type;
     private String type;
     private String label;
     private String label;
@@ -45,6 +47,7 @@ public class Asset extends SearchTextBasedWithAdditionalInfo<AssetId> implements
         super(asset);
         super(asset);
         this.tenantId = asset.getTenantId();
         this.tenantId = asset.getTenantId();
         this.customerId = asset.getCustomerId();
         this.customerId = asset.getCustomerId();
+        this.edgeId = asset.getEdgeId();
         this.name = asset.getName();
         this.name = asset.getName();
         this.type = asset.getType();
         this.type = asset.getType();
         this.label = asset.getLabel();
         this.label = asset.getLabel();
@@ -66,6 +69,14 @@ public class Asset extends SearchTextBasedWithAdditionalInfo<AssetId> implements
         this.customerId = customerId;
         this.customerId = customerId;
     }
     }
 
 
+    public EdgeId getEdgeId() {
+        return edgeId;
+    }
+
+    public void setEdgeId(EdgeId edgeId) {
+        this.edgeId = edgeId;
+    }
+
     @Override
     @Override
     public String getName() {
     public String getName() {
         return name;
         return name;
@@ -103,6 +114,8 @@ public class Asset extends SearchTextBasedWithAdditionalInfo<AssetId> implements
         builder.append(tenantId);
         builder.append(tenantId);
         builder.append(", customerId=");
         builder.append(", customerId=");
         builder.append(customerId);
         builder.append(customerId);
+        builder.append(", edgeId=");
+        builder.append(edgeId);
         builder.append(", name=");
         builder.append(", name=");
         builder.append(name);
         builder.append(name);
         builder.append(", type=");
         builder.append(", type=");

@@ -40,7 +40,9 @@ public enum ActionType {
     ALARM_CLEAR(false),
     ALARM_CLEAR(false),
     LOGIN(false),
     LOGIN(false),
     LOGOUT(false),
     LOGOUT(false),
-    LOCKOUT(false);
+    LOCKOUT(false),
+    ASSIGNED_TO_EDGE(false), // log edge name
+    UNASSIGNED_FROM_EDGE(false); // log edge name
 
 
     private final boolean isRead;
     private final boolean isRead;
 
 

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.edge;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import org.thingsboard.server.common.data.HasCustomerId;
+import org.thingsboard.server.common.data.HasName;
+import org.thingsboard.server.common.data.HasTenantId;
+import org.thingsboard.server.common.data.SearchTextBasedWithAdditionalInfo;
+import org.thingsboard.server.common.data.ShortCustomerInfo;
+import org.thingsboard.server.common.data.ShortEdgeInfo;
+import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
+import org.thingsboard.server.common.data.id.RuleChainId;
+import org.thingsboard.server.common.data.id.TenantId;
+
+@EqualsAndHashCode(callSuper = true)
+@ToString
+@Getter
+@Setter
+public class Edge extends SearchTextBasedWithAdditionalInfo<EdgeId> implements HasName, HasTenantId, HasCustomerId {
+
+    private static final long serialVersionUID = 4934987555236873728L;
+
+    private TenantId tenantId;
+    private CustomerId customerId;
+    private RuleChainId rootRuleChainId;
+    private String name;
+    private String type;
+    private String label;
+    private String routingKey;
+    private String secret;
+    private transient JsonNode configuration;
+
+    public Edge() {
+        super();
+    }
+
+    public Edge(EdgeId id) {
+        super(id);
+    }
+
+    public Edge(Edge edge) {
+        super(edge);
+        this.tenantId = edge.getTenantId();
+        this.customerId = edge.getCustomerId();
+        this.rootRuleChainId = edge.getRootRuleChainId();
+        this.type = edge.getType();
+        this.name = edge.getName();
+        this.routingKey = edge.getRoutingKey();
+        this.secret = edge.getSecret();
+        this.configuration = edge.getConfiguration();
+    }
+
+    @JsonIgnore
+    public ShortEdgeInfo toShortEdgeInfo() {
+        return new ShortEdgeInfo(id, name, rootRuleChainId);
+    }
+
+    @Override
+    public String getSearchText() {
+        return getName();
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.edge;
+
+public enum EdgeQueueEntityType {
+    DASHBOARD, ASSET, DEVICE, ENTITY_VIEW, ALARM, RULE_CHAIN, RULE_CHAIN_METADATA, EDGE, USER, CUSTOMER
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.edge;
+
+import lombok.Data;
+
+@Data
+public class EdgeQueueEntry {
+    private String type;
+    private EdgeQueueEntityType entityType;
+    private String data;
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.edge;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.relation.EntityRelation;
+import org.thingsboard.server.common.data.relation.EntityRelationsQuery;
+import org.thingsboard.server.common.data.relation.EntityTypeFilter;
+import org.thingsboard.server.common.data.relation.RelationsSearchParameters;
+
+import java.util.Collections;
+import java.util.List;
+
+@Data
+public class EdgeSearchQuery {
+
+    private RelationsSearchParameters parameters;
+    private String relationType;
+    private List<String> edgeTypes;
+
+    public EntityRelationsQuery toEntitySearchQuery() {
+        EntityRelationsQuery query = new EntityRelationsQuery();
+        query.setParameters(parameters);
+        query.setFilters(
+                Collections.singletonList(new EntityTypeFilter(relationType == null ? EntityRelation.CONTAINS_TYPE : relationType,
+                        Collections.singletonList(EntityType.EDGE))));
+        return query;
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.id;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.thingsboard.server.common.data.EntityType;
+
+import java.util.UUID;
+
+public class EdgeId extends UUIDBased implements EntityId {
+
+    private static final long serialVersionUID = 1L;
+
+    @JsonCreator
+    public EdgeId(@JsonProperty("id") UUID id) {
+        super(id);
+    }
+
+    public static EdgeId fromString(String integrationId) {
+        return new EdgeId(UUID.fromString(integrationId));
+    }
+
+    @JsonIgnore
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.EDGE;
+    }
+}

@@ -63,6 +63,8 @@ public class EntityIdFactory {
                 return new WidgetsBundleId(uuid);
                 return new WidgetsBundleId(uuid);
             case WIDGET_TYPE:
             case WIDGET_TYPE:
                 return new WidgetTypeId(uuid);
                 return new WidgetTypeId(uuid);
+            case EDGE:
+                return new EdgeId(uuid);
         }
         }
         throw new IllegalArgumentException("EntityType " + type + " is not supported!");
         throw new IllegalArgumentException("EntityType " + type + " is not supported!");
     }
     }

@@ -32,6 +32,7 @@ public class EntityRelation implements Serializable {
 
 
     private static final long serialVersionUID = 2807343040519543363L;
     private static final long serialVersionUID = 2807343040519543363L;
 
 
+    public static final String EDGE_TYPE = "ManagedByEdge";
     public static final String CONTAINS_TYPE = "Contains";
     public static final String CONTAINS_TYPE = "Contains";
     public static final String MANAGES_TYPE = "Manages";
     public static final String MANAGES_TYPE = "Manages";
 
 

@@ -21,6 +21,7 @@ public enum RelationTypeGroup {
     ALARM,
     ALARM,
     DASHBOARD,
     DASHBOARD,
     RULE_CHAIN,
     RULE_CHAIN,
-    RULE_NODE
+    RULE_NODE,
+    EDGE
 
 
 }
 }

@@ -23,10 +23,16 @@ import lombok.extern.slf4j.Slf4j;
 import org.thingsboard.server.common.data.HasName;
 import org.thingsboard.server.common.data.HasName;
 import org.thingsboard.server.common.data.HasTenantId;
 import org.thingsboard.server.common.data.HasTenantId;
 import org.thingsboard.server.common.data.SearchTextBasedWithAdditionalInfo;
 import org.thingsboard.server.common.data.SearchTextBasedWithAdditionalInfo;
+import org.thingsboard.server.common.data.ShortEdgeInfo;
+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.RuleChainId;
 import org.thingsboard.server.common.data.id.RuleNodeId;
 import org.thingsboard.server.common.data.id.RuleNodeId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 
 
+import java.util.HashSet;
+import java.util.Set;
+
 @Data
 @Data
 @EqualsAndHashCode(callSuper = true)
 @EqualsAndHashCode(callSuper = true)
 @Slf4j
 @Slf4j
@@ -36,13 +42,16 @@ public class RuleChain extends SearchTextBasedWithAdditionalInfo<RuleChainId> im
 
 
     private TenantId tenantId;
     private TenantId tenantId;
     private String name;
     private String name;
+    private RuleChainType type;
     private RuleNodeId firstRuleNodeId;
     private RuleNodeId firstRuleNodeId;
     private boolean root;
     private boolean root;
     private boolean debugMode;
     private boolean debugMode;
     private transient JsonNode configuration;
     private transient JsonNode configuration;
+    private Set<ShortEdgeInfo> assignedEdges;
     @JsonIgnore
     @JsonIgnore
     private byte[] configurationBytes;
     private byte[] configurationBytes;
 
 
+
     public RuleChain() {
     public RuleChain() {
         super();
         super();
     }
     }
@@ -55,8 +64,10 @@ public class RuleChain extends SearchTextBasedWithAdditionalInfo<RuleChainId> im
         super(ruleChain);
         super(ruleChain);
         this.tenantId = ruleChain.getTenantId();
         this.tenantId = ruleChain.getTenantId();
         this.name = ruleChain.getName();
         this.name = ruleChain.getName();
+        this.type = ruleChain.getType();
         this.firstRuleNodeId = ruleChain.getFirstRuleNodeId();
         this.firstRuleNodeId = ruleChain.getFirstRuleNodeId();
         this.root = ruleChain.isRoot();
         this.root = ruleChain.isRoot();
+        this.assignedEdges = ruleChain.getAssignedEdges();
         this.setConfiguration(ruleChain.getConfiguration());
         this.setConfiguration(ruleChain.getConfiguration());
     }
     }
 
 
@@ -78,4 +89,52 @@ public class RuleChain extends SearchTextBasedWithAdditionalInfo<RuleChainId> im
         setJson(data, json -> this.configuration = json, bytes -> this.configurationBytes = bytes);
         setJson(data, json -> this.configuration = json, bytes -> this.configurationBytes = bytes);
     }
     }
 
 
+    public boolean isAssignedToEdge(EdgeId edgeId) {
+        return this.assignedEdges != null && this.assignedEdges.contains(new ShortEdgeInfo(edgeId, null, null));
+    }
+
+    public ShortEdgeInfo getAssignedEdgeInfo(EdgeId edgeId) {
+        if (this.assignedEdges != null) {
+            for (ShortEdgeInfo edgeInfo : this.assignedEdges) {
+                if (edgeInfo.getEdgeId().equals(edgeId)) {
+                    return edgeInfo;
+                }
+            }
+        }
+        return null;
+    }
+
+    public boolean addAssignedEdge(Edge edge) {
+        ShortEdgeInfo edgeInfo = edge.toShortEdgeInfo();
+        if (this.assignedEdges != null && this.assignedEdges.contains(edgeInfo)) {
+            return false;
+        } else {
+            if (this.assignedEdges == null) {
+                this.assignedEdges = new HashSet<>();
+            }
+            this.assignedEdges.add(edgeInfo);
+            return true;
+        }
+    }
+
+    public boolean updateAssignedEdge(Edge edge) {
+        ShortEdgeInfo edgeInfo = edge.toShortEdgeInfo();
+        if (this.assignedEdges != null && this.assignedEdges.contains(edgeInfo)) {
+            this.assignedEdges.remove(edgeInfo);
+            this.assignedEdges.add(edgeInfo);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public boolean removeAssignedEdge(Edge edge) {
+        ShortEdgeInfo edgeInfo = edge.toShortEdgeInfo();
+        if (this.assignedEdges != null && this.assignedEdges.contains(edgeInfo)) {
+            this.assignedEdges.remove(edgeInfo);
+            return true;
+        } else {
+            return false;
+        }
+    }
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.rule;
+
+public enum RuleChainType {
+    SYSTEM, EDGE
+}

+<!--
+
+    Copyright © 2016-2020 The Thingsboard Authors
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.thingsboard</groupId>
+        <version>3.0.0-SNAPSHOT</version>
+        <artifactId>common</artifactId>
+    </parent>
+    <groupId>org.thingsboard.common</groupId>
+    <artifactId>edge-api</artifactId>
+    <packaging>jar</packaging>
+
+    <name>Thingsboard Server Remote Edge wrapper</name>
+    <url>https://thingsboard.io</url>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <main.dir>${basedir}/../..</main.dir>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.thingsboard.common</groupId>
+            <artifactId>data</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.thingsboard.common</groupId>
+            <artifactId>message</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>log4j-over-slf4j</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-all</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.grpc</groupId>
+            <artifactId>grpc-netty</artifactId>
+            <exclusions>
+                <exclusion>
+                    <artifactId>netty-transport</artifactId>
+                    <groupId>io.netty</groupId>
+                </exclusion>
+                <exclusion>
+                    <artifactId>netty-common</artifactId>
+                    <groupId>io.netty</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>io.grpc</groupId>
+            <artifactId>grpc-protobuf</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.grpc</groupId>
+            <artifactId>grpc-stub</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.protobuf</groupId>
+            <artifactId>protobuf-java</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.xolstice.maven.plugins</groupId>
+                <artifactId>protobuf-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+    <distributionManagement>
+        <repository>
+            <id>thingsboard-repo-deploy</id>
+            <name>ThingsBoard Repo Deployment</name>
+            <url>https://repo.thingsboard.io/artifactory/libs-release-public</url>
+        </repository>
+    </distributionManagement>
+
+</project>

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.edge.exception;
+
+public class EdgeConnectionException extends RuntimeException {
+
+    private static final long serialVersionUID = -4372754681230555723L;
+
+    public EdgeConnectionException(String message) {
+        super(message);
+    }
+
+    public EdgeConnectionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.edge.rpc;
+
+import com.google.common.io.Resources;
+import io.grpc.ManagedChannel;
+import io.grpc.netty.GrpcSslContexts;
+import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.stub.StreamObserver;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.thingsboard.edge.exception.EdgeConnectionException;
+import org.thingsboard.server.gen.edge.ConnectRequestMsg;
+import org.thingsboard.server.gen.edge.ConnectResponseCode;
+import org.thingsboard.server.gen.edge.ConnectResponseMsg;
+import org.thingsboard.server.gen.edge.DownlinkMsg;
+import org.thingsboard.server.gen.edge.EdgeConfiguration;
+import org.thingsboard.server.gen.edge.EdgeRpcServiceGrpc;
+import org.thingsboard.server.gen.edge.EntityUpdateMsg;
+import org.thingsboard.server.gen.edge.RequestMsg;
+import org.thingsboard.server.gen.edge.RequestMsgType;
+import org.thingsboard.server.gen.edge.ResponseMsg;
+import org.thingsboard.server.gen.edge.UplinkMsg;
+import org.thingsboard.server.gen.edge.UplinkResponseMsg;
+
+import javax.net.ssl.SSLException;
+import java.io.File;
+import java.net.URISyntaxException;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+
+@Service
+@Slf4j
+public class EdgeGrpcClient implements EdgeRpcClient {
+
+    @Value("${cloud.rpc.host}")
+    private String rpcHost;
+    @Value("${cloud.rpc.port}")
+    private int rpcPort;
+    @Value("${cloud.rpc.timeout}")
+    private int timeoutSecs;
+    @Value("${cloud.rpc.ssl.enabled}")
+    private boolean sslEnabled;
+    @Value("${cloud.rpc.ssl.cert}")
+    private String certResource;
+
+    private ManagedChannel channel;
+
+    private StreamObserver<RequestMsg> inputStream;
+
+    @Override
+    public void connect(String edgeKey,
+                        String edgeSecret,
+                        Consumer<UplinkResponseMsg> onUplinkResponse,
+                        Consumer<EdgeConfiguration> onEdgeUpdate,
+                        Consumer<EntityUpdateMsg> onEntityUpdate,
+                        Consumer<DownlinkMsg> onDownlink,
+                        Consumer<Exception> onError) {
+        NettyChannelBuilder builder = NettyChannelBuilder.forAddress(rpcHost, rpcPort).usePlaintext();
+        if (sslEnabled) {
+            try {
+                builder.sslContext(GrpcSslContexts.forClient().trustManager(new File(Resources.getResource(certResource).toURI())).build());
+            } catch (URISyntaxException | SSLException e) {
+                log.error("Failed to initialize channel!", e);
+                throw new RuntimeException(e);
+            }
+        }
+        channel = builder.build();
+        EdgeRpcServiceGrpc.EdgeRpcServiceStub stub = EdgeRpcServiceGrpc.newStub(channel);
+        log.info("[{}] Sending a connect request to the TB!", edgeKey);
+        this.inputStream = stub.handleMsgs(initOutputStream(edgeKey, onUplinkResponse, onEdgeUpdate, onEntityUpdate, onDownlink, onError));
+        this.inputStream.onNext(RequestMsg.newBuilder()
+                .setMsgType(RequestMsgType.CONNECT_RPC_MESSAGE)
+                .setConnectRequestMsg(ConnectRequestMsg.newBuilder().setEdgeRoutingKey(edgeKey).setEdgeSecret(edgeSecret).build())
+                .build());
+    }
+
+    @Override
+    public void disconnect() throws InterruptedException {
+        inputStream.onCompleted();
+        if (channel != null) {
+            channel.shutdown().awaitTermination(timeoutSecs, TimeUnit.SECONDS);
+        }
+    }
+
+    @Override
+    public void sendUplinkMsg(UplinkMsg msg) {
+        this.inputStream.onNext(RequestMsg.newBuilder()
+                .setMsgType(RequestMsgType.UPLINK_RPC_MESSAGE)
+                .setUplinkMsg(msg)
+                .build());
+    }
+
+    private StreamObserver<ResponseMsg> initOutputStream(String edgeKey,
+                                                         Consumer<UplinkResponseMsg> onUplinkResponse,
+                                                         Consumer<EdgeConfiguration> onEdgeUpdate,
+                                                         Consumer<EntityUpdateMsg> onEntityUpdate,
+                                                         Consumer<DownlinkMsg> onDownlink,
+                                                         Consumer<Exception> onError) {
+        return new StreamObserver<ResponseMsg>() {
+            @Override
+            public void onNext(ResponseMsg responseMsg) {
+                if (responseMsg.hasConnectResponseMsg()) {
+                    ConnectResponseMsg connectResponseMsg = responseMsg.getConnectResponseMsg();
+                    if (connectResponseMsg.getResponseCode().equals(ConnectResponseCode.ACCEPTED)) {
+                        log.info("[{}] Configuration received: {}", edgeKey, connectResponseMsg.getConfiguration());
+                        onEdgeUpdate.accept(connectResponseMsg.getConfiguration());
+                    } else {
+                        log.error("[{}] Failed to establish the connection! Code: {}. Error message: {}.", edgeKey, connectResponseMsg.getResponseCode(), connectResponseMsg.getErrorMsg());
+                        onError.accept(new EdgeConnectionException("Failed to establish the connection! Response code: " + connectResponseMsg.getResponseCode().name()));
+                    }
+                } else if (responseMsg.hasUplinkResponseMsg()) {
+                    log.debug("[{}] Uplink response message received {}", edgeKey, responseMsg.getUplinkResponseMsg());
+                    onUplinkResponse.accept(responseMsg.getUplinkResponseMsg());
+                } else if (responseMsg.hasEntityUpdateMsg()) {
+                    log.debug("[{}] Entity update message received {}", edgeKey, responseMsg.getEntityUpdateMsg());
+                    onEntityUpdate.accept(responseMsg.getEntityUpdateMsg());
+                } else if (responseMsg.hasDownlinkMsg()) {
+                    log.debug("[{}] Downlink message received for rule chain {}", edgeKey, responseMsg.getDownlinkMsg());
+                    onDownlink.accept(responseMsg.getDownlinkMsg());
+                }
+            }
+
+            @Override
+            public void onError(Throwable t) {
+                log.debug("[{}] The rpc session received an error!", edgeKey, t);
+                onError.accept(new RuntimeException(t));
+            }
+
+            @Override
+            public void onCompleted() {
+                log.debug("[{}] The rpc session was closed!", edgeKey);
+            }
+        };
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.edge.rpc;
+
+import org.thingsboard.server.gen.edge.DownlinkMsg;
+import org.thingsboard.server.gen.edge.EdgeConfiguration;
+import org.thingsboard.server.gen.edge.EntityUpdateMsg;
+import org.thingsboard.server.gen.edge.UplinkMsg;
+import org.thingsboard.server.gen.edge.UplinkResponseMsg;
+
+import java.util.function.Consumer;
+
+public interface EdgeRpcClient {
+
+    void connect(String integrationKey,
+                 String integrationSecret,
+                 Consumer<UplinkResponseMsg> onUplinkResponse,
+                 Consumer<EdgeConfiguration> onEdgeUpdate,
+                 Consumer<EntityUpdateMsg> onEntityUpdate,
+                 Consumer<DownlinkMsg> onDownlink,
+                 Consumer<Exception> onError);
+
+    void disconnect() throws InterruptedException;
+
+    void sendUplinkMsg(UplinkMsg uplinkMsg) throws InterruptedException;
+}