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