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

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