gerrit.onap Code Review - sdc.git/blob

   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
  17 package org.openecomp.sdc.model.impl;
  18
  19 import java.io.InputStream;
  20 import java.util.ArrayList;
  21 import java.util.Collection;
  22 import java.util.Collections;
  23 import java.util.HashMap;
  24 import java.util.List;
  25 import java.util.Map;
  26 import java.util.stream.Collectors;
  27 import org.onap.sdc.tosca.datatypes.model.Import;
  28
  29 import org.onap.sdc.tosca.services.ToscaExtensionYamlUtil;
  30 import org.openecomp.core.model.dao.ServiceArtifactDaoInter;
  31 import org.openecomp.core.model.dao.ServiceTemplateDaoInter;
  32 import org.openecomp.core.model.types.ServiceArtifact;
  33 import org.openecomp.core.model.types.ServiceElement;
  34 import org.openecomp.core.model.types.ServiceTemplate;
  35 import org.openecomp.core.utilities.file.FileContentHandler;
  36 import org.openecomp.core.utilities.file.FileUtils;
  37 import org.openecomp.sdc.logging.api.Logger;
  38 import org.openecomp.sdc.logging.api.LoggerFactory;
  39 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  40 import org.openecomp.sdc.tosca.datatypes.model.Old1610ServiceTemplate;
  41 import org.openecomp.sdc.versioning.dao.VersionableDao;
  42 import org.openecomp.sdc.versioning.dao.types.Version;
  43
  44 public class AbstractServiceModelDao implements VersionableDao {
  45
  46   protected ServiceTemplateDaoInter templateDao;
  47   protected ServiceArtifactDaoInter artifactDao;
  48
  49   private final Logger log = LoggerFactory.getLogger(this.getClass());
  50
  51   @Override
  52   public void registerVersioning(String versionableEntityType) {
  53     templateDao.registerVersioning(versionableEntityType);
  54     artifactDao.registerVersioning(versionableEntityType);
  55   }
  56
  57   /**
  58    * Gets service model.
  59    *
  60    * @param vspId   the vsp id
  61    * @param version the version
  62    * @return the service model
  63    */
  64   public ToscaServiceModel getServiceModel(String vspId, Version version) {
  65     if (vspId == null || version == null) {
  66       throw new RuntimeException("missing service model key");
  67     }
  68
  69     FileContentHandler artifactFiles = getArtifacts(vspId, version);
  70
  71     Map<String, org.onap.sdc.tosca.datatypes.model.ServiceTemplate> serviceTemplates =
  72         getTemplates(vspId,
  73             version);
  74     String entryDefinitionServiceTemplate = getServiceBase(vspId, version);
  75     return new ToscaServiceModel(artifactFiles, serviceTemplates, entryDefinitionServiceTemplate);
  76   }
  77
  78   public void storeExternalArtifact(ServiceArtifact serviceArtifact) {
  79     artifactDao.create(serviceArtifact);
  80   }
  81
  82
  83   /**
  84    * Store service model.
  85    *
  86    * @param vspId             the vsp id
  87    * @param version           the version
  88    * @param toscaServiceModel the tosca service model
  89    */
  90   public void storeServiceModel(String vspId, Version version,
  91                                 ToscaServiceModel toscaServiceModel) {
  92     ServiceArtifact entityArt;
  93
  94     for (String fileName : toscaServiceModel.getArtifactFiles().getFileList()) {
  95       entityArt = new ServiceArtifact();
  96       entityArt.setContentData(
  97           FileUtils.toByteArray(toscaServiceModel.getArtifactFiles().getFileContent(fileName)));
  98       entityArt.setVspId(vspId);
  99       entityArt.setVersion(version);
 100       entityArt.setName(fileName);
 101
 102       artifactDao.create(entityArt);
 103     }
 104
 105     ServiceTemplate entityTmp;
 106     String yaml;
 107     for (Map.Entry<String, org.onap.sdc.tosca.datatypes.model.ServiceTemplate>
 108         entryTemplate : toscaServiceModel.getServiceTemplates().entrySet()) {
 109       entityTmp = new ServiceTemplate();
 110
 111       yaml = new ToscaExtensionYamlUtil().objectToYaml(entryTemplate.getValue());
 112       entityTmp.setContentData(yaml.getBytes());
 113       entityTmp.setVspId(vspId);
 114       entityTmp.setVersion(version);
 115       entityTmp.setName(entryTemplate.getKey());
 116       entityTmp.setBaseName(toscaServiceModel.getEntryDefinitionServiceTemplate());
 117
 118       templateDao.create(entityTmp);
 119     }
 120   }
 121
 122
 123   /**
 124    * Gets service model info.
 125    *
 126    * @param vspId   the vsp id
 127    * @param version the version
 128    * @param name    the name
 129    * @return the service model info
 130    */
 131   public ServiceElement getServiceModelInfo(String vspId, Version version, String name) {
 132     ServiceElement element = templateDao.getTemplateInfo(vspId, version, name);
 133     if (element != null) {
 134       return element;
 135     }
 136
 137     element = artifactDao.getArtifactInfo(vspId, version, name);
 138     if (element != null) {
 139       return element;
 140     }
 141     return null;
 142   }
 143
 144   private String getServiceBase(String vspId, Version version) {
 145     return templateDao.getBase(vspId, version);
 146   }
 147
 148   private Map<String, org.onap.sdc.tosca.datatypes.model.ServiceTemplate> getTemplates(
 149       String vspId,
 150       Version version) {
 151
 152     Collection<ServiceTemplate> templates = templateDao.list(vspId, version);
 153     if (templates == null) {
 154       return null;
 155     }
 156     return templates.stream().collect(Collectors.toMap(template -> template.getName(),
 157         template -> getServiceTemplate(template.getContent())));
 158   }
 159
 160   private org.onap.sdc.tosca.datatypes.model.ServiceTemplate getServiceTemplate(
 161       InputStream content) {
 162     String serviceTemplateContent = new String(FileUtils.toByteArray(content));
 163
 164     try{
 165       return new ToscaExtensionYamlUtil().yamlToObject(serviceTemplateContent,
 166           org.onap.sdc.tosca.datatypes.model.ServiceTemplate.class);
 167     }catch (Exception e){
 168       log.warn("Found vsp with old-versioned tosca service template", e);
 169       Old1610ServiceTemplate old1610ServiceTemplate =
 170           new ToscaExtensionYamlUtil().yamlToObject(serviceTemplateContent,
 171               Old1610ServiceTemplate.class);
 172
 173       return mapOldSTToCurrentST(old1610ServiceTemplate);
 174     }
 175   }
 176
 177   private static org.onap.sdc.tosca.datatypes.model.ServiceTemplate mapOldSTToCurrentST(Old1610ServiceTemplate oldServiceTemplate){
 178     org.onap.sdc.tosca.datatypes.model.ServiceTemplate
 179         serviceTemplate = new org.onap.sdc.tosca.datatypes.model.ServiceTemplate();
 180
 181     serviceTemplate.setArtifact_types(oldServiceTemplate.getArtifact_types());
 182     serviceTemplate.setCapability_types(oldServiceTemplate.getCapability_types());
 183     serviceTemplate.setData_types(oldServiceTemplate.getData_types());
 184     serviceTemplate.setDescription(oldServiceTemplate.getDescription());
 185     serviceTemplate.setGroup_types(oldServiceTemplate.getGroup_types());
 186     serviceTemplate.setInterface_types(oldServiceTemplate.getInterface_types());
 187     serviceTemplate.setMetadata(oldServiceTemplate.getMetadata());
 188     serviceTemplate.setNode_types(oldServiceTemplate.getNode_types());
 189     serviceTemplate.setPolicy_types(oldServiceTemplate.getPolicy_types());
 190     serviceTemplate.setRelationship_types(oldServiceTemplate.getRelationship_types());
 191     serviceTemplate.setTopology_template(oldServiceTemplate.getTopology_template());
 192
 193     List<Map<String, Import>> imports = new ArrayList<>();
 194     for(Map.Entry<String, Import> importEntry : oldServiceTemplate.getImports().entrySet()){
 195       Map<String, Import> importMap = new HashMap<>();
 196       importMap.put(importEntry.getKey(), importEntry.getValue());
 197       imports.add(importMap);
 198     }
 199     serviceTemplate.setImports(imports);
 200
 201     return serviceTemplate;
 202
 203   }
 204
 205   private FileContentHandler getArtifacts(String vspId, Version version) {
 206     Collection<ServiceArtifact> templates = artifactDao.list(vspId, version);
 207     if (templates == null) {
 208       return null;
 209     }
 210
 211     FileContentHandler fileContentHandler = new FileContentHandler();
 212     templates.stream().forEach(
 213         serviceArtifact -> fileContentHandler
 214             .addFile(serviceArtifact.getName(), serviceArtifact.getContent()));
 215
 216     return fileContentHandler;
 217   }
 218 }