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

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