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