2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2019-2022 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
10 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * SPDX-License-Identifier: Apache-2.0
19 * ============LICENSE_END=========================================================
22 package org.onap.policy.models.tosca.authorative.provider;
24 import java.util.ArrayList;
25 import java.util.Collections;
26 import java.util.List;
28 import javax.ws.rs.core.Response;
29 import javax.ws.rs.core.Response.Status;
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;
51 * This class provides the provision of information on TOSCA concepts in the database to callers.
53 * @author Liam Fallon (liam.fallon@est.tech)
55 public class AuthorativeToscaProvider {
56 private static final Logger LOGGER = LoggerFactory.getLogger(AuthorativeToscaProvider.class);
58 // TODO: In next release this locking mechanism should be removed and replaced with proper session handling
59 private static final Object providerLockObject = "providerLockObject";
62 * Get service templates.
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
70 public List<ToscaServiceTemplate> getServiceTemplateList(PfDao dao, String name, String version)
71 throws PfModelException {
73 synchronized (providerLockObject) {
74 LOGGER.debug("->getServiceTemplateList: name={}, version={}", name, version);
76 List<ToscaServiceTemplate> serviceTemplateList = new ArrayList<>();
79 ToscaServiceTemplate serviceTemplate =
80 new SimpleToscaProvider().getServiceTemplate(dao).toAuthorative();
81 serviceTemplateList.add(serviceTemplate);
82 } catch (PfModelRuntimeException pfme) {
83 return handlePfModelRuntimeException(pfme);
86 LOGGER.debug("<-getServiceTemplateList: name={}, version={}, serviceTemplateList={}", name, version,
88 return serviceTemplateList;
93 * Get filtered service templates.
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
100 public List<ToscaServiceTemplate> getFilteredServiceTemplateList(PfDao pfDao,
101 @NonNull ToscaEntityFilter<ToscaServiceTemplate> filter) throws PfModelException {
103 LOGGER.debug("->getFilteredServiceTemplateList: filter={}", filter);
105 List<ToscaServiceTemplate> filteredServiceTemplateList =
106 filter.filter(getServiceTemplateList(pfDao, null, null));
108 LOGGER.debug("<-getFilteredServiceTemplateList: filter={}, filteredServiceTemplateList={}", filter,
109 filteredServiceTemplateList);
111 return filteredServiceTemplateList;
115 * Create a service template.
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
122 public ToscaServiceTemplate createServiceTemplate(@NonNull final PfDao dao,
123 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
125 synchronized (providerLockObject) {
126 LOGGER.debug("->createServiceTemplate: serviceTemplate={}", serviceTemplate);
128 ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
129 .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
131 LOGGER.debug("<-createServiceTemplate: createdServiceTemplate={}", createdServiceTemplate);
132 return createdServiceTemplate;
137 * Update a service template.
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
144 public ToscaServiceTemplate updateServiceTemplate(@NonNull final PfDao dao,
145 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
147 synchronized (providerLockObject) {
148 LOGGER.debug("->updateServiceTemplate: serviceTemplate={}", serviceTemplate);
150 ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
151 .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
153 LOGGER.debug("<-updateServiceTemplate: updatedServiceTemplate={}", updatedServiceTemplate);
154 return updatedServiceTemplate;
159 * Delete a service template.
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
167 public ToscaServiceTemplate deleteServiceTemplate(@NonNull final PfDao dao, @NonNull final String name,
168 @NonNull final String version) throws PfModelException {
170 synchronized (providerLockObject) {
171 LOGGER.debug("->deleteServiceTemplate: name={}, version={}", name, version);
173 ToscaServiceTemplate deletedServiceTemplate =
174 new SimpleToscaProvider().deleteServiceTemplate(dao).toAuthorative();
176 LOGGER.debug("<-deleteServiceTemplate: name={}, version={}, deletedServiceTemplate={}", name, version,
177 deletedServiceTemplate);
178 return deletedServiceTemplate;
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
191 public ToscaServiceTemplate getPolicyTypes(@NonNull final PfDao dao, final String name, final String version)
192 throws PfModelException {
194 synchronized (providerLockObject) {
195 LOGGER.debug("->getPolicyTypes: name={}, version={}", name, version);
197 JpaToscaServiceTemplate jpaServiceTemplate = new SimpleToscaProvider().getPolicyTypes(dao, name, version);
199 ToscaServiceTemplate serviceTemplate = jpaServiceTemplate.toAuthorative();
201 LOGGER.debug("<-getPolicyTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
202 return serviceTemplate;
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
215 public List<ToscaPolicyType> getPolicyTypeList(@NonNull final PfDao dao, final String name, final String version)
216 throws PfModelException {
218 synchronized (providerLockObject) {
219 LOGGER.debug("->getPolicyTypeList: name={}, version={}", name, version);
221 List<ToscaPolicyType> policyTypeList;
224 policyTypeList = new ArrayList<>(new SimpleToscaProvider().getPolicyTypes(dao, name, version)
225 .toAuthorative().getPolicyTypes().values());
226 } catch (PfModelRuntimeException pfme) {
227 return handlePfModelRuntimeException(pfme);
230 LOGGER.debug("<-getPolicyTypeList: name={}, version={}, policyTypeList={}", name, version, policyTypeList);
231 return policyTypeList;
236 * Get filtered policy types.
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
243 public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull final PfDao dao,
244 @NonNull final ToscaEntityFilter<ToscaPolicyType> filter) throws PfModelException {
246 synchronized (providerLockObject) {
247 LOGGER.debug("->getFilteredPolicyTypes: filter={}", filter);
248 var simpleToscaProvider = new SimpleToscaProvider();
250 final JpaToscaServiceTemplate dbServiceTemplate = simpleToscaProvider.getPolicyTypes(dao, null, null);
252 List<ToscaPolicyType> filteredPolicyTypes = dbServiceTemplate.getPolicyTypes().toAuthorativeList();
253 filteredPolicyTypes = filter.filter(filteredPolicyTypes);
255 if (CollectionUtils.isEmpty(filteredPolicyTypes)) {
256 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
257 "policy types for filter " + filter.toString() + " do not exist");
260 var filteredServiceTemplate = new JpaToscaServiceTemplate();
262 for (ToscaPolicyType policyType : filteredPolicyTypes) {
263 JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
264 .getCascadedPolicyTypes(dbServiceTemplate, policyType.getName(), policyType.getVersion());
266 filteredServiceTemplate =
267 ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
270 ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
272 LOGGER.debug("<-getFilteredPolicyTypes: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
273 return returnServiceTemplate;
278 * Get filtered policy types.
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
285 public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull final PfDao dao,
286 @NonNull final ToscaEntityFilter<ToscaPolicyType> filter) throws PfModelException {
288 LOGGER.debug("->getFilteredPolicyTypeList: filter={}", filter);
290 List<ToscaPolicyType> filteredPolicyTypeList = filter.filter(getPolicyTypeList(dao, null, null));
292 LOGGER.debug("<-getFilteredPolicyTypeList: filter={}, filteredPolicyTypeList={}", filter,
293 filteredPolicyTypeList);
295 return filteredPolicyTypeList;
299 * Create policy types.
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
306 public ToscaServiceTemplate createPolicyTypes(@NonNull final PfDao dao,
307 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
309 synchronized (providerLockObject) {
310 LOGGER.debug("->createPolicyTypes: serviceTemplate={}", serviceTemplate);
312 ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
313 .createPolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
315 LOGGER.debug("<-createPolicyTypes: createdServiceTemplate={}", createdServiceTemplate);
316 return createdServiceTemplate;
321 * Update policy types.
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
328 public ToscaServiceTemplate updatePolicyTypes(@NonNull final PfDao dao,
329 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
331 synchronized (providerLockObject) {
332 LOGGER.debug("->updatePolicyTypes: serviceTemplate={}", serviceTemplate);
334 ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
335 .updatePolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
337 LOGGER.debug("<-updatePolicyTypes: updatedServiceTemplate={}", updatedServiceTemplate);
338 return updatedServiceTemplate;
343 * Delete policy type.
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
351 public ToscaServiceTemplate deletePolicyType(@NonNull final PfDao dao, @NonNull final String name,
352 @NonNull final String version) throws PfModelException {
354 synchronized (providerLockObject) {
355 LOGGER.debug("->deletePolicyType: name={}, version={}", name, version);
357 ToscaServiceTemplate deletedServiceTemplate =
358 new SimpleToscaProvider().deletePolicyType(dao, new PfConceptKey(name, version)).toAuthorative();
360 LOGGER.debug("<-deletePolicyType: name={}, version={}, deletedServiceTemplate={}", name, version,
361 deletedServiceTemplate);
362 return deletedServiceTemplate;
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
375 public ToscaServiceTemplate getPolicies(@NonNull final PfDao dao, final String name, final String version)
376 throws PfModelException {
378 synchronized (providerLockObject) {
379 LOGGER.debug("->getPolicies: name={}, version={}", name, version);
381 ToscaServiceTemplate gotServiceTemplate =
382 new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative();
384 LOGGER.debug("<-getPolicies: name={}, version={}, gotServiceTemplate={}", name, version,
386 return gotServiceTemplate;
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
399 public List<ToscaPolicy> getPolicyList(@NonNull final PfDao dao, final String name, final String version)
400 throws PfModelException {
402 synchronized (providerLockObject) {
403 LOGGER.debug("->getPolicyList: name={}, version={}", name, version);
405 List<ToscaPolicy> policyList;
408 policyList = asConceptList(new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative()
409 .getToscaTopologyTemplate().getPolicies());
410 } catch (PfModelRuntimeException pfme) {
411 return handlePfModelRuntimeException(pfme);
414 LOGGER.debug("<-getPolicyList: name={}, version={}, policyList={}", name, version, policyList);
420 * Get filtered policies.
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
427 public ToscaServiceTemplate getFilteredPolicies(@NonNull final PfDao dao,
428 @NonNull final ToscaTypedEntityFilter<ToscaPolicy> filter) throws PfModelException {
430 synchronized (providerLockObject) {
431 LOGGER.debug("->getFilteredPolicies: filter={}", filter);
433 ToscaTypedEntityFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
435 var simpleToscaProvider = new SimpleToscaProvider();
436 final JpaToscaServiceTemplate dbServiceTemplate =
437 simpleToscaProvider.getPolicies(dao, filter.getName(), version);
439 List<ToscaPolicy> filteredPolicies =
440 dbServiceTemplate.getTopologyTemplate().getPolicies().toAuthorativeList();
441 filteredPolicies = filter.filter(filteredPolicies);
443 if (CollectionUtils.isEmpty(filteredPolicies)) {
444 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
445 "policies for filter " + filter.toString() + " do not exist");
448 var filteredServiceTemplate = new JpaToscaServiceTemplate();
450 for (ToscaPolicy policy : filteredPolicies) {
451 JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
452 .getCascadedPolicies(dbServiceTemplate, policy.getName(), policy.getVersion());
454 filteredServiceTemplate =
455 ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
458 ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
460 LOGGER.debug("<-getFilteredPolicies: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
461 return returnServiceTemplate;
466 * Get filtered policies.
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
473 public List<ToscaPolicy> getFilteredPolicyList(@NonNull final PfDao dao,
474 @NonNull final ToscaTypedEntityFilter<ToscaPolicy> filter) throws PfModelException {
476 LOGGER.debug("->getFilteredPolicyList: filter={}", filter);
477 String version = ToscaTypedEntityFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
479 List<ToscaPolicy> policyList = filter.filter(getPolicyList(dao, filter.getName(), version));
481 LOGGER.debug("<-getFilteredPolicyList: filter={}, policyList={}", filter, policyList);
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
493 public ToscaServiceTemplate createPolicies(@NonNull final PfDao dao,
494 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
496 synchronized (providerLockObject) {
497 LOGGER.debug("->createPolicies: serviceTemplate={}", serviceTemplate);
499 ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
500 .createPolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
502 LOGGER.debug("<-createPolicies: createdServiceTemplate={}", createdServiceTemplate);
503 return createdServiceTemplate;
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
515 public ToscaServiceTemplate updatePolicies(@NonNull final PfDao dao,
516 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
518 synchronized (providerLockObject) {
519 LOGGER.debug("->updatePolicies: serviceTemplate={}", serviceTemplate);
521 ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
522 .updatePolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
524 LOGGER.debug("<-updatePolicies: updatedServiceTemplate={}", updatedServiceTemplate);
525 return updatedServiceTemplate;
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
538 public ToscaServiceTemplate deletePolicy(@NonNull final PfDao dao, @NonNull final String name,
539 @NonNull final String version) throws PfModelException {
541 synchronized (providerLockObject) {
542 LOGGER.debug("->deletePolicy: name={}, version={}", name, version);
544 ToscaServiceTemplate deletedServiceTemplate =
545 new SimpleToscaProvider().deletePolicy(dao, new PfConceptKey(name, version)).toAuthorative();
547 LOGGER.debug("<-deletePolicy: name={}, version={}, deletedServiceTemplate={}", name, version,
548 deletedServiceTemplate);
549 return deletedServiceTemplate;
554 * Create tosca node templates.
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
561 public ToscaServiceTemplate createToscaNodeTemplates(@NonNull final PfDao dao,
562 @NonNull final ToscaServiceTemplate toscaServiceTemplate)
563 throws PfModelException {
564 LOGGER.debug("createToscaNodeTemplates ={}", toscaServiceTemplate);
565 ToscaServiceTemplate createdServiceTemplate;
567 synchronized (providerLockObject) {
568 createdServiceTemplate = new SimpleToscaProvider()
569 .createToscaNodeTemplates(dao, new JpaToscaServiceTemplate(toscaServiceTemplate)).toAuthorative();
572 LOGGER.debug("<-createToscaNodeTemplates: createdServiceTemplate={}", createdServiceTemplate);
573 return createdServiceTemplate;
577 * Update tosca node templates.
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
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;
590 synchronized (providerLockObject) {
591 updatedServiceTemplate = new SimpleToscaProvider()
592 .updateToscaNodeTemplates(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
595 LOGGER.debug("<-updateToscaNodeTemplates: updatedServiceTemplate={}", updatedServiceTemplate);
596 return updatedServiceTemplate;
601 * Delete a tosca node template.
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
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;
614 synchronized (providerLockObject) {
615 deletedServiceTemplate =
616 new SimpleToscaProvider().deleteToscaNodeTemplate(dao, new PfConceptKey(name, version)).toAuthorative();
618 LOGGER.debug("<-deleteToscaNodeTemplate: name={}, version={}, deletedServiceTemplate={}", name, version,
619 deletedServiceTemplate);
620 return deletedServiceTemplate;
624 * Get node template metadataSet.
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
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;
638 synchronized (providerLockObject) {
639 metadataSets = new SimpleToscaProvider().getNodeTemplateMetadata(dao, name, version);
641 LOGGER.debug("<-getNodeTemplateMetadataSet: name={}, version={}, metadataSets={}", name, version,
647 * Get tosca node templates.
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
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<>();
661 synchronized (providerLockObject) {
662 new SimpleToscaProvider().getToscaNodeTemplates(dao, name, version)
663 .getConceptMap().forEach((key, value) -> nodeTemplates.add(value.toAuthorative()));
666 LOGGER.debug("<-getNodeTemplate: name={}, version={}, nodeTemplates={}", name, version,
668 return nodeTemplates;
673 * Return the contents of a list of maps as a plain list.
675 * @param listOfMaps the list of maps
676 * @return the plain list
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 for (T concept : conceptMap.values()) {
682 returnList.add(concept);
690 * Handle a PfModelRuntimeException on a list call.
692 * @param pfme the model exception
693 * @return an empty list on 404
695 private <T extends ToscaEntity> List<T> handlePfModelRuntimeException(final PfModelRuntimeException pfme) {
696 if (Status.NOT_FOUND.equals(pfme.getErrorResponse().getResponseCode())) {
697 LOGGER.trace("request did not find any results", pfme);
698 return Collections.emptyList();