openecomp-be/lib/openecomp-sdc-enrichment-lib/openecomp-sdc-enrichment-impl/src/main/java/org/openecomp/sdc/enrichment/impl/external/artifact/MonitoringMibEnricher.java

   1 /*
   2  * Copyright © 2018 European Support Limited
   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.openecomp.sdc.enrichment.impl.external.artifact;
  17
  18 import static org.openecomp.sdc.tosca.services.ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME;
  19 import static org.openecomp.sdc.tosca.services.ToscaConstants.SUBSTITUTE_SERVICE_TEMPLATE_PROPERTY_NAME;
  20
  21 import java.io.File;
  22 import java.io.IOException;
  23 import java.util.ArrayList;
  24 import java.util.Collection;
  25 import java.util.HashMap;
  26 import java.util.HashSet;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Objects;
  30 import java.util.Optional;
  31 import java.util.Set;
  32 import org.onap.sdc.tosca.datatypes.model.Directive;
  33 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  34 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  35 import org.openecomp.core.enrichment.types.ArtifactCategory;
  36 import org.openecomp.core.enrichment.types.ComponentMonitoringUploadInfo;
  37 import org.openecomp.core.enrichment.types.MonitoringArtifactInfo;
  38 import org.openecomp.core.enrichment.types.MonitoringUploadType;
  39 import org.openecomp.core.model.dao.EnrichedServiceModelDao;
  40 import org.openecomp.core.model.dao.EnrichedServiceModelDaoFactory;
  41 import org.openecomp.core.model.types.ServiceArtifact;
  42 import org.openecomp.core.utilities.file.FileContentHandler;
  43 import org.openecomp.core.utilities.file.FileUtils;
  44 import org.openecomp.sdc.common.errors.Messages;
  45 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  46 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  47 import org.openecomp.sdc.enrichment.EnrichmentInfo;
  48 import org.openecomp.sdc.enrichment.inter.ExternalArtifactEnricherInterface;
  49 import org.openecomp.sdc.logging.api.Logger;
  50 import org.openecomp.sdc.logging.api.LoggerFactory;
  51 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  52 import org.openecomp.sdc.tosca.services.DataModelUtil;
  53 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentArtifactDao;
  54 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
  55 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDaoFactory;
  56 import org.openecomp.sdc.vendorsoftwareproduct.dao.MonitoringUploadDaoFactory;
  57 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
  58 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentMonitoringUploadEntity;
  59 import org.openecomp.sdc.versioning.dao.types.Version;
  60
  61 public class MonitoringMibEnricher implements ExternalArtifactEnricherInterface {
  62
  63     private static final String COMPONENT_PREFIX = "org.openecomp.resource.vfc.";
  64     private final Logger log = LoggerFactory.getLogger(this.getClass().getName());
  65     private EnrichedServiceModelDao enrichedServiceModelDao;
  66     private ComponentDao componentDao;
  67     private ComponentArtifactDao componentArtifactDao;
  68
  69     /**
  70      * Enrich map.
  71      *
  72      * @param enrichmentInfo the enrichmentInfo
  73      * @return the map
  74      */
  75     @Override
  76     public Map<String, List<ErrorMessage>> enrich(EnrichmentInfo enrichmentInfo, ToscaServiceModel serviceModel) {
  77         Map<String, List<ErrorMessage>> errors = new HashMap<>();
  78         String vspId = enrichmentInfo.getKey();
  79         Version version = enrichmentInfo.getVersion();
  80         Collection<ComponentEntity> components = getComponentDao().list(new ComponentEntity(vspId, version, null));
  81         components.forEach(componentEntry -> errors.putAll(enrichComponent(vspId, version, componentEntry, serviceModel)));
  82         return errors;
  83     }
  84
  85     private Map<String, List<ErrorMessage>> enrichComponent(String vspId, Version version, ComponentEntity component,
  86                                                             ToscaServiceModel serviceModel) {
  87         Set<String> abstractNodeTypes = extractAbstractTypesFromSameTypeFromServiceModel(component, serviceModel);
  88         return enrichComponent(vspId, version, component, abstractNodeTypes);
  89     }
  90
  91     private Set<String> extractAbstractTypesFromSameTypeFromServiceModel(ComponentEntity component, ToscaServiceModel serviceModel) {
  92         Set<String> abstractNodeTypes = new HashSet<>();
  93         Map<String, ServiceTemplate> serviceTemplates = serviceModel.getServiceTemplates();
  94         String typeToCheck = getComponentVfcTypeToCheck(component.getComponentCompositionData().getName());
  95         for (ServiceTemplate serviceTemplate : serviceTemplates.values()) {
  96             collectAllAbstractNodeTypesPointingToType(typeToCheck, serviceTemplate, serviceTemplates, abstractNodeTypes);
  97         }
  98         return abstractNodeTypes;
  99     }
 100
 101     private String getComponentVfcTypeToCheck(String type) {
 102         return Objects.isNull(type) ? "" : type.replace(COMPONENT_PREFIX, COMPONENT_PREFIX + "compute.");
 103     }
 104
 105     private void collectAllAbstractNodeTypesPointingToType(String typeToCheck, ServiceTemplate serviceTemplate,
 106                                                            Map<String, ServiceTemplate> serviceTemplates, Set<String> abstractNodeTypes) {
 107         Map<String, NodeTemplate> nodeTemplates = DataModelUtil.getNodeTemplates(serviceTemplate);
 108         for (Map.Entry<String, NodeTemplate> nodeTemplateEntry : nodeTemplates.entrySet()) {
 109             handleNodeTemplate(nodeTemplateEntry.getValue(), typeToCheck, serviceTemplates, abstractNodeTypes);
 110         }
 111     }
 112
 113     private void handleNodeTemplate(NodeTemplate nodeTemplate, String typeToCheck, Map<String, ServiceTemplate> serviceTemplates,
 114                                     Set<String> abstractNodeTypes) {
 115         List<String> directives = DataModelUtil.getDirectives(nodeTemplate);
 116         if (directives.contains(Directive.SUBSTITUTABLE.getDisplayName())) {
 117             handleSubstitutionServiceTemplate(typeToCheck, nodeTemplate, serviceTemplates, abstractNodeTypes);
 118         }
 119     }
 120
 121     private void handleSubstitutionServiceTemplate(String typeToCheck, NodeTemplate nodeTemplate, Map<String, ServiceTemplate> serviceTemplates,
 122                                                    Set<String> abstractNodeTypes) {
 123         Object serviceTemplateFilter = DataModelUtil.getPropertyValue(nodeTemplate, SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
 124         if (Objects.nonNull(serviceTemplateFilter) && serviceTemplateFilter instanceof Map) {
 125             String substituteServiceTemplateName = (String) ((Map<String, Object>) serviceTemplateFilter)
 126                 .get(SUBSTITUTE_SERVICE_TEMPLATE_PROPERTY_NAME);
 127             ServiceTemplate substituteServiceTemplate = serviceTemplates.get(substituteServiceTemplateName);
 128             if (doesNodeTypeExistInSubServiceTemplate(typeToCheck, substituteServiceTemplate)) {
 129                 abstractNodeTypes.add(nodeTemplate.getType());
 130             }
 131         }
 132     }
 133
 134     private boolean doesNodeTypeExistInSubServiceTemplate(String nodeTypeId, ServiceTemplate substituteServiceTemplate) {
 135         return Objects.nonNull(DataModelUtil.getNodeType(substituteServiceTemplate, nodeTypeId));
 136     }
 137
 138     Map<String, List<ErrorMessage>> enrichComponent(String vspId, Version version, ComponentEntity componentEntry, Set<String> abstractNodeTypes) {
 139         Map<String, List<ErrorMessage>> errors = new HashMap<>();
 140         List<ComponentMonitoringUploadInfo> componentMonitoringUploadInfoList = extractComponentMibInfo(vspId, version, componentEntry,
 141             abstractNodeTypes);
 142         componentMonitoringUploadInfoList.forEach(componentUploadInfo -> enrichComponentMib(vspId, version, componentUploadInfo, errors));
 143         return errors;
 144     }
 145
 146     private List<ComponentMonitoringUploadInfo> extractComponentMibInfo(String vspId, Version version, ComponentEntity componentEntity,
 147                                                                         Set<String> abstractNodeTypes) {
 148         String componentId = componentEntity.getId();
 149         ComponentMonitoringUploadEntity entity = new ComponentMonitoringUploadEntity();
 150         entity.setVspId(vspId);
 151         entity.setVersion(version);
 152         entity.setComponentId(componentId);
 153         List<ComponentMonitoringUploadInfo> componentMonitoringUploadInfoList = new ArrayList<>();
 154         abstractNodeTypes
 155             .forEach(unifiedComponentNodeType -> componentMonitoringUploadInfoList.add(updComponentMibInfoByType(unifiedComponentNodeType, entity)));
 156         return componentMonitoringUploadInfoList;
 157     }
 158
 159     private ComponentMonitoringUploadInfo updComponentMibInfoByType(String componentName,
 160                                                                     ComponentMonitoringUploadEntity componentMonitoringUploadEntity) {
 161         ComponentMonitoringUploadInfo componentMonitoringUploadInfo = new ComponentMonitoringUploadInfo();
 162         for (MonitoringUploadType type : MonitoringUploadType.values()) {
 163             componentMonitoringUploadEntity.setType(type);
 164             Optional<ComponentMonitoringUploadEntity> artifact = getComponentArtifactDao().getByType(componentMonitoringUploadEntity);
 165             if (!artifact.isPresent()) {
 166                 continue;
 167             }
 168             ComponentMonitoringUploadEntity mibArtifact = artifact.get();
 169             updateComponentMonitoringUploadInfoWithMib(getArtifactPath(type, componentName), type, mibArtifact, componentMonitoringUploadInfo);
 170         }
 171         return componentMonitoringUploadInfo;
 172     }
 173
 174     private String getArtifactPath(MonitoringUploadType type, String unifiedComponentNodeType) {
 175         return unifiedComponentNodeType + File.separator + ArtifactCategory.DEPLOYMENT.getDisplayName() + File.separator + type.name();
 176     }
 177
 178     private void updateComponentMonitoringUploadInfoWithMib(String path, MonitoringUploadType type, ComponentMonitoringUploadEntity mibArtifact,
 179                                                             ComponentMonitoringUploadInfo componentMonitoringUploadInfo) {
 180         MonitoringArtifactInfo monitoringArtifactInfo = new MonitoringArtifactInfo();
 181         monitoringArtifactInfo.setName(path);
 182         monitoringArtifactInfo.setContent(mibArtifact.getArtifact().array());
 183         componentMonitoringUploadInfo.setMonitoringArtifactFile(type, monitoringArtifactInfo);
 184     }
 185
 186     private void enrichComponentMib(String vspId, Version version, ComponentMonitoringUploadInfo componentUploadInfo,
 187                                     Map<String, List<ErrorMessage>> errors) {
 188         ServiceArtifact mibServiceArtifact = new ServiceArtifact();
 189         mibServiceArtifact.setVspId(vspId);
 190         mibServiceArtifact.setVersion(version);
 191         enrichMibFiles(mibServiceArtifact, componentUploadInfo, errors);
 192     }
 193
 194     private void enrichMibFiles(ServiceArtifact monitoringArtifact, ComponentMonitoringUploadInfo componentMonitoringUploadInfo,
 195                                 Map<String, List<ErrorMessage>> errors) {
 196         if (componentMonitoringUploadInfo == null) {
 197             return;
 198         }
 199         enrichMibByType(componentMonitoringUploadInfo.getSnmpTrap(), MonitoringUploadType.SNMP_TRAP, monitoringArtifact, errors);
 200         enrichMibByType(componentMonitoringUploadInfo.getSnmpPoll(), MonitoringUploadType.SNMP_POLL, monitoringArtifact, errors);
 201         enrichMibByType(componentMonitoringUploadInfo.getVesEvent(), MonitoringUploadType.VES_EVENTS, monitoringArtifact, errors);
 202     }
 203
 204     private void enrichMibByType(MonitoringArtifactInfo monitoringArtifactInfo, MonitoringUploadType type, ServiceArtifact mibServiceArtifact,
 205                                  Map<String, List<ErrorMessage>> errors) {
 206         if (monitoringArtifactInfo == null) {
 207             return;
 208         }
 209         FileContentHandler mibs;
 210         try {
 211             mibs = FileUtils.getFileContentMapFromZip(monitoringArtifactInfo.getContent());
 212         } catch (final IOException ex) {
 213             log.error("Failed to get file content map from zip ", ex);
 214             ErrorMessage.ErrorMessageUtil.addMessage(mibServiceArtifact.getName() + "." + type.name(), errors)
 215                 .add(new ErrorMessage(ErrorLevel.ERROR, Messages.INVALID_ZIP_FILE.getErrorMessage()));
 216             return;
 217         }
 218         Set<String> fileList = mibs.getFileList();
 219         for (String fileName : fileList) {
 220             mibServiceArtifact.setContentData(mibs.getFileContent(fileName));
 221             mibServiceArtifact.setName(monitoringArtifactInfo.getName() + File.separator + fileName);
 222             getEnrichedServiceModelDao().storeExternalArtifact(mibServiceArtifact);
 223         }
 224     }
 225
 226     private EnrichedServiceModelDao getEnrichedServiceModelDao() {
 227         if (enrichedServiceModelDao == null) {
 228             enrichedServiceModelDao = EnrichedServiceModelDaoFactory.getInstance().createInterface();
 229         }
 230         return enrichedServiceModelDao;
 231     }
 232
 233     private ComponentDao getComponentDao() {
 234         if (componentDao == null) {
 235             componentDao = ComponentDaoFactory.getInstance().createInterface();
 236         }
 237         return componentDao;
 238     }
 239
 240     private ComponentArtifactDao getComponentArtifactDao() {
 241         if (componentArtifactDao == null) {
 242             componentArtifactDao = MonitoringUploadDaoFactory.getInstance().createInterface();
 243         }
 244         return componentArtifactDao;
 245     }
 246 }