rulemgt/src/main/java/org/onap/holmes/rulemgt/wrapper/RuleMgtWrapper.java

   1 /**
   2  * Copyright 2017-2021 ZTE Corporation.
   3  * <p>
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  * <p>
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  * <p>
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.onap.holmes.rulemgt.wrapper;
  17
  18 import lombok.extern.slf4j.Slf4j;
  19 import org.apache.commons.lang3.StringUtils;
  20 import org.onap.holmes.common.api.entity.CorrelationRule;
  21 import org.onap.holmes.common.exception.CorrelationException;
  22 import org.onap.holmes.rulemgt.bean.request.*;
  23 import org.onap.holmes.rulemgt.bean.response.RuleAddAndUpdateResponse;
  24 import org.onap.holmes.rulemgt.bean.response.RuleQueryListResponse;
  25 import org.onap.holmes.rulemgt.bean.response.RuleResult4API;
  26 import org.onap.holmes.rulemgt.bolt.enginebolt.EngineWrapper;
  27 import org.onap.holmes.rulemgt.constant.RuleMgtConstant;
  28 import org.onap.holmes.rulemgt.db.CorrelationRuleQueryService;
  29 import org.onap.holmes.rulemgt.db.CorrelationRuleService;
  30 import org.onap.holmes.rulemgt.tools.EngineTools;
  31 import org.springframework.beans.factory.annotation.Autowired;
  32 import org.springframework.stereotype.Service;
  33
  34 import java.util.ArrayList;
  35 import java.util.Date;
  36 import java.util.List;
  37
  38
  39 @Service
  40 @Slf4j
  41 public class RuleMgtWrapper {
  42
  43     @Autowired
  44     private EngineTools engineTools;
  45
  46     @Autowired
  47     private RuleQueryWrapper ruleQueryWrapper;
  48
  49     @Autowired
  50     private CorrelationRuleQueryService correlationRuleQueryDao;
  51
  52     @Autowired
  53     private EngineWrapper engineWarpper;
  54
  55     @Autowired
  56     private CorrelationRuleService correlationRuleService;
  57
  58     public RuleAddAndUpdateResponse addCorrelationRule(String creator, RuleCreateRequest ruleCreateRequest)
  59             throws CorrelationException {
  60         if (ruleCreateRequest == null) {
  61             throw new CorrelationException("The request object can not be empty!");
  62         }
  63         CorrelationRule correlationRule = convertCreateRequest2Rule(creator,
  64                 ruleCreateRequest);
  65         validateCorrelationRule(correlationRule);
  66         CorrelationRule ruleTemp = correlationRuleService.queryRuleByRuleName(correlationRule.getName());
  67         if (ruleTemp != null) {
  68             throw new CorrelationException("A rule with the same name already exists.");
  69         }
  70         String ip = "";
  71         try {
  72             ip = engineTools.getEngineWithLeastRules();
  73         } catch (Exception e) {
  74             log.error("When adding rules, can not get engine instance ip");
  75         }
  76         String packageName = deployRule2Engine(correlationRule, ip);
  77         correlationRule.setPackageName(packageName);
  78         correlationRule.setEngineInstance(ip);
  79         CorrelationRule result = null;
  80         try {
  81             result = correlationRuleService.saveRule(correlationRule);
  82         } catch (CorrelationException e) {
  83             if (StringUtils.isNotEmpty(packageName)) {
  84                 engineWarpper.deleteRuleFromEngine(packageName, ip);
  85             }
  86             throw new CorrelationException(e.getMessage(), e);
  87         }
  88         RuleAddAndUpdateResponse ruleAddAndUpdateResponse = new RuleAddAndUpdateResponse();
  89         ruleAddAndUpdateResponse.setRuleId(result.getRid());
  90         return ruleAddAndUpdateResponse;
  91     }
  92
  93     public RuleAddAndUpdateResponse updateCorrelationRule(String modifier, RuleUpdateRequest ruleUpdateRequest)
  94             throws CorrelationException {
  95         if (ruleUpdateRequest == null) {
  96             throw new CorrelationException("The request object can not be empty!");
  97         }
  98         CorrelationRule oldCorrelationRule = correlationRuleService.queryRuleByRid(ruleUpdateRequest.getRuleId());
  99         if (oldCorrelationRule == null) {
 100             throw new CorrelationException("You're trying to update a rule which does not exist in the system.");
 101         }
 102
 103         String updateIp = oldCorrelationRule.getEngineInstance();
 104         if (!checkIfEngineExists(updateIp)) {
 105             updateIp = engineTools.getEngineWithLeastRules();
 106         }
 107         CorrelationRule newCorrelationRule = convertRuleUpdateRequest2CorrelationRule(modifier,
 108                 ruleUpdateRequest, oldCorrelationRule.getName());
 109         newCorrelationRule.setEngineInstance(updateIp);
 110         validateCorrelationRule(newCorrelationRule);
 111         RuleAddAndUpdateResponse ruleChangeResponse = new RuleAddAndUpdateResponse();
 112         ruleChangeResponse.setRuleId(newCorrelationRule.getRid());
 113
 114         if (!checkIfRuleChanged(newCorrelationRule, oldCorrelationRule)) {
 115             return ruleChangeResponse;
 116         }
 117         String engineInstance = oldCorrelationRule.getEngineInstance();
 118         if (oldCorrelationRule.getEnabled() == RuleMgtConstant.STATUS_ENABLED
 119                 && checkIfEngineExists(engineInstance)) {
 120             engineWarpper.deleteRuleFromEngine(oldCorrelationRule.getPackageName(), engineInstance);
 121         }
 122         newCorrelationRule.setPackageName(deployRule2Engine(newCorrelationRule, updateIp));
 123         correlationRuleService.updateRule(newCorrelationRule);
 124         return ruleChangeResponse;
 125     }
 126
 127     private void validateCorrelationRule(CorrelationRule correlationRule) throws CorrelationException {
 128         int enabled = correlationRule.getEnabled();
 129         String ruleName = correlationRule.getName() == null ? "" : correlationRule.getName().trim();
 130         String content = correlationRule.getContent() == null ? "" : correlationRule.getContent().trim();
 131         if ("".equals(content)) {
 132             throw new CorrelationException("The contents of the rule can not be empty!");
 133         }
 134         if (enabled != RuleMgtConstant.STATUS_DISABLED
 135                 && enabled != RuleMgtConstant.STATUS_ENABLED) {
 136             throw new CorrelationException("Invalid rule status. Only 0 (disabled) and 1 (enabled) are allowed.");
 137         }
 138         if ("".equals(ruleName)) {
 139             throw new CorrelationException("The name of the rule can not be empty.");
 140         }
 141     }
 142
 143     private boolean checkIfRuleChanged(CorrelationRule newCorrelationRule, CorrelationRule oldCorrelationRule) {
 144         String newContent = newCorrelationRule.getContent();
 145         String oldContent = oldCorrelationRule.getContent();
 146         int newEnabled = newCorrelationRule.getEnabled();
 147         int oldEnabled = oldCorrelationRule.getEnabled();
 148         String newDes = newCorrelationRule.getDescription();
 149         String oldDes = oldCorrelationRule.getDescription();
 150         String oldControlLoop = oldCorrelationRule.getClosedControlLoopName();
 151         String newControlLoop = newCorrelationRule.getClosedControlLoopName();
 152         if (newContent.equals(oldContent) && newEnabled == oldEnabled
 153                 && newDes.equals(oldDes) && newControlLoop.equals(oldControlLoop)) {
 154             return false;
 155         }
 156         return true;
 157     }
 158
 159     public void deleteCorrelationRule(RuleDeleteRequest ruleDeleteRequest)
 160             throws CorrelationException {
 161         if (ruleDeleteRequest == null) {
 162             throw new CorrelationException("The request object can not be empty!");
 163         }
 164         CorrelationRule correlationRule = correlationRuleService.queryRuleByRid(ruleDeleteRequest.getRuleId());
 165         if (correlationRule == null) {
 166             log.warn("the rule:rule id=" + ruleDeleteRequest.getRuleId() + " does not exist the database.");
 167             throw new CorrelationException("You're trying to delete a rule which does not exist in the system.");
 168         }
 169         if (correlationRule.getEnabled() == RuleMgtConstant.STATUS_ENABLED) {
 170             String ip = correlationRule.getEngineInstance();
 171             engineWarpper.deleteRuleFromEngine(correlationRule.getPackageName(), ip);
 172         }
 173         correlationRuleService.deleteRule(correlationRule);
 174     }
 175
 176     private CorrelationRule convertCreateRequest2Rule(String userName,
 177                                                       RuleCreateRequest ruleCreateRequest) throws CorrelationException {
 178         String tempContent = ruleCreateRequest.getContent();
 179         CorrelationRule correlationRule = new CorrelationRule();
 180         String ruleId = "rule_" + System.currentTimeMillis();
 181         String description = ruleCreateRequest.getDescription() == null ? "" : ruleCreateRequest.getDescription();
 182         correlationRule.setRid(ruleId);
 183         if (tempContent != null) {
 184             correlationRule.setContent(tempContent.trim());
 185         }
 186         correlationRule.setDescription(description);
 187         correlationRule.setCreateTime(new Date());
 188         correlationRule.setUpdateTime(new Date());
 189         correlationRule.setName(ruleCreateRequest.getRuleName());
 190         correlationRule.setEngineID("correlation-d");
 191         correlationRule.setEngineType("");
 192         correlationRule.setTemplateID(0);
 193         correlationRule.setVendor("");
 194         correlationRule.setCreator(userName);
 195         correlationRule.setModifier(userName);
 196         correlationRule.setEnabled(ruleCreateRequest.getEnabled());
 197         correlationRule.setClosedControlLoopName(ruleCreateRequest.getLoopControlName());
 198         return correlationRule;
 199     }
 200
 201     private CorrelationRule convertRuleUpdateRequest2CorrelationRule(String modifier,
 202                                                                      RuleUpdateRequest ruleUpdateRequest, String ruleName) throws CorrelationException {
 203         CorrelationRule correlationRule = new CorrelationRule();
 204         String description = ruleUpdateRequest.getDescription() == null ? "" : ruleUpdateRequest.getDescription();
 205         correlationRule.setRid(ruleUpdateRequest.getRuleId());
 206         correlationRule.setContent(ruleUpdateRequest.getContent());
 207         correlationRule.setDescription(description);
 208         correlationRule.setEnabled(ruleUpdateRequest.getEnabled());
 209         correlationRule.setUpdateTime(new Date());
 210         correlationRule.setModifier(modifier);
 211         correlationRule.setName(ruleName);
 212         correlationRule.setClosedControlLoopName(ruleUpdateRequest.getLoopControlName());
 213         return correlationRule;
 214     }
 215
 216     public String deployRule2Engine(CorrelationRule correlationRule, String ip)
 217             throws CorrelationException {
 218         if (engineWarpper.checkRuleFromEngine(toCorrelationCheckRule(correlationRule), ip) && (
 219                 correlationRule.getEnabled() == RuleMgtConstant.STATUS_ENABLED)) {
 220             return engineWarpper.deployEngine(correlationRules2DeployRule(correlationRule), ip);
 221         }
 222         return "";
 223     }
 224
 225     public RuleQueryListResponse getCorrelationRuleByCondition(
 226             RuleQueryCondition ruleQueryCondition) throws CorrelationException {
 227         List<CorrelationRule> correlationRule = correlationRuleQueryDao
 228                 .getCorrelationRulesByCondition(ruleQueryCondition);
 229         RuleQueryListResponse ruleQueryListResponse = new RuleQueryListResponse();
 230         ruleQueryListResponse.setTotalCount(correlationRule.size());
 231         ruleQueryListResponse
 232                 .setCorrelationRules(correlationRules2RuleResult4APIs(correlationRule));
 233         return ruleQueryListResponse;
 234     }
 235
 236     private List<RuleResult4API> correlationRules2RuleResult4APIs(
 237             List<CorrelationRule> correlationRules) {
 238         List<RuleResult4API> ruleResult4APIs = new ArrayList<RuleResult4API>();
 239         for (CorrelationRule correlationRule : correlationRules) {
 240             RuleResult4API ruleResult4API = new RuleResult4API();
 241             String description = correlationRule.getDescription() == null ? "" : correlationRule.getDescription();
 242             ruleResult4API.setRuleId(correlationRule.getRid());
 243             ruleResult4API.setRuleName(correlationRule.getName());
 244             ruleResult4API.setDescription(description);
 245             ruleResult4API.setContent(correlationRule.getContent());
 246             ruleResult4API.setCreateTime(correlationRule.getCreateTime());
 247             ruleResult4API.setCreator(correlationRule.getCreator());
 248             ruleResult4API.setUpdateTime(correlationRule.getUpdateTime());
 249             ruleResult4API.setModifier(correlationRule.getModifier());
 250             ruleResult4API.setEnabled(correlationRule.getEnabled());
 251             ruleResult4API.setLoopControlName(correlationRule.getClosedControlLoopName());
 252             ruleResult4APIs.add(ruleResult4API);
 253         }
 254         return ruleResult4APIs;
 255     }
 256
 257     private CorrelationDeployRule4Engine correlationRules2DeployRule(
 258             CorrelationRule correlationRule) {
 259         CorrelationDeployRule4Engine correlationDeployRule4Engine = new CorrelationDeployRule4Engine();
 260         correlationDeployRule4Engine.setContent(correlationRule.getContent());
 261         correlationDeployRule4Engine.setEngineId(correlationRule.getEngineID());
 262         correlationDeployRule4Engine.setLoopControlName(correlationRule.getClosedControlLoopName());
 263         return correlationDeployRule4Engine;
 264     }
 265
 266     private CorrelationCheckRule4Engine toCorrelationCheckRule(
 267             CorrelationRule correlationRule) {
 268         CorrelationCheckRule4Engine correlationCheckRule4Engine = new CorrelationCheckRule4Engine();
 269         correlationCheckRule4Engine.setContent(correlationRule.getContent());
 270         return correlationCheckRule4Engine;
 271     }
 272
 273     private boolean checkIfEngineExists(String ip) {
 274         List engineList = engineTools.getInstanceList();
 275         return engineList.contains(ip);
 276     }
 277 }