holmes-actions/src/main/java/org/onap/holmes/common/dmaap/DmaapService.java

   1 /*
   2  * Copyright 2017-2020 ZTE Corporation.
   3  *
   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  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.common.dmaap;
  17
  18 import org.jvnet.hk2.annotations.Service;
  19 import org.onap.holmes.common.aai.AaiQuery;
  20 import org.onap.holmes.common.aai.entity.RelationshipList.Relationship;
  21 import org.onap.holmes.common.aai.entity.VmEntity;
  22 import org.onap.holmes.common.aai.entity.VnfEntity;
  23 import org.onap.holmes.common.api.stat.VesAlarm;
  24 import org.onap.holmes.common.dcae.DcaeConfigurationsCache;
  25 import org.onap.holmes.common.dmaap.entity.PolicyMsg;
  26 import org.onap.holmes.common.dmaap.entity.PolicyMsg.EVENT_STATUS;
  27 import org.onap.holmes.common.dmaap.store.ClosedLoopControlNameCache;
  28 import org.onap.holmes.common.dmaap.store.UniqueRequestIdCache;
  29 import org.onap.holmes.common.exception.CorrelationException;
  30 import org.onap.holmes.common.utils.GsonUtil;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 import javax.inject.Inject;
  35 import java.util.Map.Entry;
  36 import java.util.Optional;
  37 import java.util.UUID;
  38
  39 @Service
  40 public class DmaapService {
  41
  42     private static final Logger log = LoggerFactory.getLogger(DmaapService.class);
  43
  44     private AaiQuery aaiQuery;
  45     private ClosedLoopControlNameCache closedLoopControlNameCache;
  46     private UniqueRequestIdCache uniqueRequestIdCache;
  47
  48     @Inject
  49     public void setAaiQuery(AaiQuery aaiQuery) {
  50         this.aaiQuery = aaiQuery;
  51     }
  52
  53     @Inject
  54     public void setClosedLoopControlNameCache(ClosedLoopControlNameCache closedLoopControlNameCache) {
  55         this.closedLoopControlNameCache = closedLoopControlNameCache;
  56     }
  57
  58     @Inject
  59     public void setUniqueRequestIdCache(UniqueRequestIdCache uniqueRequestIdCache) {
  60         this.uniqueRequestIdCache = uniqueRequestIdCache;
  61     }
  62
  63     public void publishPolicyMsg(PolicyMsg policyMsg, String dmaapConfigKey) {
  64         try {
  65             Publisher publisher = new Publisher();
  66             publisher.setUrl(DcaeConfigurationsCache.getPubSecInfo(dmaapConfigKey).getDmaapInfo()
  67                     .getTopicUrl());
  68             publisher.publish(policyMsg);
  69             deleteRequestIdIfNecessary(policyMsg);
  70             log.info("send policyMsg: " + GsonUtil.beanToJson(policyMsg));
  71         } catch (CorrelationException e) {
  72             log.error("Failed to publish the control loop event to DMaaP", e);
  73         } catch (NullPointerException e) {
  74             log.error(String.format("DMaaP configurations do not exist!\n DCAE Configurations: \n %s",
  75                     DcaeConfigurationsCache.getDcaeConfigurations()), e);
  76         }
  77     }
  78
  79     public PolicyMsg getPolicyMsg(VesAlarm rootAlarm, VesAlarm childAlarm, String packgeName) {
  80         return Optional.ofNullable(getVmEntity(rootAlarm.getSourceId(), rootAlarm.getSourceName()))
  81                 .map(vmEntity -> getEnrichedPolicyMsg(vmEntity, rootAlarm, childAlarm, packgeName))
  82                 .orElse(getDefaultPolicyMsg(rootAlarm, packgeName));
  83     }
  84
  85     private PolicyMsg getEnrichedPolicyMsg(VmEntity vmEntity, VesAlarm rootAlarm, VesAlarm childAlarm,
  86             String packageName) {
  87         PolicyMsg policyMsg = new PolicyMsg();
  88         policyMsg.setRequestID(getUniqueRequestId(rootAlarm));
  89         if (rootAlarm.getAlarmIsCleared() == PolicyMassgeConstant.POLICY_MESSAGE_ONSET) {
  90             enrichVnfInfo(vmEntity, childAlarm, policyMsg);
  91             policyMsg.setClosedLoopEventStatus(EVENT_STATUS.ONSET);
  92             policyMsg.getAai().put("vserver.in-maint", vmEntity.getInMaint());
  93             policyMsg.getAai().put("vserver.is-closed-loop-disabled",
  94                         vmEntity.getClosedLoopDisable());
  95             policyMsg.getAai().put("vserver.prov-status", vmEntity.getProvStatus());
  96             policyMsg.getAai().put("vserver.resource-version", vmEntity.getResourceVersion());
  97         } else {
  98             policyMsg.setClosedLoopAlarmEnd(rootAlarm.getLastEpochMicrosec());
  99             policyMsg.setClosedLoopEventStatus(EVENT_STATUS.ABATED);
 100         }
 101         policyMsg.setClosedLoopControlName(closedLoopControlNameCache.get(packageName));
 102         policyMsg.setClosedLoopAlarmStart(rootAlarm.getStartEpochMicrosec());
 103         policyMsg.getAai().put("vserver.vserver-id", vmEntity.getVserverId());
 104         policyMsg.getAai().put("vserver.vserver-name", vmEntity.getVserverName());
 105         policyMsg.getAai().put("vserver.vserver-name2", vmEntity.getVserverName2());
 106         policyMsg.getAai().put("vserver.vserver-selflink", vmEntity.getVserverSelflink());
 107         policyMsg.setTarget("vserver.vserver-name");
 108         return policyMsg;
 109     }
 110
 111     private PolicyMsg getDefaultPolicyMsg(VesAlarm rootAlarm, String packageName) {
 112         PolicyMsg policyMsg = new PolicyMsg();
 113         policyMsg.setRequestID(getUniqueRequestId(rootAlarm));
 114         policyMsg.setClosedLoopControlName(closedLoopControlNameCache.get(packageName));
 115         policyMsg.setClosedLoopAlarmStart(rootAlarm.getStartEpochMicrosec());
 116         policyMsg.setTarget("vserver.vserver-name");
 117         policyMsg.setTargetType("VM");
 118         policyMsg.getAai().put("vserver.vserver-name", rootAlarm.getSourceName());
 119         if (rootAlarm.getAlarmIsCleared() == PolicyMassgeConstant.POLICY_MESSAGE_ABATED) {
 120             policyMsg.setClosedLoopAlarmEnd(rootAlarm.getLastEpochMicrosec());
 121             policyMsg.setClosedLoopEventStatus(EVENT_STATUS.ABATED);
 122         }
 123         return policyMsg;
 124     }
 125
 126     private String getUniqueRequestId(VesAlarm rootAlarm) {
 127         String alarmUniqueKey = "";
 128         if (rootAlarm.getAlarmIsCleared() == PolicyMassgeConstant.POLICY_MESSAGE_ABATED) {
 129             alarmUniqueKey =
 130                     rootAlarm.getSourceId() + ":" + rootAlarm.getEventName().replace("Cleared", "");
 131         } else {
 132             alarmUniqueKey = rootAlarm.getSourceId() + ":" + rootAlarm.getEventName();
 133         }
 134         if (uniqueRequestIdCache.containsKey(alarmUniqueKey)) {
 135             return uniqueRequestIdCache.get(alarmUniqueKey);
 136         } else {
 137             String requestID = UUID.randomUUID().toString();
 138             uniqueRequestIdCache.put(alarmUniqueKey, requestID);
 139             return requestID;
 140         }
 141     }
 142
 143     private void enrichVnfInfo(VmEntity vmEntity, VesAlarm childAlarm, PolicyMsg policyMsg) {
 144         String vnfId = "";
 145         String vnfName = "";
 146         if (null != childAlarm) {
 147             vnfId = childAlarm.getSourceId();
 148             vnfName = childAlarm.getSourceName();
 149         } else {
 150             Relationship relationship = vmEntity.getRelationshipList()
 151                     .getRelationship(PolicyMassgeConstant.GENERIC_VNF);
 152             if (null != relationship) {
 153                 vnfId = relationship.getRelationshipDataValue(PolicyMassgeConstant.GENERIC_VNF_VNF_ID);
 154                 vnfName = relationship.getRelatedToPropertyValue(PolicyMassgeConstant.GENERIC_VNF_VNF_NAME);
 155             }
 156         }
 157         VnfEntity vnfEntity = getVnfEntity(vnfId, vnfName);
 158         String vserverInstatnceId = getVserverInstanceId(vnfEntity);
 159         policyMsg.getAai().put("generic-vnf.vnf-id", vnfId);
 160         policyMsg.getAai().put("generic-vnf.service-instance-id", vserverInstatnceId);
 161     }
 162
 163
 164     private String getVserverInstanceId(VnfEntity vnfEntity) {
 165         String vserverInstanceId = "";
 166         if (vnfEntity != null) {
 167             Relationship relationship = vnfEntity.getRelationshipList()
 168                     .getRelationship(PolicyMassgeConstant.SERVICE_INSTANCE);
 169             if (relationship == null) {
 170                 return vserverInstanceId;
 171             }
 172             vserverInstanceId = relationship
 173                     .getRelationshipDataValue(PolicyMassgeConstant.SERVICE_INSTANCE_ID);
 174         }
 175         return vserverInstanceId;
 176     }
 177
 178     private VnfEntity getVnfEntity(String vnfId, String vnfName) {
 179         VnfEntity vnfEntity = null;
 180         try {
 181             vnfEntity = aaiQuery.getAaiVnfData(vnfId, vnfName);
 182         } catch (CorrelationException e) {
 183             log.error("Failed to get the VNF data.", e);
 184         }
 185         return vnfEntity;
 186     }
 187
 188     private VmEntity getVmEntity(String sourceId, String sourceName) {
 189         VmEntity vmEntity = null;
 190         try {
 191             vmEntity = aaiQuery.getAaiVmData(sourceId, sourceName);
 192         } catch (CorrelationException e) {
 193             log.error("Failed to get the VM data.", e);
 194         }
 195         return vmEntity;
 196     }
 197
 198     private void deleteRequestIdIfNecessary(PolicyMsg policyMsg){
 199         EVENT_STATUS status = policyMsg.getClosedLoopEventStatus();
 200         if(EVENT_STATUS.ABATED.equals(status)) {
 201             String requestId = policyMsg.getRequestID();
 202             for(Entry<String, String> kv: uniqueRequestIdCache.entrySet()) {
 203                 if(kv.getValue().equals(requestId)) {
 204                     uniqueRequestIdCache.remove(kv.getKey());
 205                     break;
 206                 }
 207             }
 208             log.info("An alarm is cleared and the corresponding requestId is deleted successfully");
 209         }
 210     }
 211 }