models-tosca/src/main/java/org/onap/policy/models/tosca/authorative/provider/AuthorativeToscaProvider.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019-2023 Nordix Foundation.
   4  *  Modifications Copyright (C) 2019, 2021 AT&T Intellectual Property. All rights reserved.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.models.tosca.authorative.provider;
  23
  24 import jakarta.ws.rs.core.Response;
  25 import jakarta.ws.rs.core.Response.Status;
  26 import java.util.ArrayList;
  27 import java.util.Collections;
  28 import java.util.List;
  29 import java.util.Map;
  30 import lombok.NonNull;
  31 import org.apache.commons.collections4.CollectionUtils;
  32 import org.onap.policy.models.base.PfConceptKey;
  33 import org.onap.policy.models.base.PfModelException;
  34 import org.onap.policy.models.base.PfModelRuntimeException;
  35 import org.onap.policy.models.dao.PfDao;
  36 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntity;
  37 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityFilter;
  38 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntityKey;
  39 import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
  40 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  41 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
  42 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  43 import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
  44 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
  45 import org.onap.policy.models.tosca.simple.provider.SimpleToscaProvider;
  46 import org.onap.policy.models.tosca.utils.ToscaServiceTemplateUtils;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 /**
  51  * This class provides the provision of information on TOSCA concepts in the database to callers.
  52  *
  53  * @author Liam Fallon (liam.fallon@est.tech)
  54  */
  55 public class AuthorativeToscaProvider {
  56     private static final Logger LOGGER = LoggerFactory.getLogger(AuthorativeToscaProvider.class);
  57
  58     // TODO: In next release this locking mechanism should be removed and replaced with proper session handling
  59     private static final Object providerLockObject = "providerLockObject";
  60
  61     /**
  62      * Get service templates.
  63      *
  64      * @param dao the DAO to use to access the database
  65      * @param name the name of the service template to get.
  66      * @param version the version of the service template to get.
  67      * @return the service templates found
  68      * @throws PfModelException on errors getting service templates
  69      */
  70     public List<ToscaServiceTemplate> getServiceTemplateList(PfDao dao, String name, String version)
  71             throws PfModelException {
  72
  73         synchronized (providerLockObject) {
  74             LOGGER.debug("->getServiceTemplateList: name={}, version={}", name, version);
  75
  76             List<ToscaServiceTemplate> serviceTemplateList = new ArrayList<>();
  77
  78             try {
  79                 ToscaServiceTemplate serviceTemplate =
  80                         new SimpleToscaProvider().getServiceTemplate(dao).toAuthorative();
  81                 serviceTemplateList.add(serviceTemplate);
  82             } catch (PfModelRuntimeException pfme) {
  83                 return handlePfModelRuntimeException(pfme);
  84             }
  85
  86             LOGGER.debug("<-getServiceTemplateList: name={}, version={}, serviceTemplateList={}", name, version,
  87                     serviceTemplateList);
  88             return serviceTemplateList;
  89         }
  90     }
  91
  92     /**
  93      * Get filtered service templates.
  94      *
  95      * @param pfDao the DAO to use to access the database
  96      * @param filter the filter for the service templates to get
  97      * @return the service templates found
  98      * @throws PfModelException on errors getting service templates
  99      */
 100     public List<ToscaServiceTemplate> getFilteredServiceTemplateList(PfDao pfDao,
 101             @NonNull ToscaEntityFilter<ToscaServiceTemplate> filter) throws PfModelException {
 102
 103         LOGGER.debug("->getFilteredServiceTemplateList: filter={}", filter);
 104
 105         List<ToscaServiceTemplate> filteredServiceTemplateList =
 106                 filter.filter(getServiceTemplateList(pfDao, null, null));
 107
 108         LOGGER.debug("<-getFilteredServiceTemplateList: filter={}, filteredServiceTemplateList={}", filter,
 109                 filteredServiceTemplateList);
 110
 111         return filteredServiceTemplateList;
 112     }
 113
 114     /**
 115      * Create a service template.
 116      *
 117      * @param dao the DAO to use to access the database
 118      * @param serviceTemplate the service template to be created.
 119      * @return the TOSCA service template that was created
 120      * @throws PfModelException on errors creating the service template
 121      */
 122     public ToscaServiceTemplate createServiceTemplate(@NonNull final PfDao dao,
 123             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 124
 125         synchronized (providerLockObject) {
 126             LOGGER.debug("->createServiceTemplate: serviceTemplate={}", serviceTemplate);
 127
 128             ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
 129                     .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 130
 131             LOGGER.debug("<-createServiceTemplate: createdServiceTemplate={}", createdServiceTemplate);
 132             return createdServiceTemplate;
 133         }
 134     }
 135
 136     /**
 137      * Update a service template.
 138      *
 139      * @param dao the DAO to use to access the database
 140      * @param serviceTemplate the service template to be updated.
 141      * @return the TOSCA service template that was updated
 142      * @throws PfModelException on errors updating the service template
 143      */
 144     public ToscaServiceTemplate updateServiceTemplate(@NonNull final PfDao dao,
 145             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 146
 147         synchronized (providerLockObject) {
 148             LOGGER.debug("->updateServiceTemplate: serviceTemplate={}", serviceTemplate);
 149
 150             ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
 151                     .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 152
 153             LOGGER.debug("<-updateServiceTemplate: updatedServiceTemplate={}", updatedServiceTemplate);
 154             return updatedServiceTemplate;
 155         }
 156     }
 157
 158     /**
 159      * Delete a service template.
 160      *
 161      * @param dao the DAO to use to access the database
 162      * @param name the name of the service template to delete.
 163      * @param version the version of the service template to delete.
 164      * @return the TOSCA service template that was deleted
 165      * @throws PfModelException on errors deleting the control loop
 166      */
 167     public ToscaServiceTemplate deleteServiceTemplate(@NonNull final PfDao dao, @NonNull final String name,
 168             @NonNull final String version) throws PfModelException {
 169
 170         synchronized (providerLockObject) {
 171             LOGGER.debug("->deleteServiceTemplate: name={}, version={}", name, version);
 172
 173             ToscaServiceTemplate deletedServiceTemplate =
 174                     new SimpleToscaProvider().deleteServiceTemplate(dao).toAuthorative();
 175
 176             LOGGER.debug("<-deleteServiceTemplate: name={}, version={}, deletedServiceTemplate={}", name, version,
 177                     deletedServiceTemplate);
 178             return deletedServiceTemplate;
 179         }
 180     }
 181
 182     /**
 183      * Get policy types.
 184      *
 185      * @param dao the DAO to use to access the database
 186      * @param name the name of the policy type to get.
 187      * @param version the version of the policy type to get.
 188      * @return the policy types found
 189      * @throws PfModelException on errors getting policy types
 190      */
 191     public ToscaServiceTemplate getPolicyTypes(@NonNull final PfDao dao, final String name, final String version)
 192             throws PfModelException {
 193
 194         synchronized (providerLockObject) {
 195             LOGGER.debug("->getPolicyTypes: name={}, version={}", name, version);
 196
 197             JpaToscaServiceTemplate jpaServiceTemplate = new SimpleToscaProvider().getPolicyTypes(dao, name, version);
 198
 199             ToscaServiceTemplate serviceTemplate = jpaServiceTemplate.toAuthorative();
 200
 201             LOGGER.debug("<-getPolicyTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
 202             return serviceTemplate;
 203         }
 204     }
 205
 206     /**
 207      * Get policy types.
 208      *
 209      * @param dao the DAO to use to access the database
 210      * @param name the name of the policy type to get, set to null to get all policy types
 211      * @param version the version of the policy type to get, set to null to get all versions
 212      * @return the policy types found
 213      * @throws PfModelException on errors getting policy types
 214      */
 215     public List<ToscaPolicyType> getPolicyTypeList(@NonNull final PfDao dao, final String name, final String version)
 216             throws PfModelException {
 217
 218         synchronized (providerLockObject) {
 219             LOGGER.debug("->getPolicyTypeList: name={}, version={}", name, version);
 220
 221             List<ToscaPolicyType> policyTypeList;
 222
 223             try {
 224                 policyTypeList = new ArrayList<>(new SimpleToscaProvider().getPolicyTypes(dao, name, version)
 225                         .toAuthorative().getPolicyTypes().values());
 226             } catch (PfModelRuntimeException pfme) {
 227                 return handlePfModelRuntimeException(pfme);
 228             }
 229
 230             LOGGER.debug("<-getPolicyTypeList: name={}, version={}, policyTypeList={}", name, version, policyTypeList);
 231             return policyTypeList;
 232         }
 233     }
 234
 235     /**
 236      * Get filtered policy types.
 237      *
 238      * @param dao the DAO to use to access the database
 239      * @param filter the filter for the policy types to get
 240      * @return the policy types found
 241      * @throws PfModelException on errors getting policy types
 242      */
 243     public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull final PfDao dao,
 244             @NonNull final ToscaEntityFilter<ToscaPolicyType> filter) throws PfModelException {
 245
 246         synchronized (providerLockObject) {
 247             LOGGER.debug("->getFilteredPolicyTypes: filter={}", filter);
 248             var simpleToscaProvider = new SimpleToscaProvider();
 249
 250             final JpaToscaServiceTemplate dbServiceTemplate = simpleToscaProvider.getPolicyTypes(dao, null, null);
 251
 252             List<ToscaPolicyType> filteredPolicyTypes = dbServiceTemplate.getPolicyTypes().toAuthorativeList();
 253             filteredPolicyTypes = filter.filter(filteredPolicyTypes);
 254
 255             if (CollectionUtils.isEmpty(filteredPolicyTypes)) {
 256                 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
 257                         "policy types for filter " + filter.toString() + " do not exist");
 258             }
 259
 260             var filteredServiceTemplate = new JpaToscaServiceTemplate();
 261
 262             for (ToscaPolicyType policyType : filteredPolicyTypes) {
 263                 JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
 264                         .getCascadedPolicyTypes(dbServiceTemplate, policyType.getName(), policyType.getVersion());
 265
 266                 filteredServiceTemplate =
 267                         ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
 268             }
 269
 270             ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
 271
 272             LOGGER.debug("<-getFilteredPolicyTypes: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
 273             return returnServiceTemplate;
 274         }
 275     }
 276
 277     /**
 278      * Get filtered policy types.
 279      *
 280      * @param dao the DAO to use to access the database
 281      * @param filter the filter for the policy types to get
 282      * @return the policy types found
 283      * @throws PfModelException on errors getting policy types
 284      */
 285     public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull final PfDao dao,
 286             @NonNull final ToscaEntityFilter<ToscaPolicyType> filter) throws PfModelException {
 287
 288         LOGGER.debug("->getFilteredPolicyTypeList: filter={}", filter);
 289
 290         List<ToscaPolicyType> filteredPolicyTypeList = filter.filter(getPolicyTypeList(dao, null, null));
 291
 292         LOGGER.debug("<-getFilteredPolicyTypeList: filter={}, filteredPolicyTypeList={}", filter,
 293                 filteredPolicyTypeList);
 294
 295         return filteredPolicyTypeList;
 296     }
 297
 298     /**
 299      * Create policy types.
 300      *
 301      * @param dao the DAO to use to access the database
 302      * @param serviceTemplate the service template containing the definition of the policy types to be created
 303      * @return the TOSCA service template containing the created policy types
 304      * @throws PfModelException on errors creating policy types
 305      */
 306     public ToscaServiceTemplate createPolicyTypes(@NonNull final PfDao dao,
 307             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 308
 309         synchronized (providerLockObject) {
 310             LOGGER.debug("->createPolicyTypes: serviceTemplate={}", serviceTemplate);
 311
 312             ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
 313                     .createPolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 314
 315             LOGGER.debug("<-createPolicyTypes: createdServiceTemplate={}", createdServiceTemplate);
 316             return createdServiceTemplate;
 317         }
 318     }
 319
 320     /**
 321      * Update policy types.
 322      *
 323      * @param dao the DAO to use to access the database
 324      * @param serviceTemplate the service template containing the definition of the policy types to be modified
 325      * @return the TOSCA service template containing the modified policy types
 326      * @throws PfModelException on errors updating policy types
 327      */
 328     public ToscaServiceTemplate updatePolicyTypes(@NonNull final PfDao dao,
 329             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 330
 331         synchronized (providerLockObject) {
 332             LOGGER.debug("->updatePolicyTypes: serviceTemplate={}", serviceTemplate);
 333
 334             ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
 335                     .updatePolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 336
 337             LOGGER.debug("<-updatePolicyTypes: updatedServiceTemplate={}", updatedServiceTemplate);
 338             return updatedServiceTemplate;
 339         }
 340     }
 341
 342     /**
 343      * Delete policy type.
 344      *
 345      * @param dao the DAO to use to access the database
 346      * @param name the name of the policy type to delete.
 347      * @param version the version of the policy type to delete.
 348      * @return the TOSCA service template containing the policy type that was deleted
 349      * @throws PfModelException on errors deleting policy types
 350      */
 351     public ToscaServiceTemplate deletePolicyType(@NonNull final PfDao dao, @NonNull final String name,
 352             @NonNull final String version) throws PfModelException {
 353
 354         synchronized (providerLockObject) {
 355             LOGGER.debug("->deletePolicyType: name={}, version={}", name, version);
 356
 357             ToscaServiceTemplate deletedServiceTemplate =
 358                     new SimpleToscaProvider().deletePolicyType(dao, new PfConceptKey(name, version)).toAuthorative();
 359
 360             LOGGER.debug("<-deletePolicyType: name={}, version={}, deletedServiceTemplate={}", name, version,
 361                     deletedServiceTemplate);
 362             return deletedServiceTemplate;
 363         }
 364     }
 365
 366     /**
 367      * Get policies.
 368      *
 369      * @param dao the DAO to use to access the database
 370      * @param name the name of the policy to get.
 371      * @param version the version of the policy to get.
 372      * @return the policies found
 373      * @throws PfModelException on errors getting policies
 374      */
 375     public ToscaServiceTemplate getPolicies(@NonNull final PfDao dao, final String name, final String version)
 376             throws PfModelException {
 377
 378         synchronized (providerLockObject) {
 379             LOGGER.debug("->getPolicies: name={}, version={}", name, version);
 380
 381             ToscaServiceTemplate gotServiceTemplate =
 382                     new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative();
 383
 384             LOGGER.debug("<-getPolicies: name={}, version={}, gotServiceTemplate={}", name, version,
 385                     gotServiceTemplate);
 386             return gotServiceTemplate;
 387         }
 388     }
 389
 390     /**
 391      * Get policies.
 392      *
 393      * @param dao the DAO to use to access the database
 394      * @param name the name of the policy to get, null to get all policies
 395      * @param version the version of the policy to get, null to get all versions of a policy
 396      * @return the policies found
 397      * @throws PfModelException on errors getting policies
 398      */
 399     public List<ToscaPolicy> getPolicyList(@NonNull final PfDao dao, final String name, final String version)
 400             throws PfModelException {
 401
 402         synchronized (providerLockObject) {
 403             LOGGER.debug("->getPolicyList: name={}, version={}", name, version);
 404
 405             List<ToscaPolicy> policyList;
 406
 407             try {
 408                 policyList = asConceptList(new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative()
 409                         .getToscaTopologyTemplate().getPolicies());
 410             } catch (PfModelRuntimeException pfme) {
 411                 return handlePfModelRuntimeException(pfme);
 412             }
 413
 414             LOGGER.debug("<-getPolicyList: name={}, version={}, policyList={}", name, version, policyList);
 415             return policyList;
 416         }
 417     }
 418
 419     /**
 420      * Get filtered policies.
 421      *
 422      * @param dao the DAO to use to access the database
 423      * @param filter the filter for the policies to get
 424      * @return the policies found
 425      * @throws PfModelException on errors getting policies
 426      */
 427     public ToscaServiceTemplate getFilteredPolicies(@NonNull final PfDao dao,
 428             @NonNull final ToscaTypedEntityFilter<ToscaPolicy> filter) throws PfModelException {
 429
 430         synchronized (providerLockObject) {
 431             LOGGER.debug("->getFilteredPolicies: filter={}", filter);
 432             String version =
 433                     ToscaTypedEntityFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
 434
 435             var simpleToscaProvider = new SimpleToscaProvider();
 436             final JpaToscaServiceTemplate dbServiceTemplate =
 437                     simpleToscaProvider.getPolicies(dao, filter.getName(), version);
 438
 439             List<ToscaPolicy> filteredPolicies =
 440                     dbServiceTemplate.getTopologyTemplate().getPolicies().toAuthorativeList();
 441             filteredPolicies = filter.filter(filteredPolicies);
 442
 443             if (CollectionUtils.isEmpty(filteredPolicies)) {
 444                 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
 445                         "policies for filter " + filter.toString() + " do not exist");
 446             }
 447
 448             var filteredServiceTemplate = new JpaToscaServiceTemplate();
 449
 450             for (ToscaPolicy policy : filteredPolicies) {
 451                 JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
 452                         .getCascadedPolicies(dbServiceTemplate, policy.getName(), policy.getVersion());
 453
 454                 filteredServiceTemplate =
 455                         ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
 456             }
 457
 458             ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
 459
 460             LOGGER.debug("<-getFilteredPolicies: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
 461             return returnServiceTemplate;
 462         }
 463     }
 464
 465     /**
 466      * Get filtered policies.
 467      *
 468      * @param dao the DAO to use to access the database
 469      * @param filter the filter for the policies to get
 470      * @return the policies found
 471      * @throws PfModelException on errors getting policies
 472      */
 473     public List<ToscaPolicy> getFilteredPolicyList(@NonNull final PfDao dao,
 474             @NonNull final ToscaTypedEntityFilter<ToscaPolicy> filter) throws PfModelException {
 475
 476         LOGGER.debug("->getFilteredPolicyList: filter={}", filter);
 477         String version = ToscaTypedEntityFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
 478
 479         List<ToscaPolicy> policyList = filter.filter(getPolicyList(dao, filter.getName(), version));
 480
 481         LOGGER.debug("<-getFilteredPolicyList: filter={}, policyList={}", filter, policyList);
 482         return policyList;
 483     }
 484
 485     /**
 486      * Create policies.
 487      *
 488      * @param dao the DAO to use to access the database
 489      * @param serviceTemplate the service template containing the definitions of the new policies to be created.
 490      * @return the TOSCA service template containing the policy types that were created
 491      * @throws PfModelException on errors creating policies
 492      */
 493     public ToscaServiceTemplate createPolicies(@NonNull final PfDao dao,
 494             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 495
 496         synchronized (providerLockObject) {
 497             LOGGER.debug("->createPolicies: serviceTemplate={}", serviceTemplate);
 498
 499             ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
 500                     .createPolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 501
 502             LOGGER.debug("<-createPolicies: createdServiceTemplate={}", createdServiceTemplate);
 503             return createdServiceTemplate;
 504         }
 505     }
 506
 507     /**
 508      * Update policies.
 509      *
 510      * @param dao the DAO to use to access the database
 511      * @param serviceTemplate the service template containing the definitions of the policies to be updated.
 512      * @return the TOSCA service template containing the policies that were updated
 513      * @throws PfModelException on errors updating policies
 514      */
 515     public ToscaServiceTemplate updatePolicies(@NonNull final PfDao dao,
 516             @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 517
 518         synchronized (providerLockObject) {
 519             LOGGER.debug("->updatePolicies: serviceTemplate={}", serviceTemplate);
 520
 521             ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
 522                     .updatePolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 523
 524             LOGGER.debug("<-updatePolicies: updatedServiceTemplate={}", updatedServiceTemplate);
 525             return updatedServiceTemplate;
 526         }
 527     }
 528
 529     /**
 530      * Delete policy.
 531      *
 532      * @param dao the DAO to use to access the database
 533      * @param name the name of the policy to delete.
 534      * @param version the version of the policy to delete.
 535      * @return the TOSCA service template containing the policy that was deleted
 536      * @throws PfModelException on errors deleting policies
 537      */
 538     public ToscaServiceTemplate deletePolicy(@NonNull final PfDao dao, @NonNull final String name,
 539             @NonNull final String version) throws PfModelException {
 540
 541         synchronized (providerLockObject) {
 542             LOGGER.debug("->deletePolicy: name={}, version={}", name, version);
 543
 544             ToscaServiceTemplate deletedServiceTemplate =
 545                     new SimpleToscaProvider().deletePolicy(dao, new PfConceptKey(name, version)).toAuthorative();
 546
 547             LOGGER.debug("<-deletePolicy: name={}, version={}, deletedServiceTemplate={}", name, version,
 548                     deletedServiceTemplate);
 549             return deletedServiceTemplate;
 550         }
 551     }
 552
 553     /**
 554      * Create tosca node templates.
 555      *
 556      * @param dao the DAO to use to access the database
 557      * @param toscaServiceTemplate the template with node templates entities to be created.
 558      * @return the toscaServiceTemplate with node templates that were created
 559      * @throws PfModelException on errors creating node templates
 560      */
 561     public ToscaServiceTemplate createToscaNodeTemplates(@NonNull final PfDao dao,
 562                                                          @NonNull final ToscaServiceTemplate toscaServiceTemplate)
 563         throws PfModelException {
 564         LOGGER.debug("createToscaNodeTemplates ={}", toscaServiceTemplate);
 565         ToscaServiceTemplate createdServiceTemplate;
 566
 567         synchronized (providerLockObject) {
 568             createdServiceTemplate = new SimpleToscaProvider()
 569                 .createToscaNodeTemplates(dao, new JpaToscaServiceTemplate(toscaServiceTemplate)).toAuthorative();
 570         }
 571
 572         LOGGER.debug("<-createToscaNodeTemplates: createdServiceTemplate={}", createdServiceTemplate);
 573         return createdServiceTemplate;
 574     }
 575
 576     /**
 577      * Update tosca node templates.
 578      *
 579      * @param dao the DAO to use to access the database
 580      * @param serviceTemplate the service template containing the definitions of the nodeTemplates to be updated.
 581      * @return the TOSCA service template containing the nodeTemplates that were updated
 582      * @throws PfModelRuntimeException on errors updating node templates
 583      */
 584     public ToscaServiceTemplate updateToscaNodeTemplates(@NonNull final PfDao dao,
 585                                                          @NonNull final ToscaServiceTemplate serviceTemplate)
 586         throws PfModelException {
 587         LOGGER.debug("->updateToscaNodeTemplates: serviceTemplate={}", serviceTemplate);
 588         ToscaServiceTemplate updatedServiceTemplate;
 589
 590         synchronized (providerLockObject) {
 591             updatedServiceTemplate = new SimpleToscaProvider()
 592                 .updateToscaNodeTemplates(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 593         }
 594
 595         LOGGER.debug("<-updateToscaNodeTemplates: updatedServiceTemplate={}", updatedServiceTemplate);
 596         return updatedServiceTemplate;
 597     }
 598
 599
 600     /**
 601      * Delete a tosca node template.
 602      *
 603      * @param dao the DAO to use to access the database
 604      * @param name the name of the node template to delete.
 605      * @param version the version of the node template to delete.
 606      * @return the TOSCA service template containing the node template that was deleted
 607      * @throws PfModelException on errors deleting node template
 608      */
 609     public ToscaServiceTemplate deleteToscaNodeTemplate(@NonNull final PfDao dao, @NonNull final String name,
 610                                                         @NonNull final String version) throws PfModelException {
 611         LOGGER.debug("->deleteToscaNodeTemplate: name={}, version={}", name, version);
 612         ToscaServiceTemplate deletedServiceTemplate;
 613
 614         synchronized (providerLockObject) {
 615             deletedServiceTemplate =
 616                 new SimpleToscaProvider().deleteToscaNodeTemplate(dao, new PfConceptKey(name, version)).toAuthorative();
 617         }
 618         LOGGER.debug("<-deleteToscaNodeTemplate: name={}, version={}, deletedServiceTemplate={}", name, version,
 619             deletedServiceTemplate);
 620         return deletedServiceTemplate;
 621     }
 622
 623     /**
 624      * Get node template metadataSet.
 625      *
 626      * @param dao the DAO to use to access the database
 627      * @param name the name of the metadataSet to get, null to get all metadataSets
 628      * @param version the version of the metadataSet to get, null to get all versions of a metadataSets
 629      * @return the metadataSets found
 630      * @throws PfModelException on errors getting policy metadataSet
 631      */
 632     public List<Map<ToscaEntityKey, Map<String, Object>>> getNodeTemplateMetadataSet(
 633         @NonNull final PfDao dao, final String name, final String version)
 634         throws PfModelException {
 635         LOGGER.debug("->getNodeTemplateMetadataSet: name={}, version={}", name, version);
 636         List<Map<ToscaEntityKey, Map<String, Object>>> metadataSets;
 637
 638         synchronized (providerLockObject) {
 639             metadataSets = new SimpleToscaProvider().getNodeTemplateMetadata(dao, name, version);
 640         }
 641         LOGGER.debug("<-getNodeTemplateMetadataSet: name={}, version={}, metadataSets={}", name, version,
 642             metadataSets);
 643         return metadataSets;
 644     }
 645
 646     /**
 647      * Get tosca node templates.
 648      *
 649      * @param dao the DAO to use to access the database
 650      * @param name the name of the node template to get, null to get all node templates
 651      * @param version the version of the node template to get, null to get all versions of node template
 652      * @return the node templates found
 653      * @throws PfModelException on errors getting tosca node templates
 654      */
 655     public List<ToscaNodeTemplate> getToscaNodeTemplate(
 656         @NonNull final PfDao dao, final String name, final String version)
 657         throws PfModelException {
 658         LOGGER.debug("->getNodeTemplate: name={}, version={}", name, version);
 659         List<ToscaNodeTemplate> nodeTemplates = new ArrayList<>();
 660
 661         synchronized (providerLockObject) {
 662             new SimpleToscaProvider().getToscaNodeTemplates(dao, name, version)
 663                 .getConceptMap().forEach((key, value) -> nodeTemplates.add(value.toAuthorative()));
 664         }
 665
 666         LOGGER.debug("<-getNodeTemplate: name={}, version={}, nodeTemplates={}", name, version,
 667             nodeTemplates);
 668         return nodeTemplates;
 669     }
 670
 671
 672     /**
 673      * Return the contents of a list of maps as a plain list.
 674      *
 675      * @param listOfMaps the list of maps
 676      * @return the plain list
 677      */
 678     private <T> List<T> asConceptList(final List<Map<String, T>> listOfMaps) {
 679         List<T> returnList = new ArrayList<>();
 680         for (Map<String, T> conceptMap : listOfMaps) {
 681             returnList.addAll(conceptMap.values());
 682         }
 683
 684         return returnList;
 685     }
 686
 687     /**
 688      * Handle a PfModelRuntimeException on a list call.
 689      *
 690      * @param pfme the model exception
 691      * @return an empty list on 404
 692      */
 693     private <T extends ToscaEntity> List<T> handlePfModelRuntimeException(final PfModelRuntimeException pfme) {
 694         if (Status.NOT_FOUND.equals(pfme.getErrorResponse().getResponseCode())) {
 695             LOGGER.trace("request did not find any results", pfme);
 696             return Collections.emptyList();
 697         } else {
 698             throw pfme;
 699         }
 700     }
 701 }