gerrit.onap Code Review - vfc/nfvo/catalog.git/blob

   1 /**
   2  * Copyright 2016 [ZTE] and others.
   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.openo.commontosca.catalog.model.wrapper;
  18
  19 import org.openo.commontosca.catalog.common.ToolUtil;
  20 import org.openo.commontosca.catalog.db.entity.NodeTemplateData;
  21 import org.openo.commontosca.catalog.db.entity.PackageData;
  22 import org.openo.commontosca.catalog.db.entity.ServiceTemplateData;
  23 import org.openo.commontosca.catalog.db.entity.ServiceTemplateMappingData;
  24 import org.openo.commontosca.catalog.db.exception.CatalogResourceException;
  25 import org.openo.commontosca.catalog.db.resource.TemplateManager;
  26 import org.openo.commontosca.catalog.model.common.TemplateDataHelper;
  27 import org.openo.commontosca.catalog.model.entity.InputParameter;
  28 import org.openo.commontosca.catalog.model.entity.NfvTemplate;
  29 import org.openo.commontosca.catalog.model.entity.NodeTemplate;
  30 import org.openo.commontosca.catalog.model.entity.Parameters;
  31 import org.openo.commontosca.catalog.model.entity.QueryRawDataCondition;
  32 import org.openo.commontosca.catalog.model.entity.ServiceTemplate;
  33 import org.openo.commontosca.catalog.model.entity.ServiceTemplateOperation;
  34 import org.openo.commontosca.catalog.model.entity.ServiceTemplateRawData;
  35 import org.openo.commontosca.catalog.model.entity.SubstitutionMapping;
  36 import org.openo.commontosca.catalog.resources.CatalogBadRequestException;
  37 import org.slf4j.Logger;
  38 import org.slf4j.LoggerFactory;
  39
  40 import java.util.ArrayList;
  41 import java.util.Arrays;
  42 import java.util.List;
  43
  44
  45 public class ServiceTemplateWrapper {
  46   private static ServiceTemplateWrapper instance;
  47   private static final Logger logger = LoggerFactory.getLogger(ServiceTemplateWrapper.class);
  48
  49   /**
  50    * get service template wrapper instance.
  51    * @return ServiceTemplateWrapper instance
  52    */
  53   public static ServiceTemplateWrapper getInstance() {
  54     if (instance == null) {
  55       instance = new ServiceTemplateWrapper();
  56     }
  57     return instance;
  58   }
  59
  60   /**
  61    * get service template by id.
  62    * @param serviceTemplateId service template id
  63    * @return service template
  64    * @throws CatalogResourceException e1
  65    */
  66   public ServiceTemplate getServiceTemplateById(String serviceTemplateId)
  67       throws CatalogResourceException {
  68     logger.info("getServiceTemplateById. serviceTemplateId = " + serviceTemplateId);
  69
  70     List<ServiceTemplateData> stdList =
  71         TemplateManager.getInstance().queryServiceTemplateById(serviceTemplateId);
  72     if (stdList == null || stdList.isEmpty()) {
  73       throw new CatalogResourceException("Can't find this servcie template");
  74     }
  75
  76     return TemplateDataHelper.convert2ServiceTemplate(stdList.get(0));
  77   }
  78
  79
  80   /**
  81    * get service templates.
  82    * @param status usage status
  83    * @param deletionPending package's deletionPending
  84    * @return service template list
  85    * @throws CatalogResourceException e
  86    */
  87   public ServiceTemplate[] getServiceTemplates(String status, boolean deletionPending)
  88       throws CatalogResourceException {
  89     PackageData pd = new PackageData();
  90     pd.setUsageState(status);
  91     pd.setDeletionPending(String.valueOf(deletionPending));
  92
  93     List<ServiceTemplateData> stdList =
  94         TemplateManager.getInstance().queryServiceTemplateByCsarPackageInfo(pd);
  95
  96     return TemplateDataHelper.convert2ServiceTemplates(stdList);
  97   }
  98
  99
 100   /**
 101    * get nesting service template.
 102    * @param nodeTypeIds nodeType id list
 103    * @return service template list
 104    * @throws CatalogResourceException e
 105    */
 106   public ServiceTemplate[] getNestingServiceTemplate(String[] nodeTypeIds)
 107       throws CatalogResourceException {
 108     ServiceTemplate[] sts = new ServiceTemplate[nodeTypeIds.length];
 109     for (int i = 0; i < nodeTypeIds.length; i++) {
 110       SubstitutionMapping stm = getSubstitutionMappingsByNodeTypeId(nodeTypeIds[i]);
 111       if (stm == null) {
 112         sts[i] = null;
 113       } else {
 114         sts[i] = getServiceTemplateById(stm.getServiceTemplateId());
 115       }
 116     }
 117
 118     return sts;
 119   }
 120
 121   /**
 122    * get substitution mappings by nodeTpe id.
 123    * @param nodeTypeId nodeType id
 124    * @return SubstitutionMapping
 125    * @throws CatalogResourceException e
 126    */
 127   private SubstitutionMapping getSubstitutionMappingsByNodeTypeId(String nodeTypeId)
 128       throws CatalogResourceException {
 129     List<ServiceTemplateMappingData> stmDataList =
 130         TemplateManager.getInstance().queryServiceTemplateMapping(nodeTypeId, null);
 131     if (stmDataList == null || stmDataList.isEmpty()) {
 132       return null;
 133     }
 134
 135     return TemplateDataHelper.convert2SubstitutionMapping(stmDataList.get(0));
 136   }
 137
 138
 139   /**
 140    * get service template raw data.
 141    * @param queryCondition query raw data condition
 142    * @return ServiceTemplateRawData
 143    * @throws CatalogResourceException e1
 144    * @throws CatalogBadRequestException e2
 145    */
 146   public ServiceTemplateRawData getServiceTemplateRawData(QueryRawDataCondition queryCondition)
 147       throws CatalogResourceException, CatalogBadRequestException {
 148     ServiceTemplateData std = getServiceTemplateDataByCsarId(queryCondition.getCsarId());
 149     return new ServiceTemplateRawData(std.getRowData());
 150   }
 151
 152   /**
 153    * get service template data by package id.
 154    * @param csarId package id
 155    * @return ServiceTemplateData
 156    * @throws CatalogBadRequestException e1
 157    * @throws CatalogResourceException e2
 158    */
 159   private ServiceTemplateData getServiceTemplateDataByCsarId(String csarId)
 160       throws CatalogBadRequestException, CatalogResourceException {
 161     if (ToolUtil.isTrimedEmptyString(csarId)) {
 162       throw new CatalogBadRequestException("CsarId is null.");
 163     }
 164     PackageData pd = new PackageData();
 165     pd.setCsarId(csarId);
 166
 167     List<ServiceTemplateData> stdList =
 168         TemplateManager.getInstance().queryServiceTemplateByCsarPackageInfo(pd);
 169
 170     if (stdList == null || stdList.isEmpty()) {
 171       throw new CatalogResourceException("Can't find this servcie template");
 172     }
 173
 174     return stdList.get(0);
 175   }
 176
 177   /**
 178    * get service template by package id.
 179    * @param packageId package id
 180    * @return service template data
 181    * @throws CatalogBadRequestException e1
 182    * @throws CatalogResourceException e2
 183    */
 184   public ServiceTemplate getServiceTemplateByCsarId(String packageId)
 185       throws CatalogBadRequestException, CatalogResourceException {
 186     ServiceTemplateData std = getServiceTemplateDataByCsarId(packageId);
 187     ServiceTemplate st = TemplateDataHelper.convert2ServiceTemplate(std);
 188     return st;
 189   }
 190
 191   /**
 192    * get service template parameters.
 193    * @param serviceTemplateId service template id
 194    * @return service template parameters
 195    * @throws CatalogResourceException e
 196    */
 197   public Parameters getServiceTemplateParameters(String serviceTemplateId)
 198       throws CatalogResourceException {
 199     ServiceTemplate st = getServiceTemplateById(serviceTemplateId);
 200     return new Parameters(st.getInputs(), st.getOutputs());
 201   }
 202
 203   /**
 204    * get template operation.
 205    * @param serviceTemplateId service template id
 206    * @return service template operations
 207    */
 208   public ServiceTemplateOperation[] getTemplateOperations(String serviceTemplateId)
 209       throws CatalogResourceException {
 210     ServiceTemplate st = getServiceTemplateById(serviceTemplateId);
 211
 212     if (st.getOperations() == null) {
 213       return new ServiceTemplateOperation[0];
 214     }
 215     return st.getOperations();
 216   }
 217
 218   /**
 219    * get parameters by operation name.
 220    * @param serviceTemplateId service template id
 221    * @param operationName operation name
 222    * @return InputParameter list
 223    * @throws CatalogResourceException e
 224    */
 225   public InputParameter[] getParametersByOperationName(String serviceTemplateId,
 226       String operationName) throws CatalogResourceException {
 227     if (ToolUtil.isTrimedEmptyString(operationName)) {
 228       throw new CatalogResourceException("Operation Name is null.");
 229     }
 230
 231     ServiceTemplateOperation[] operations = getTemplateOperations(serviceTemplateId);
 232     for (int i = 0; i < operations.length; i++) {
 233       if (operationName.equals(operations[i].getName())) {
 234         return operations[i].getInputs();
 235       }
 236     }
 237
 238     throw new CatalogResourceException("Can't find this operation.");
 239   }
 240
 241
 242   /**
 243    * get nodeTemplate by id.
 244    * @param serviceTemplateId service template id
 245    * @param nodeTemplateId node template id
 246    * @return NodeTemplate
 247    * @throws CatalogResourceException e1
 248    */
 249   public NodeTemplate getNodeTemplateById(String serviceTemplateId, String nodeTemplateId)
 250       throws CatalogResourceException {
 251     List<NodeTemplateData> ntdList =
 252         TemplateManager.getInstance().queryNodeTemplateById(serviceTemplateId, nodeTemplateId);
 253
 254     if (ntdList == null || ntdList.isEmpty()) {
 255       throw new CatalogResourceException("Can't find this node template.");
 256     }
 257
 258     return TemplateDataHelper.convert2NodeTemplate(ntdList.get(0));
 259   }
 260
 261   /**
 262    * get node templates.
 263    * @param serviceTemplateId service template id
 264    * @param types type list
 265    * @return NodeTemplate list
 266    * @throws CatalogResourceException e
 267    */
 268   public NodeTemplate[] getNodeTemplates(String serviceTemplateId, String[] types)
 269       throws CatalogResourceException {
 270     List<NodeTemplateData> ntdList =
 271         TemplateManager.getInstance().queryNodeTemplateBySeriviceTemplateId(serviceTemplateId);
 272     if (ntdList == null || ntdList.isEmpty()) {
 273       return new NodeTemplate[0];
 274     }
 275
 276     if (ToolUtil.isTrimedEmptyArray(types)) { // return all node templates
 277       return TemplateDataHelper.convert2NodeTemplates(ntdList);
 278     }
 279
 280     List<NodeTemplate> ntList = new ArrayList<>();
 281     for (String type : types) {
 282       if (!ToolUtil.isTrimedEmptyString(type)) {
 283         List<NodeTemplateData> typedNtdList = filterNodeTemplateDataListByType(ntdList, type);
 284         ntList.addAll(Arrays.asList(TemplateDataHelper.convert2NodeTemplates(typedNtdList)));
 285       }
 286     }
 287     return ntList.toArray(new NodeTemplate[0]);
 288   }
 289
 290   /**
 291    * filter node template data list by type.
 292    * @param ntdList nodeTemplate list
 293    * @param type node type
 294    * @return node template data list
 295    */
 296   private List<NodeTemplateData> filterNodeTemplateDataListByType(List<NodeTemplateData> ntdList,
 297       String type) {
 298     List<NodeTemplateData> retList = new ArrayList<>();
 299     for (NodeTemplateData ntd : ntdList) {
 300       if (type.equals(ntd.getType())) {
 301         retList.add(ntd);
 302       }
 303     }
 304     return retList;
 305   }
 306
 307
 308   /**
 309    * get nfv template.
 310    * @param serviceTemlateId service template id
 311    * @return NfvTemplate
 312    * @throws CatalogResourceException e
 313    */
 314   public NfvTemplate getNfvTemplate(String serviceTemlateId) throws CatalogResourceException {
 315     NodeTemplate[] nts = getNodeTemplates(serviceTemlateId, null);
 316
 317     List<NodeTemplate> vduNodes = new ArrayList<>();
 318     List<NodeTemplate> networkNodes = new ArrayList<>();
 319     List<NodeTemplate> vnfcNodes = new ArrayList<>();
 320     List<NodeTemplate> vnfNodes = new ArrayList<>();
 321     for (NodeTemplate nt : nts) {
 322       if (isVduNode(nt.getType())) {
 323         vduNodes.add(nt);
 324         continue;
 325       }
 326
 327       if (isNetworkNode(nt.getType())) {
 328         networkNodes.add(nt);
 329         continue;
 330       }
 331
 332       if (isVnfcNode(nt.getType())) {
 333         vnfcNodes.add(nt);
 334         continue;
 335       }
 336
 337       if (isVnfNode(nt.getType())) {
 338         vnfNodes.add(nt);
 339         continue;
 340       }
 341     }
 342
 343     return new NfvTemplate(vduNodes, networkNodes, vnfcNodes, vnfNodes);
 344   }
 345
 346   private boolean isVnfNode(String type) {
 347     return type.toUpperCase().indexOf(".VNF") > 0;
 348   }
 349
 350   private boolean isVnfcNode(String type) {
 351     return type.toUpperCase().indexOf(".VNFC") > 0;
 352   }
 353
 354   private boolean isNetworkNode(String type) {
 355     return type.toUpperCase().indexOf(".VL") > 0 || type.toUpperCase().indexOf(".VIRTUALLINK") > 0;
 356   }
 357
 358   private boolean isVduNode(String type) {
 359     return type.toUpperCase().indexOf(".VDU") > 0;
 360   }
 361
 362 }