From 580d4ce637b1c09b3bd2258b0b9c8332b8789bad Mon Sep 17 00:00:00 2001 From: Congcong Peng Date: Wed, 28 Mar 2018 09:42:09 +0800 Subject: Allocate Rule Issue-ID: HOLMES-106 Change-Id: I50937669cf26ead5abb8d2ef9bd20bc61095ac1b Signed-off-by: Congcong Peng --- .../rulemgt/bolt/enginebolt/EngineService.java | 15 +- .../rulemgt/bolt/enginebolt/EngineWrapper.java | 12 +- .../onap/holmes/rulemgt/db/CorrelationRuleDao.java | 19 +- .../holmes/rulemgt/db/CorrelationRuleQueryDao.java | 1 + .../org/onap/holmes/rulemgt/msb/EngineIpList.java | 67 ++++++ .../java/org/onap/holmes/rulemgt/msb/MsbQuery.java | 79 +++++++ .../onap/holmes/rulemgt/send/Ip4AddingRule.java | 66 ++++++ .../onap/holmes/rulemgt/send/RuleAllocation.java | 228 +++++++++++++++++++++ .../holmes/rulemgt/wrapper/RuleMgtWrapper.java | 37 +++- .../holmes/rulemgt/wrapper/RuleQueryWrapper.java | 52 +++++ 10 files changed, 553 insertions(+), 23 deletions(-) create mode 100644 rulemgt/src/main/java/org/onap/holmes/rulemgt/msb/EngineIpList.java create mode 100644 rulemgt/src/main/java/org/onap/holmes/rulemgt/msb/MsbQuery.java create mode 100644 rulemgt/src/main/java/org/onap/holmes/rulemgt/send/Ip4AddingRule.java create mode 100644 rulemgt/src/main/java/org/onap/holmes/rulemgt/send/RuleAllocation.java create mode 100644 rulemgt/src/main/java/org/onap/holmes/rulemgt/wrapper/RuleQueryWrapper.java (limited to 'rulemgt/src/main') diff --git a/rulemgt/src/main/java/org/onap/holmes/rulemgt/bolt/enginebolt/EngineService.java b/rulemgt/src/main/java/org/onap/holmes/rulemgt/bolt/enginebolt/EngineService.java index 319347e..13507d6 100644 --- a/rulemgt/src/main/java/org/onap/holmes/rulemgt/bolt/enginebolt/EngineService.java +++ b/rulemgt/src/main/java/org/onap/holmes/rulemgt/bolt/enginebolt/EngineService.java @@ -32,24 +32,27 @@ import org.onap.holmes.common.config.MicroServiceConfig; @Service public class EngineService { - protected HttpResponse delete(String packageName) throws Exception { + private static final String PREFIX = "https://"; + private static final String PORT = ":9102"; + + protected HttpResponse delete(String packageName, String ip) throws Exception { HashMap headers = createHeaders(); - String url = MicroServiceConfig.getMsbServerAddrWithHttpPrefix() + RuleMgtConstant.ENGINE_PATH + "/" + packageName; + String url = PREFIX + ip + PORT + RuleMgtConstant.ENGINE_PATH + "/" + packageName; return HttpsUtils.delete(url, headers); } - protected HttpResponse check(CorrelationCheckRule4Engine correlationCheckRule4Engine) + protected HttpResponse check(CorrelationCheckRule4Engine correlationCheckRule4Engine, String ip) throws Exception { String content = GsonUtil.beanToJson(correlationCheckRule4Engine); HashMap headers = createHeaders(); - String url = MicroServiceConfig.getMsbServerAddrWithHttpPrefix() + RuleMgtConstant.ENGINE_PATH; + String url = PREFIX + ip + PORT + RuleMgtConstant.ENGINE_PATH; return HttpsUtils.post(url, headers, new HashMap<>(), new StringEntity(content)); } - protected HttpResponse deploy(CorrelationDeployRule4Engine correlationDeployRule4Engine) throws Exception { + protected HttpResponse deploy(CorrelationDeployRule4Engine correlationDeployRule4Engine, String ip) throws Exception { String content = GsonUtil.beanToJson(correlationDeployRule4Engine); HashMap headers = createHeaders(); - String url = MicroServiceConfig.getMsbServerAddrWithHttpPrefix() + RuleMgtConstant.ENGINE_PATH; + String url = PREFIX + ip + PORT + RuleMgtConstant.ENGINE_PATH; return HttpsUtils.put(url, headers, new HashMap<>(), new StringEntity(content)); } diff --git a/rulemgt/src/main/java/org/onap/holmes/rulemgt/bolt/enginebolt/EngineWrapper.java b/rulemgt/src/main/java/org/onap/holmes/rulemgt/bolt/enginebolt/EngineWrapper.java index 18a326e..b0bd1f5 100644 --- a/rulemgt/src/main/java/org/onap/holmes/rulemgt/bolt/enginebolt/EngineWrapper.java +++ b/rulemgt/src/main/java/org/onap/holmes/rulemgt/bolt/enginebolt/EngineWrapper.java @@ -34,10 +34,10 @@ public class EngineWrapper { @Inject private EngineService engineService; - public String deployEngine(CorrelationDeployRule4Engine correlationRule) throws CorrelationException { + public String deployEngine(CorrelationDeployRule4Engine correlationRule,String ip) throws CorrelationException { HttpResponse response; try { - response = engineService.deploy(correlationRule); + response = engineService.deploy(correlationRule, ip); } catch (Exception e) { throw new CorrelationException("Failed to call the rule deployment RESTful API.", e); } @@ -55,10 +55,10 @@ public class EngineWrapper { } } - public boolean deleteRuleFromEngine(String packageName) throws CorrelationException { + public boolean deleteRuleFromEngine(String packageName,String ip) throws CorrelationException { HttpResponse response; try { - response = engineService.delete(packageName); + response = engineService.delete(packageName, ip); } catch (Exception e) { throw new CorrelationException("Failed to call the rule deleting RESTful API.", e); } @@ -70,12 +70,12 @@ public class EngineWrapper { } } - public boolean checkRuleFromEngine(CorrelationCheckRule4Engine correlationCheckRule4Engine) + public boolean checkRuleFromEngine(CorrelationCheckRule4Engine correlationCheckRule4Engine,String ip) throws CorrelationException { log.info("Rule Contents: " + correlationCheckRule4Engine.getContent()); HttpResponse response; try { - response = engineService.check(correlationCheckRule4Engine); + response = engineService.check(correlationCheckRule4Engine, ip); } catch (Exception e) { throw new CorrelationException("Failed to call the rule verification RESTful API.", e); } diff --git a/rulemgt/src/main/java/org/onap/holmes/rulemgt/db/CorrelationRuleDao.java b/rulemgt/src/main/java/org/onap/holmes/rulemgt/db/CorrelationRuleDao.java index a94c1db..64dcea2 100644 --- a/rulemgt/src/main/java/org/onap/holmes/rulemgt/db/CorrelationRuleDao.java +++ b/rulemgt/src/main/java/org/onap/holmes/rulemgt/db/CorrelationRuleDao.java @@ -30,10 +30,10 @@ import org.skife.jdbi.v2.sqlobject.customizers.RegisterMapper; public abstract class CorrelationRuleDao { @GetGeneratedKeys - @SqlUpdate("INSERT INTO APLUS_RULE (NAME,CTRLLOOP,DESCRIPTION,ENABLE,TEMPLATEID,ENGINETYPE,CREATOR,UPDATOR,PARAMS,CONTENT ,VENDOR,CREATETIME,UPDATETIME,ENGINEID,PACKAGE,RID) VALUES (:name,:closedControlLoopName,:description,:enabled,:templateID,:engineType,:creator,:modifier,:params,:content,:vendor,:createTime,:updateTime,:engineID,:packageName,:rid)") + @SqlUpdate("INSERT INTO APLUS_RULE (NAME,CTRLLOOP,DESCRIPTION,ENABLE,TEMPLATEID,ENGINETYPE,CREATOR,UPDATOR,PARAMS,CONTENT ,VENDOR,CREATETIME,UPDATETIME,ENGINEID,PACKAGE,RID, ENGINEINSTANCE) VALUES (:name,:closedControlLoopName,:description,:enabled,:templateID,:engineType,:creator,:modifier,:params,:content,:vendor,:createTime,:updateTime,:engineID,:packageName,:rid,:engineInstance)") protected abstract String addRule(@BindBean CorrelationRule correlationRule); - @SqlUpdate("UPDATE APLUS_RULE SET CTRLLOOP=:closedControlLoopName,DESCRIPTION=:description,ENABLE=:enabled,CONTENT=:content,UPDATOR=:modifier,UPDATETIME=:updateTime, PACKAGE=:packageName WHERE RID=:rid") + @SqlUpdate("UPDATE APLUS_RULE SET CTRLLOOP=:closedControlLoopName,DESCRIPTION=:description,ENABLE=:enabled,CONTENT=:content,UPDATOR=:modifier,UPDATETIME=:updateTime, PACKAGE=:packageName, ENGINEINSTANCE=:engineInstance WHERE RID=:rid") protected abstract int updateRuleByRid(@BindBean CorrelationRule correlationRule); @SqlUpdate("DELETE FROM APLUS_RULE WHERE RID=:rid") @@ -51,6 +51,21 @@ public abstract class CorrelationRuleDao { @SqlQuery("SELECT * FROM APLUS_RULE WHERE NAME=:name") protected abstract CorrelationRule queryRuleByName(@Bind("name") String name); + @SqlQuery("SELECT * FROM APLUS_RULE WHERE enable=:enable") + public abstract List queryRuleByEnable(@Bind("enable") int enable); + + @SqlQuery("SELECT * FROM APLUS_RULE WHERE engineinstance=:engineinstance") + public abstract List queryRuleByEngineInstance(@Bind("engineinstance") String engineinstance); + + public List queryRuleByRuleEngineInstance(String enginetype) { + return queryRuleByEngineInstance(enginetype); + } + + public List queryRuleByRuleEnable(int enable) { + return queryRuleByEnable(enable); + } + + private void deleteRule2DbInner(CorrelationRule correlationRule) { String name = correlationRule.getName() != null ? correlationRule.getName().trim() : ""; String rid = correlationRule.getRid() != null ? correlationRule.getRid().trim() : ""; diff --git a/rulemgt/src/main/java/org/onap/holmes/rulemgt/db/CorrelationRuleQueryDao.java b/rulemgt/src/main/java/org/onap/holmes/rulemgt/db/CorrelationRuleQueryDao.java index 85980e5..b0f0b96 100644 --- a/rulemgt/src/main/java/org/onap/holmes/rulemgt/db/CorrelationRuleQueryDao.java +++ b/rulemgt/src/main/java/org/onap/holmes/rulemgt/db/CorrelationRuleQueryDao.java @@ -81,6 +81,7 @@ public class CorrelationRuleQueryDao { correlationRule.setVendor((String) value.get("vendor")); correlationRule.setPackageName((String) value.get("package")); correlationRule.setClosedControlLoopName((String) value.get("ctrlloop")); + correlationRule.setEngineInstance((String) value.get("engineInstance")); return correlationRule; } diff --git a/rulemgt/src/main/java/org/onap/holmes/rulemgt/msb/EngineIpList.java b/rulemgt/src/main/java/org/onap/holmes/rulemgt/msb/EngineIpList.java new file mode 100644 index 0000000..cfccd18 --- /dev/null +++ b/rulemgt/src/main/java/org/onap/holmes/rulemgt/msb/EngineIpList.java @@ -0,0 +1,67 @@ +/** + * Copyright 2017 ZTE Corporation. + * + * 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.onap.holmes.rulemgt.msb; + + +import org.apache.http.HttpResponse; +import org.jvnet.hk2.annotations.Service; +import org.onap.holmes.common.api.entity.ServiceEntity; +import org.onap.holmes.common.api.entity.ServiceNode4Query; +import org.onap.holmes.common.config.MicroServiceConfig; +import org.onap.holmes.common.utils.GsonUtil; +import org.onap.holmes.common.utils.HttpsUtils; + +import javax.annotation.PostConstruct; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +@Service +public class EngineIpList { + + private String[] msbAddrInfo; + private String ip; + private String port; + private String url; + + @PostConstruct + public void init(){ + msbAddrInfo = MicroServiceConfig.getMsbIpAndPort(); + ip = msbAddrInfo[0]; + port = msbAddrInfo[1]; + url = "http://" + ip + ":" + port + "/api/microservices/v1/services/holmes-engine-mgmt/version/v1" ; + } + + public List getServiceCount()throws Exception{ + String response; + try { + HttpResponse httpResponse = HttpsUtils + .get(url, new HashMap<>()); + response = HttpsUtils.extractResponseEntity(httpResponse); + } catch (Exception e) { + throw e; + } + ServiceEntity service = GsonUtil.jsonToBean(response, ServiceEntity.class); + List nodesList = service.getNodes(); + List ipList = new ArrayList<>(); + for(ServiceNode4Query node : nodesList){ + ipList.add(node.getIp()); + } + return ipList; + + } + +} diff --git a/rulemgt/src/main/java/org/onap/holmes/rulemgt/msb/MsbQuery.java b/rulemgt/src/main/java/org/onap/holmes/rulemgt/msb/MsbQuery.java new file mode 100644 index 0000000..ed9b9af --- /dev/null +++ b/rulemgt/src/main/java/org/onap/holmes/rulemgt/msb/MsbQuery.java @@ -0,0 +1,79 @@ +/** + * Copyright 2017 ZTE Corporation. + * + * 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.onap.holmes.rulemgt.msb; + +import lombok.extern.slf4j.Slf4j; +import org.jvnet.hk2.annotations.Service; +import org.onap.holmes.rulemgt.send.RuleAllocation; +import org.onap.holmes.rulemgt.send.Ip4AddingRule; +import org.onap.holmes.rulemgt.wrapper.RuleMgtWrapper; + +import javax.annotation.PostConstruct; +import javax.inject.Inject; +import java.util.List; +import java.util.Timer; +import java.util.TimerTask; + + +@Service +@Slf4j +public class MsbQuery { + + @Inject + private RuleAllocation ruleAllocation; + + @Inject + private Ip4AddingRule ip4AddingRule; + + @Inject + private EngineIpList engineIpList; + + @Inject + private RuleMgtWrapper ruleMgtWrapper; + + private List timerIpList; + + @PostConstruct + public void init() { + + try{ + timer(); + }catch(Exception e){ + log.error("MSBQuery init timer task failed !" + e.getMessage()); + } + + } + + public void timer() throws Exception{ + Timer timer = new Timer(); + timer.schedule(new TimerTask() { + + public void run() { + try { + timerIpList = engineIpList.getServiceCount(); + ip4AddingRule.getIpList(timerIpList); + ruleAllocation.judgeAndAllocateRule(timerIpList); + + } catch (Exception e) { + log.error("The timing query engine instance failed " ,e); + } + } + + }, 5000, 30000); + + } + +} diff --git a/rulemgt/src/main/java/org/onap/holmes/rulemgt/send/Ip4AddingRule.java b/rulemgt/src/main/java/org/onap/holmes/rulemgt/send/Ip4AddingRule.java new file mode 100644 index 0000000..f82d3a4 --- /dev/null +++ b/rulemgt/src/main/java/org/onap/holmes/rulemgt/send/Ip4AddingRule.java @@ -0,0 +1,66 @@ +/** + * Copyright 2017 ZTE Corporation. + * + * 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.onap.holmes.rulemgt.send; + +import lombok.extern.slf4j.Slf4j; +import org.jvnet.hk2.annotations.Service; +import org.onap.holmes.common.api.entity.CorrelationRule; +import org.onap.holmes.rulemgt.wrapper.RuleQueryWrapper; + +import javax.inject.Inject; +import java.util.*; + +@Service +@Slf4j +public class Ip4AddingRule { + + @Inject + private RuleQueryWrapper ruleQueryWrapper; + private List engineService; + + public void getIpList(List ipList){ + engineService = ipList; + } + + public String getEngineIp4AddRule() { + List ipRuleList = new ArrayList<>(); + LinkedHashMap linkedHashMap = new LinkedHashMap(); + + try{ + for(String ip : engineService){ + ipRuleList = ruleQueryWrapper.queryRuleByEngineInstance(ip); + if(ipRuleList != null) { + linkedHashMap.put(ip, ipRuleList.size()); + } + } + }catch (Exception e){ + log.error("getEngineIp4AddRule failed !" + e.getMessage()); + } + + //min + Collection c = linkedHashMap.values(); + Object[] obj = c.toArray(); + Arrays.sort(obj); + String ip = null; + for(String getKey: linkedHashMap.keySet()){ + if(linkedHashMap.get(getKey).equals(obj[0])){ + ip = getKey; + } + } + return ip; + } +} diff --git a/rulemgt/src/main/java/org/onap/holmes/rulemgt/send/RuleAllocation.java b/rulemgt/src/main/java/org/onap/holmes/rulemgt/send/RuleAllocation.java new file mode 100644 index 0000000..e69be51 --- /dev/null +++ b/rulemgt/src/main/java/org/onap/holmes/rulemgt/send/RuleAllocation.java @@ -0,0 +1,228 @@ +/** + * Copyright 2017 ZTE Corporation. + * + * 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.onap.holmes.rulemgt.send; + +import lombok.extern.slf4j.Slf4j; +import org.jvnet.hk2.annotations.Service; +import org.onap.holmes.common.api.entity.CorrelationRule; +import org.onap.holmes.common.exception.CorrelationException; +import org.onap.holmes.common.utils.DbDaoUtil; +import org.onap.holmes.rulemgt.bolt.enginebolt.EngineWrapper; +import org.onap.holmes.rulemgt.db.CorrelationRuleDao; +import org.onap.holmes.rulemgt.msb.EngineIpList; +import org.onap.holmes.rulemgt.wrapper.RuleQueryWrapper; +import org.onap.holmes.rulemgt.wrapper.RuleMgtWrapper; + +import javax.annotation.PostConstruct; +import javax.inject.Inject; +import java.util.*; + + +@Service +@Slf4j +public class RuleAllocation { + + private final static int ENABLE = 1; + + @Inject + private RuleMgtWrapper ruleMgtWrapper; + @Inject + private RuleQueryWrapper ruleQueryWrapper; + @Inject + private EngineWrapper engineWrapper; + @Inject + private EngineIpList engineIpList; + @Inject + private DbDaoUtil daoUtil; + + private CorrelationRuleDao correlationRuleDao; + + private int ruleCount; + private int serviceCount; + private List temIpList = new ArrayList<>(); + private List engineService = new ArrayList<>(); + private List allRules = new ArrayList<>(); + + @PostConstruct + public void initDaoUtilAndEngineIp() throws Exception{ + correlationRuleDao = daoUtil.getJdbiDaoByOnDemand(CorrelationRuleDao.class); + temIpList = engineIpList.getServiceCount(); + } + + public void judgeAndAllocateRule(List ipList)throws Exception{ + if(ipList != null) { + engineService = ipList; + serviceCount = ipList.size(); + } + if(temIpList.size() < serviceCount){ + //extend + List deleteRule = calculateRule(temIpList); + List allocateRule = calculateRule(temIpList); + List extendIp = extendCompareIp(engineService,temIpList); + AllocateService(extendIp,allocateRule); + deleteRuleFromFormerEngine(deleteRule,temIpList); + + } else if (temIpList.size() > serviceCount) { + //destroy + List destroyIp = destroyCompareIp(engineService, temIpList); + AllocateService(restIp(destroyIp), relocateRuleAfterDestroy(destroyIp)); + + } else if(temIpList.size() == serviceCount) { + temIpList = engineService; + return; + } + temIpList = engineService; + + } + + + // When the engine is expanding, the rules that need to be allocated are calculated. + private List calculateRule(List oldIpList) throws Exception{ + allRules = ruleQueryWrapper.queryRuleByEnable(ENABLE); + if(allRules != null) { + ruleCount = allRules.size(); + } + int count = ruleCount / serviceCount; + int remainder = ruleCount % serviceCount; + + List subRule = new ArrayList<>(); + for(String ip : oldIpList) { + List rules = ruleQueryWrapper.queryRuleByEngineInstance(ip); + List tem = rules.subList(count + (remainder-- / oldIpList.size()),rules.size()); + subRule.addAll(tem); + } + return subRule; + } + + //Rules that need to be allocated after the engine is destroyed + private List relocateRuleAfterDestroy(List destroyIpList) throws CorrelationException { + List rules = new ArrayList<>(); + try{ + if(destroyIpList != null){ + for(String ip : destroyIpList) { + rules.addAll(ruleQueryWrapper.queryRuleByEngineInstance(ip)); + } + } + }catch(CorrelationException e) { + log.error("method relocateRuleAfterDestroy get data from DB failed !" +e.getMessage()); + } + return rules; + } + + //Extended IP + private List extendCompareIp(List newList, List oldList){ + List extendIpList = new ArrayList<>(); + + for( String ip :newList) { + if(! oldList.contains(ip)) { + extendIpList.add(ip); + } + } + return extendIpList; + } + + //Destroyed IP + private List destroyCompareIp(List newList, List oldList) { + List destroyIpList = new ArrayList<>(); + for(String ip : oldList) { + if(!newList.contains(ip)) { + destroyIpList.add(ip); + } + } + return destroyIpList; + } + + //Residual IP after destruction + private List restIp(List destroyIp) { + List restIpList = new ArrayList<>(); + for(String ip : engineService) { + if(!destroyIp.contains(ip)) { + restIpList.add(ip); + } + } + return restIpList; + } + + public void AllocateService(List extendIpList, List subList) throws Exception{ + List needIpList = getSortIp(extendIpList); + + for(int i=0,j=0;j < subList.size();i++,j++ ){ + int index = i % needIpList.size(); + String deployIp = needIpList.get(index); + CorrelationRule rule = subList.get(j); + rule.setEngineInstance(deployIp); + allocateDeployRule(rule,deployIp); + } + } + + //The IP to be allocated is in ascending order, and the least is circulate. + private List getSortIp(List ipList){ + List ipRuleList = new ArrayList<>(); + HashMap hashMap = new HashMap(); + + try{ + for(String ip : ipList){ + ipRuleList = ruleQueryWrapper.queryRuleByEngineInstance(ip); + if(ipRuleList != null) { + hashMap.put(ip, String.valueOf(ipRuleList.size())); + } + } + }catch (Exception e){ + log.error("getEngineIp4AddRule failed !" + e.getMessage()); + } + + List> list_Data = new ArrayList>(hashMap.entrySet()); + Collections.sort(list_Data, new Comparator>() { + public int compare(Map.Entry o1, Map.Entry o2) + { + return o1.getValue().compareTo(o2.getValue()); + } + }); + + List needList = new ArrayList<>(); + for(Map.Entry map: list_Data) { + String key = map.getKey(); + needList.add(key); + } + return needList; + } + + private void allocateDeployRule(CorrelationRule rule, String ip) throws CorrelationException { + try{ + ruleMgtWrapper.deployRule2Engine(rule,ip); + correlationRuleDao.updateRule(rule); + }catch (CorrelationException e){ + throw new CorrelationException("allocate Deploy Rule failed", e); + } + } + + private void deleteRuleFromFormerEngine(List subRule, List oldList) { + try{ + for(String ip : oldList){ + for(CorrelationRule rule: subRule) { + if(ip.equals(rule.getEngineInstance())) { + engineWrapper.deleteRuleFromEngine(rule.getPackageName(),ip); + } + } + } + }catch (CorrelationException e) { + log.error("When the engine is extended, deleting rule failed" +e.getMessage()); + } + + } + +} diff --git a/rulemgt/src/main/java/org/onap/holmes/rulemgt/wrapper/RuleMgtWrapper.java b/rulemgt/src/main/java/org/onap/holmes/rulemgt/wrapper/RuleMgtWrapper.java index 484fb5f..196b21a 100644 --- a/rulemgt/src/main/java/org/onap/holmes/rulemgt/wrapper/RuleMgtWrapper.java +++ b/rulemgt/src/main/java/org/onap/holmes/rulemgt/wrapper/RuleMgtWrapper.java @@ -23,7 +23,6 @@ import javax.inject.Inject; import javax.inject.Singleton; import lombok.extern.slf4j.Slf4j; import org.jvnet.hk2.annotations.Service; -import org.onap.holmes.common.dmaap.DmaapService; import org.onap.holmes.rulemgt.bean.request.CorrelationCheckRule4Engine; import org.onap.holmes.rulemgt.bean.response.RuleResult4API; import org.onap.holmes.rulemgt.constant.RuleMgtConstant; @@ -40,6 +39,7 @@ import org.onap.holmes.rulemgt.bean.response.RuleAddAndUpdateResponse; import org.onap.holmes.rulemgt.bean.response.RuleQueryListResponse; import org.onap.holmes.rulemgt.bolt.enginebolt.EngineWrapper; import org.onap.holmes.rulemgt.db.CorrelationRuleQueryDao; +import org.onap.holmes.rulemgt.send.Ip4AddingRule; @Service @@ -47,6 +47,12 @@ import org.onap.holmes.rulemgt.db.CorrelationRuleQueryDao; @Slf4j public class RuleMgtWrapper { + @Inject + private Ip4AddingRule ip4AddingRule; + + @Inject + private RuleQueryWrapper ruleQueryWrapper; + @Inject private CorrelationRuleQueryDao correlationRuleQueryDao; @Inject @@ -73,13 +79,20 @@ public class RuleMgtWrapper { if (ruleTemp != null) { throw new CorrelationException("A rule with the same name already exists."); } - String packageName = deployRule2Engine(correlationRule); + String ip =""; + try{ + ip = ip4AddingRule.getEngineIp4AddRule(); + }catch(Exception e){ + log.error("When adding rules, can not get engine instance ip"); + } + String packageName = deployRule2Engine(correlationRule, ip); correlationRule.setPackageName(packageName); + correlationRule.setEngineInstance(ip); CorrelationRule result = null; try { result = correlationRuleDao.saveRule(correlationRule); } catch (CorrelationException e) { - engineWarpper.deleteRuleFromEngine(packageName); + engineWarpper.deleteRuleFromEngine(packageName, ip); throw new CorrelationException(e.getMessage(), e); } RuleAddAndUpdateResponse ruleAddAndUpdateResponse = new RuleAddAndUpdateResponse(); @@ -96,18 +109,23 @@ public class RuleMgtWrapper { if (oldCorrelationRule == null) { throw new CorrelationException("You're trying to update a rule which does not exist in the system."); } + String updateIp = ""; + updateIp = oldCorrelationRule.getEngineInstance(); CorrelationRule newCorrelationRule = convertRuleUpdateRequest2CorrelationRule(modifier, ruleUpdateRequest, oldCorrelationRule.getName()); + newCorrelationRule.setEngineInstance(updateIp); checkCorrelation(newCorrelationRule); RuleAddAndUpdateResponse ruleChangeResponse = new RuleAddAndUpdateResponse(); ruleChangeResponse.setRuleId(newCorrelationRule.getRid()); + if (!haveChange(newCorrelationRule, oldCorrelationRule)) { return ruleChangeResponse; } if (oldCorrelationRule.getEnabled() == RuleMgtConstant.STATUS_RULE_OPEN) { - engineWarpper.deleteRuleFromEngine(oldCorrelationRule.getPackageName()); + String oldRuleEngineInstance = oldCorrelationRule.getEngineInstance(); + engineWarpper.deleteRuleFromEngine(oldCorrelationRule.getPackageName(), oldRuleEngineInstance); } - newCorrelationRule.setPackageName(deployRule2Engine(newCorrelationRule)); + newCorrelationRule.setPackageName(deployRule2Engine(newCorrelationRule, updateIp)); correlationRuleDao.updateRule(newCorrelationRule); return ruleChangeResponse; } @@ -155,7 +173,8 @@ public class RuleMgtWrapper { throw new CorrelationException("You're trying to delete a rule which does not exist in the system."); } if (correlationRule.getEnabled() == RuleMgtConstant.STATUS_RULE_OPEN) { - engineWarpper.deleteRuleFromEngine(correlationRule.getPackageName()); + String ip = correlationRule.getEngineInstance(); + engineWarpper.deleteRuleFromEngine(correlationRule.getPackageName(), ip); } correlationRuleDao.deleteRule(correlationRule); } @@ -200,11 +219,11 @@ public class RuleMgtWrapper { return correlationRule; } - private String deployRule2Engine(CorrelationRule correlationRule) + public String deployRule2Engine(CorrelationRule correlationRule, String ip) throws CorrelationException { - if (engineWarpper.checkRuleFromEngine(correlationRules2CheckRule(correlationRule)) && ( + if (engineWarpper.checkRuleFromEngine(correlationRules2CheckRule(correlationRule), ip) && ( correlationRule.getEnabled() == RuleMgtConstant.STATUS_RULE_OPEN)) { - return engineWarpper.deployEngine(correlationRules2DeployRule(correlationRule)); + return engineWarpper.deployEngine(correlationRules2DeployRule(correlationRule), ip); } return ""; } diff --git a/rulemgt/src/main/java/org/onap/holmes/rulemgt/wrapper/RuleQueryWrapper.java b/rulemgt/src/main/java/org/onap/holmes/rulemgt/wrapper/RuleQueryWrapper.java new file mode 100644 index 0000000..0ad836f --- /dev/null +++ b/rulemgt/src/main/java/org/onap/holmes/rulemgt/wrapper/RuleQueryWrapper.java @@ -0,0 +1,52 @@ +/** + * Copyright 2017 ZTE Corporation. + * + * 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.onap.holmes.rulemgt.wrapper; + +import org.jvnet.hk2.annotations.Service; +import org.onap.holmes.common.api.entity.CorrelationRule; +import org.onap.holmes.common.exception.CorrelationException; +import org.onap.holmes.common.utils.DbDaoUtil; +import org.onap.holmes.rulemgt.db.CorrelationRuleDao; + +import javax.annotation.PostConstruct; +import javax.inject.Inject; +import java.util.List; + +@Service +public class RuleQueryWrapper { + + @Inject + private DbDaoUtil daoUtil; + private CorrelationRuleDao correlationRuleDao; + + @PostConstruct + public void initDaoUtil() { + correlationRuleDao = daoUtil.getJdbiDaoByOnDemand(CorrelationRuleDao.class); + } + + public List queryRuleByEnable(int enable) throws CorrelationException { + List ruleTemp = daoUtil.getJdbiDaoByOnDemand(CorrelationRuleDao.class) + .queryRuleByRuleEnable(enable); + return ruleTemp; + } + + public List queryRuleByEngineInstance(String instance) throws CorrelationException { + List ruleTemp = daoUtil.getJdbiDaoByOnDemand(CorrelationRuleDao.class) + .queryRuleByRuleEngineInstance(instance); + return ruleTemp; + } +} -- cgit 1.2.3-korg