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("DMaaP configurations do not exist!");
  75         }
  76     }
  77
  78     public PolicyMsg getPolicyMsg(VesAlarm rootAlarm, VesAlarm childAlarm, String packgeName) {
  79         return Optional.ofNullable(getVmEntity(rootAlarm.getSourceId(), rootAlarm.getSourceName()))
  80                 .map(vmEntity -> getEnrichedPolicyMsg(vmEntity, rootAlarm, childAlarm, packgeName))
  81                 .orElse(getDefaultPolicyMsg(rootAlarm, packgeName));
  82     }
  83
  84     private PolicyMsg getEnrichedPolicyMsg(VmEntity vmEntity, VesAlarm rootAlarm, VesAlarm childAlarm,
  85             String packageName) {
  86         PolicyMsg policyMsg = new PolicyMsg();
  87         policyMsg.setRequestID(getUniqueRequestId(rootAlarm));
  88         if (rootAlarm.getAlarmIsCleared() == PolicyMassgeConstant.POLICY_MESSAGE_ONSET) {
  89             enrichVnfInfo(vmEntity, childAlarm, policyMsg);
  90             policyMsg.setClosedLoopEventStatus(EVENT_STATUS.ONSET);
  91             policyMsg.getAai().put("vserver.in-maint", vmEntity.getInMaint());
  92             policyMsg.getAai().put("vserver.is-closed-loop-disabled",
  93                         vmEntity.getClosedLoopDisable());
  94             policyMsg.getAai().put("vserver.prov-status", vmEntity.getProvStatus());
  95             policyMsg.getAai().put("vserver.resource-version", vmEntity.getResourceVersion());
  96         } else {
  97             policyMsg.setClosedLoopAlarmEnd(rootAlarm.getLastEpochMicrosec());
  98             policyMsg.setClosedLoopEventStatus(EVENT_STATUS.ABATED);
  99         }
 100         policyMsg.setClosedLoopControlName(closedLoopControlNameCache.get(packageName));
 101         policyMsg.setClosedLoopAlarmStart(rootAlarm.getStartEpochMicrosec());
 102         policyMsg.getAai().put("vserver.vserver-id", vmEntity.getVserverId());
 103         policyMsg.getAai().put("vserver.vserver-name", vmEntity.getVserverName());
 104         policyMsg.getAai().put("vserver.vserver-name2", vmEntity.getVserverName2());
 105         policyMsg.getAai().put("vserver.vserver-selflink", vmEntity.getVserverSelflink());
 106         policyMsg.setTarget("vserver.vserver-name");
 107         return policyMsg;
 108     }
 109
 110     private PolicyMsg getDefaultPolicyMsg(VesAlarm rootAlarm, String packageName) {
 111         PolicyMsg policyMsg = new PolicyMsg();
 112         policyMsg.setRequestID(getUniqueRequestId(rootAlarm));
 113         policyMsg.setClosedLoopControlName(closedLoopControlNameCache.get(packageName));
 114         policyMsg.setClosedLoopAlarmStart(rootAlarm.getStartEpochMicrosec());
 115         policyMsg.setTarget("vserver.vserver-name");
 116         policyMsg.setTargetType("VM");
 117         policyMsg.getAai().put("vserver.vserver-name", rootAlarm.getSourceName());
 118         if (rootAlarm.getAlarmIsCleared() == PolicyMassgeConstant.POLICY_MESSAGE_ABATED) {
 119             policyMsg.setClosedLoopAlarmEnd(rootAlarm.getLastEpochMicrosec());
 120             policyMsg.setClosedLoopEventStatus(EVENT_STATUS.ABATED);
 121         }
 122         return policyMsg;
 123     }
 124
 125     private String getUniqueRequestId(VesAlarm rootAlarm) {
 126         String alarmUniqueKey = "";
 127         if (rootAlarm.getAlarmIsCleared() == PolicyMassgeConstant.POLICY_MESSAGE_ABATED) {
 128             alarmUniqueKey =
 129                     rootAlarm.getSourceId() + ":" + rootAlarm.getEventName().replace("Cleared", "");
 130         } else {
 131             alarmUniqueKey = rootAlarm.getSourceId() + ":" + rootAlarm.getEventName();
 132         }
 133         if (uniqueRequestIdCache.containsKey(alarmUniqueKey)) {
 134             return uniqueRequestIdCache.get(alarmUniqueKey);
 135         } else {
 136             String requestID = UUID.randomUUID().toString();
 137             uniqueRequestIdCache.put(alarmUniqueKey, requestID);
 138             return requestID;
 139         }
 140     }
 141
 142     private void enrichVnfInfo(VmEntity vmEntity, VesAlarm childAlarm, PolicyMsg policyMsg) {
 143         String vnfId = "";
 144         String vnfName = "";
 145         if (null != childAlarm) {
 146             vnfId = childAlarm.getSourceId();
 147             vnfName = childAlarm.getSourceName();
 148         } else {
 149             Relationship relationship = vmEntity.getRelationshipList()
 150                     .getRelationship(PolicyMassgeConstant.GENERIC_VNF);
 151             if (null != relationship) {
 152                 vnfId = relationship.getRelationshipDataValue(PolicyMassgeConstant.GENERIC_VNF_VNF_ID);
 153                 vnfName = relationship.getRelatedToPropertyValue(PolicyMassgeConstant.GENERIC_VNF_VNF_NAME);
 154             }
 155         }
 156         VnfEntity vnfEntity = getVnfEntity(vnfId, vnfName);
 157         String vserverInstatnceId = getVserverInstanceId(vnfEntity);
 158         policyMsg.getAai().put("generic-vnf.vnf-id", vnfId);
 159         policyMsg.getAai().put("generic-vnf.service-instance-id", vserverInstatnceId);
 160     }
 161
 162
 163     private String getVserverInstanceId(VnfEntity vnfEntity) {
 164         String vserverInstanceId = "";
 165         if (vnfEntity != null) {
 166             Relationship relationship = vnfEntity.getRelationshipList()
 167                     .getRelationship(PolicyMassgeConstant.SERVICE_INSTANCE);
 168             if (relationship == null) {
 169                 return vserverInstanceId;
 170             }
 171             vserverInstanceId = relationship
 172                     .getRelationshipDataValue(PolicyMassgeConstant.SERVICE_INSTANCE_ID);
 173         }
 174         return vserverInstanceId;
 175     }
 176
 177     private VnfEntity getVnfEntity(String vnfId, String vnfName) {
 178         VnfEntity vnfEntity = null;
 179         try {
 180             vnfEntity = aaiQuery.getAaiVnfData(vnfId, vnfName);
 181         } catch (CorrelationException e) {
 182             log.error("Failed to get the VNF data.", e);
 183         }
 184         return vnfEntity;
 185     }
 186
 187     private VmEntity getVmEntity(String sourceId, String sourceName) {
 188         VmEntity vmEntity = null;
 189         try {
 190             vmEntity = aaiQuery.getAaiVmData(sourceId, sourceName);
 191         } catch (CorrelationException e) {
 192             log.error("Failed to get the VM data.", e);
 193         }
 194         return vmEntity;
 195     }
 196
 197     private void deleteRequestIdIfNecessary(PolicyMsg policyMsg){
 198         EVENT_STATUS status = policyMsg.getClosedLoopEventStatus();
 199         if(EVENT_STATUS.ABATED.equals(status)) {
 200             String requestId = policyMsg.getRequestID();
 201             for(Entry<String, String> kv: uniqueRequestIdCache.entrySet()) {
 202                 if(kv.getValue().equals(requestId)) {
 203                     uniqueRequestIdCache.remove(kv.getKey());
 204                     break;
 205                 }
 206             }
 207             log.info("An alarm is cleared and the corresponding requestId is deleted successfully");
 208         }
 209     }
 210 }