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