From f5ab5d7a25406899fff3abb88b3c5e352d3be73b Mon Sep 17 00:00:00 2001 From: Volodymyr Babak Date: Fri, 19 Jun 2020 10:05:27 +0300 Subject: [PATCH] Revert particular methods --- .../actors/ruleChain/DefaultTbContext.java | 22 +--------- .../server/controller/BaseController.java | 18 ++++++++ .../ComponentDescriptorController.java | 43 ++++++++++++++++--- .../AnnotationComponentDiscoveryService.java | 32 ++++++++++++-- .../component/ComponentDiscoveryService.java | 4 ++ .../rule/engine/api/TbContext.java | 4 -- .../engine/action/TbAbstractAlarmNode.java | 8 +--- 7 files changed, 91 insertions(+), 40 deletions(-) diff --git a/application/src/main/java/org/thingsboard/server/actors/ruleChain/DefaultTbContext.java b/application/src/main/java/org/thingsboard/server/actors/ruleChain/DefaultTbContext.java index c4ccd485ab..b304f2a67e 100644 --- a/application/src/main/java/org/thingsboard/server/actors/ruleChain/DefaultTbContext.java +++ b/application/src/main/java/org/thingsboard/server/actors/ruleChain/DefaultTbContext.java @@ -249,28 +249,8 @@ class DefaultTbContext implements TbContext { } public TbMsg entityCreatedMsg(E entity, I id, RuleNodeId ruleNodeId) { - return entityCRUDMsg(entity, id, ruleNodeId, DataConstants.ENTITY_CREATED); - } - - public TbMsg entityCRUDMsg(E entity, I id, RuleNodeId ruleNodeId, String actionType) { - try { - return TbMsg.newMsg(actionType, id, getActionMetaData(ruleNodeId), mapper.writeValueAsString(mapper.valueToTree(entity))); - } catch (JsonProcessingException | IllegalArgumentException e) { - throw new RuntimeException("Failed to process " + id.getEntityType().name().toLowerCase() + " " + actionType + " msg: " + e); - } - } - - public TbMsg alarmUpdatedMsg(Alarm alarm, RuleNodeId ruleNodeId) { - return entityCRUDMsg(alarm, alarm.getId(), ruleNodeId, DataConstants.ENTITY_UPDATED); - } - - public TbMsg alarmClearedMsg(Alarm alarm, RuleNodeId ruleNodeId) { - return entityCRUDMsg(alarm, alarm.getId(), ruleNodeId, DataConstants.ALARM_CLEAR); - } - - public TbMsg alarmMsg(E entity, I id, RuleNodeId ruleNodeId, String actionType) { try { - return TbMsg.newMsg(actionType, id, getActionMetaData(ruleNodeId), mapper.writeValueAsString(mapper.valueToTree(entity))); + return TbMsg.newMsg(DataConstants.ENTITY_CREATED, id, getActionMetaData(ruleNodeId), mapper.writeValueAsString(mapper.valueToTree(entity))); } catch (JsonProcessingException | IllegalArgumentException e) { throw new RuntimeException("Failed to process " + id.getEntityType().name().toLowerCase() + " created msg: " + e); } diff --git a/application/src/main/java/org/thingsboard/server/controller/BaseController.java b/application/src/main/java/org/thingsboard/server/controller/BaseController.java index f71c98d63d..c7c53f7cc5 100644 --- a/application/src/main/java/org/thingsboard/server/controller/BaseController.java +++ b/application/src/main/java/org/thingsboard/server/controller/BaseController.java @@ -530,6 +530,24 @@ public abstract class BaseController { } } + ComponentDescriptor checkComponentDescriptorByClazz(String clazz) throws ThingsboardException { + try { + log.debug("[{}] Lookup component descriptor", clazz); + return checkNotNull(componentDescriptorService.getComponent(clazz)); + } catch (Exception e) { + throw handleException(e, false); + } + } + + List checkComponentDescriptorsByType(ComponentType type, RuleChainType ruleChainType) throws ThingsboardException { + try { + log.debug("[{}] Lookup component descriptors", type); + return componentDescriptorService.getComponents(type, ruleChainType); + } catch (Exception e) { + throw handleException(e, false); + } + } + List checkComponentDescriptorsByTypes(Set types, RuleChainType ruleChainType) throws ThingsboardException { try { log.debug("[{}] Lookup component descriptors", types); diff --git a/application/src/main/java/org/thingsboard/server/controller/ComponentDescriptorController.java b/application/src/main/java/org/thingsboard/server/controller/ComponentDescriptorController.java index dc52546ed8..592bcfb94a 100644 --- a/application/src/main/java/org/thingsboard/server/controller/ComponentDescriptorController.java +++ b/application/src/main/java/org/thingsboard/server/controller/ComponentDescriptorController.java @@ -15,6 +15,7 @@ */ package org.thingsboard.server.controller; +import org.apache.commons.lang3.StringUtils; import org.springframework.security.access.prepost.PreAuthorize; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; @@ -25,8 +26,8 @@ import org.springframework.web.bind.annotation.RestController; import org.thingsboard.server.common.data.exception.ThingsboardException; import org.thingsboard.server.common.data.plugin.ComponentDescriptor; import org.thingsboard.server.common.data.plugin.ComponentType; -import org.thingsboard.server.queue.util.TbCoreComponent; import org.thingsboard.server.common.data.rule.RuleChainType; +import org.thingsboard.server.queue.util.TbCoreComponent; import java.util.HashSet; import java.util.List; @@ -37,24 +38,56 @@ import java.util.Set; @RequestMapping("/api") public class ComponentDescriptorController extends BaseController { + @PreAuthorize("hasAnyAuthority('SYS_ADMIN','TENANT_ADMIN')") + @RequestMapping(value = "/component/{componentDescriptorClazz:.+}", method = RequestMethod.GET) + @ResponseBody + public ComponentDescriptor getComponentDescriptorByClazz(@PathVariable("componentDescriptorClazz") String strComponentDescriptorClazz) throws ThingsboardException { + checkParameter("strComponentDescriptorClazz", strComponentDescriptorClazz); + try { + return checkComponentDescriptorByClazz(strComponentDescriptorClazz); + } catch (Exception e) { + throw handleException(e); + } + } + + @PreAuthorize("hasAnyAuthority('SYS_ADMIN','TENANT_ADMIN')") + @RequestMapping(value = "/components/{componentType}/{ruleChainType}", method = RequestMethod.GET) + @ResponseBody + public List getComponentDescriptorsByType(@PathVariable(value = "ruleChainType", required = false) String strRuleChainType, + @PathVariable("componentType") String strComponentType) throws ThingsboardException { + checkParameter("componentType", strComponentType); + try { + return checkComponentDescriptorsByType(ComponentType.valueOf(strComponentType), getRuleChainType(strRuleChainType)); + } catch (Exception e) { + throw handleException(e); + } + } @PreAuthorize("hasAnyAuthority('SYS_ADMIN','TENANT_ADMIN')") @RequestMapping(value = "/components/{ruleChainType}", params = {"componentTypes"}, method = RequestMethod.GET) @ResponseBody - public List getComponentDescriptorsByTypes(@PathVariable("ruleChainType") String strRuleChainType, + public List getComponentDescriptorsByTypes(@PathVariable(value = "ruleChainType", required = false) String strRuleChainType, @RequestParam("componentTypes") String[] strComponentTypes) throws ThingsboardException { checkArrayParameter("componentTypes", strComponentTypes); - checkParameter("ruleChainType", strRuleChainType); try { - RuleChainType ruleChainType = RuleChainType.valueOf(strRuleChainType); Set componentTypes = new HashSet<>(); for (String strComponentType : strComponentTypes) { componentTypes.add(ComponentType.valueOf(strComponentType)); } - return checkComponentDescriptorsByTypes(componentTypes, ruleChainType); + return checkComponentDescriptorsByTypes(componentTypes, getRuleChainType(strRuleChainType)); } catch (Exception e) { throw handleException(e); } } + private RuleChainType getRuleChainType(String strRuleChainType) { + RuleChainType ruleChainType; + if (StringUtils.isEmpty(strRuleChainType)) { + ruleChainType = RuleChainType.CORE; + } else { + ruleChainType = RuleChainType.valueOf(strRuleChainType); + } + return ruleChainType; + } + } diff --git a/application/src/main/java/org/thingsboard/server/service/component/AnnotationComponentDiscoveryService.java b/application/src/main/java/org/thingsboard/server/service/component/AnnotationComponentDiscoveryService.java index 43231768f9..77e2afcd88 100644 --- a/application/src/main/java/org/thingsboard/server/service/component/AnnotationComponentDiscoveryService.java +++ b/application/src/main/java/org/thingsboard/server/service/component/AnnotationComponentDiscoveryService.java @@ -40,7 +40,6 @@ import javax.annotation.PostConstruct; import java.lang.annotation.Annotation; import java.util.ArrayList; import java.util.Arrays; -import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; @@ -65,7 +64,7 @@ public class AnnotationComponentDiscoveryService implements ComponentDiscoverySe private Map components = new HashMap<>(); - private Map> systemComponentsMap = new HashMap<>(); + private Map> coreComponentsMap = new HashMap<>(); private Map> edgeComponentsMap = new HashMap<>(); @@ -117,7 +116,7 @@ public class AnnotationComponentDiscoveryService implements ComponentDiscoverySe private void putComponentIntoMaps(ComponentType type, RuleNode ruleNodeAnnotation, ComponentDescriptor component) { if (ruleChainTypeContainsArray(RuleChainType.CORE, ruleNodeAnnotation.ruleChainTypes())) { - systemComponentsMap.computeIfAbsent(type, k -> new ArrayList<>()).add(component); + coreComponentsMap.computeIfAbsent(type, k -> new ArrayList<>()).add(component); } if (ruleChainTypeContainsArray(RuleChainType.EDGE, ruleNodeAnnotation.ruleChainTypes())) { edgeComponentsMap.computeIfAbsent(type, k -> new ArrayList<>()).add(component); @@ -223,10 +222,30 @@ public class AnnotationComponentDiscoveryService implements ComponentDiscoverySe log.info("Found following definitions: {}", components.values()); } + @Override + public List getComponents(ComponentType type, RuleChainType ruleChainType) { + if (RuleChainType.CORE.equals(ruleChainType)) { + if (coreComponentsMap.containsKey(type)) { + return Collections.unmodifiableList(coreComponentsMap.get(type)); + } else { + return Collections.emptyList(); + } + } else if (RuleChainType.EDGE.equals(ruleChainType)) { + if (edgeComponentsMap.containsKey(type)) { + return Collections.unmodifiableList(edgeComponentsMap.get(type)); + } else { + return Collections.emptyList(); + } + } else { + log.error("Unsupported rule chain type {}", ruleChainType); + throw new RuntimeException("Unsupported rule chain type " + ruleChainType); + } + } + @Override public List getComponents(Set types, RuleChainType ruleChainType) { if (RuleChainType.CORE.equals(ruleChainType)) { - return getComponents(types, systemComponentsMap); + return getComponents(types, coreComponentsMap); } else if (RuleChainType.EDGE.equals(ruleChainType)) { return getComponents(types, edgeComponentsMap); } else { @@ -235,6 +254,11 @@ public class AnnotationComponentDiscoveryService implements ComponentDiscoverySe } } + @Override + public Optional getComponent(String clazz) { + return Optional.ofNullable(components.get(clazz)); + } + private List getComponents(Set types, Map> componentsMap) { List result = new ArrayList<>(); types.stream().filter(componentsMap::containsKey).forEach(type -> { diff --git a/application/src/main/java/org/thingsboard/server/service/component/ComponentDiscoveryService.java b/application/src/main/java/org/thingsboard/server/service/component/ComponentDiscoveryService.java index 01cf130fcb..643c82f04f 100644 --- a/application/src/main/java/org/thingsboard/server/service/component/ComponentDiscoveryService.java +++ b/application/src/main/java/org/thingsboard/server/service/component/ComponentDiscoveryService.java @@ -20,6 +20,7 @@ import org.thingsboard.server.common.data.plugin.ComponentType; import org.thingsboard.server.common.data.rule.RuleChainType; import java.util.List; +import java.util.Optional; import java.util.Set; /** @@ -29,6 +30,9 @@ public interface ComponentDiscoveryService { void discoverComponents(); + List getComponents(ComponentType type, RuleChainType ruleChainType); + List getComponents(Set types, RuleChainType ruleChainType); + Optional getComponent(String clazz); } diff --git a/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/TbContext.java b/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/TbContext.java index 766d1b95ac..8de0068561 100644 --- a/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/TbContext.java +++ b/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/TbContext.java @@ -145,10 +145,6 @@ public interface TbContext { // TODO: Does this changes the message? TbMsg alarmCreatedMsg(Alarm alarm, RuleNodeId ruleNodeId); - TbMsg alarmUpdatedMsg(Alarm alarm, RuleNodeId ruleNodeId); - - TbMsg alarmClearedMsg(Alarm alarm, RuleNodeId ruleNodeId); - /* * * METHODS TO PROCESS THE MESSAGES diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbAbstractAlarmNode.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbAbstractAlarmNode.java index 7b3dbcdb38..b3344105bb 100644 --- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbAbstractAlarmNode.java +++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbAbstractAlarmNode.java @@ -65,13 +65,9 @@ public abstract class TbAbstractAlarmNode ctx.tellNext(toAlarmMsg(ctx, alarmResult, msg), "Created"), throwable -> ctx.tellFailure(toAlarmMsg(ctx, alarmResult, msg), throwable)); } else if (alarmResult.isUpdated) { - ctx.enqueue(ctx.alarmUpdatedMsg(alarmResult.alarm, ctx.getSelfId()), - () -> ctx.tellNext(toAlarmMsg(ctx, alarmResult, msg), "Updated"), - throwable -> ctx.tellFailure(toAlarmMsg(ctx, alarmResult, msg), throwable)); + ctx.tellNext(toAlarmMsg(ctx, alarmResult, msg), "Updated"); } else if (alarmResult.isCleared) { - ctx.enqueue(ctx.alarmClearedMsg(alarmResult.alarm, ctx.getSelfId()), - () -> ctx.tellNext(toAlarmMsg(ctx, alarmResult, msg), "Cleared"), - throwable -> ctx.tellFailure(toAlarmMsg(ctx, alarmResult, msg), throwable)); + ctx.tellNext(toAlarmMsg(ctx, alarmResult, msg), "Cleared"); } else { ctx.tellSuccess(msg); }