2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2019-2021 Nordix Foundation.
4 * Modifications Copyright (C) 2019 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.ToscaPolicy;
39 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
40 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
41 import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
42 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
43 import org.onap.policy.models.tosca.simple.provider.SimpleToscaProvider;
44 import org.onap.policy.models.tosca.utils.ToscaServiceTemplateUtils;
45 import org.slf4j.Logger;
46 import org.slf4j.LoggerFactory;
49 * This class provides the provision of information on TOSCA concepts in the database to callers.
51 * @author Liam Fallon (liam.fallon@est.tech)
53 public class AuthorativeToscaProvider {
54 private static final Logger LOGGER = LoggerFactory.getLogger(AuthorativeToscaProvider.class);
56 // TODO: In next release this locking mechanism should be removed and replaced with proper session handling
57 private static final Object providerLockObject = "providerLockObject";
60 * Get service templates.
62 * @param dao the DAO to use to access the database
63 * @param name the name of the service template to get.
64 * @param version the version of the service template to get.
65 * @return the service templates found
66 * @throws PfModelException on errors getting service templates
68 public List<ToscaServiceTemplate> getServiceTemplateList(PfDao dao, String name, String version)
69 throws PfModelException {
71 synchronized (providerLockObject) {
72 LOGGER.debug("->getServiceTemplateList: name={}, version={}", name, version);
74 List<ToscaServiceTemplate> serviceTemplateList = new ArrayList<>();
77 ToscaServiceTemplate serviceTemplate =
78 new SimpleToscaProvider().getServiceTemplate(dao).toAuthorative();
79 serviceTemplateList.add(serviceTemplate);
80 } catch (PfModelRuntimeException pfme) {
81 return handlePfModelRuntimeException(pfme);
84 LOGGER.debug("<-getServiceTemplateList: name={}, version={}, serviceTemplateList={}", name, version,
86 return serviceTemplateList;
91 * Get filtered service templates.
93 * @param pfDao the DAO to use to access the database
94 * @param filter the filter for the service templates to get
95 * @return the service templates found
96 * @throws PfModelException on errors getting service templates
98 public List<ToscaServiceTemplate> getFilteredServiceTemplateList(PfDao pfDao,
99 @NonNull ToscaEntityFilter<ToscaServiceTemplate> filter) throws PfModelException {
101 LOGGER.debug("->getFilteredServiceTemplateList: filter={}", filter);
103 List<ToscaServiceTemplate> filteredServiceTemplateList =
104 filter.filter(getServiceTemplateList(pfDao, null, null));
106 LOGGER.debug("<-getFilteredServiceTemplateList: filter={}, filteredServiceTemplateList={}", filter,
107 filteredServiceTemplateList);
109 return filteredServiceTemplateList;
113 * Create a service template.
115 * @param dao the DAO to use to access the database
116 * @param serviceTemplate the service template to be created.
117 * @return the TOSCA service template that was created
118 * @throws PfModelException on errors creating the service template
120 public ToscaServiceTemplate createServiceTemplate(@NonNull final PfDao dao,
121 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
123 synchronized (providerLockObject) {
124 LOGGER.debug("->createServiceTemplate: serviceTemplate={}", serviceTemplate);
126 ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
127 .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
129 LOGGER.debug("<-createServiceTemplate: createdServiceTemplate={}", createdServiceTemplate);
130 return createdServiceTemplate;
135 * Update a service template.
137 * @param dao the DAO to use to access the database
138 * @param serviceTemplate the service template to be updated.
139 * @return the TOSCA service template that was updated
140 * @throws PfModelException on errors updating the service template
142 public ToscaServiceTemplate updateServiceTemplate(@NonNull final PfDao dao,
143 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
145 synchronized (providerLockObject) {
146 LOGGER.debug("->updateServiceTemplate: serviceTemplate={}", serviceTemplate);
148 ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
149 .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
151 LOGGER.debug("<-updateServiceTemplate: updatedServiceTemplate={}", updatedServiceTemplate);
152 return updatedServiceTemplate;
157 * Delete a service template.
159 * @param dao the DAO to use to access the database
160 * @param name the name of the service template to delete.
161 * @param version the version of the service template to delete.
162 * @return the TOSCA service template that was deleted
163 * @throws PfModelException on errors deleting the control loop
165 public ToscaServiceTemplate deleteServiceTemplate(@NonNull final PfDao dao, @NonNull final String name,
166 @NonNull final String version) throws PfModelException {
168 synchronized (providerLockObject) {
169 LOGGER.debug("->deleteServiceTemplate: name={}, version={}", name, version);
171 ToscaServiceTemplate deletedServiceTemplate =
172 new SimpleToscaProvider().deleteServiceTemplate(dao).toAuthorative();
174 LOGGER.debug("<-deleteServiceTemplate: name={}, version={}, deletedServiceTemplate={}", name, version,
175 deletedServiceTemplate);
176 return deletedServiceTemplate;
183 * @param dao the DAO to use to access the database
184 * @param name the name of the policy type to get.
185 * @param version the version of the policy type to get.
186 * @return the policy types found
187 * @throws PfModelException on errors getting policy types
189 public ToscaServiceTemplate getPolicyTypes(@NonNull final PfDao dao, final String name, final String version)
190 throws PfModelException {
192 synchronized (providerLockObject) {
193 LOGGER.debug("->getPolicyTypes: name={}, version={}", name, version);
195 JpaToscaServiceTemplate jpaServiceTemplate = new SimpleToscaProvider().getPolicyTypes(dao, name, version);
197 ToscaServiceTemplate serviceTemplate = jpaServiceTemplate.toAuthorative();
199 LOGGER.debug("<-getPolicyTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
200 return serviceTemplate;
207 * @param dao the DAO to use to access the database
208 * @param name the name of the policy type to get, set to null to get all policy types
209 * @param version the version of the policy type to get, set to null to get all versions
210 * @return the policy types found
211 * @throws PfModelException on errors getting policy types
213 public List<ToscaPolicyType> getPolicyTypeList(@NonNull final PfDao dao, final String name, final String version)
214 throws PfModelException {
216 synchronized (providerLockObject) {
217 LOGGER.debug("->getPolicyTypeList: name={}, version={}", name, version);
219 List<ToscaPolicyType> policyTypeList;
222 policyTypeList = new ArrayList<>(new SimpleToscaProvider().getPolicyTypes(dao, name, version)
223 .toAuthorative().getPolicyTypes().values());
224 } catch (PfModelRuntimeException pfme) {
225 return handlePfModelRuntimeException(pfme);
228 LOGGER.debug("<-getPolicyTypeList: name={}, version={}, policyTypeList={}", name, version, policyTypeList);
229 return policyTypeList;
234 * Get filtered policy types.
236 * @param dao the DAO to use to access the database
237 * @param filter the filter for the policy types to get
238 * @return the policy types found
239 * @throws PfModelException on errors getting policy types
241 public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull final PfDao dao,
242 @NonNull final ToscaEntityFilter<ToscaPolicyType> filter) throws PfModelException {
244 synchronized (providerLockObject) {
245 LOGGER.debug("->getFilteredPolicyTypes: filter={}", filter);
246 SimpleToscaProvider simpleToscaProvider = new SimpleToscaProvider();
248 final JpaToscaServiceTemplate dbServiceTemplate = simpleToscaProvider.getPolicyTypes(dao, null, null);
250 List<ToscaPolicyType> filteredPolicyTypes = dbServiceTemplate.getPolicyTypes().toAuthorativeList();
251 filteredPolicyTypes = filter.filter(filteredPolicyTypes);
253 if (CollectionUtils.isEmpty(filteredPolicyTypes)) {
254 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
255 "policy types for filter " + filter.toString() + " do not exist");
258 JpaToscaServiceTemplate filteredServiceTemplate = new JpaToscaServiceTemplate();
260 for (ToscaPolicyType policyType : filteredPolicyTypes) {
261 JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
262 .getCascadedPolicyTypes(dbServiceTemplate, policyType.getName(), policyType.getVersion());
264 filteredServiceTemplate =
265 ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
268 ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
270 LOGGER.debug("<-getFilteredPolicyTypes: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
271 return returnServiceTemplate;
276 * Get filtered policy types.
278 * @param dao the DAO to use to access the database
279 * @param filter the filter for the policy types to get
280 * @return the policy types found
281 * @throws PfModelException on errors getting policy types
283 public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull final PfDao dao,
284 @NonNull final ToscaEntityFilter<ToscaPolicyType> filter) throws PfModelException {
286 LOGGER.debug("->getFilteredPolicyTypeList: filter={}", filter);
288 List<ToscaPolicyType> filteredPolicyTypeList = filter.filter(getPolicyTypeList(dao, null, null));
290 LOGGER.debug("<-getFilteredPolicyTypeList: filter={}, filteredPolicyTypeList={}", filter,
291 filteredPolicyTypeList);
293 return filteredPolicyTypeList;
297 * Create policy types.
299 * @param dao the DAO to use to access the database
300 * @param serviceTemplate the service template containing the definition of the policy types to be created
301 * @return the TOSCA service template containing the created policy types
302 * @throws PfModelException on errors creating policy types
304 public ToscaServiceTemplate createPolicyTypes(@NonNull final PfDao dao,
305 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
307 synchronized (providerLockObject) {
308 LOGGER.debug("->createPolicyTypes: serviceTemplate={}", serviceTemplate);
310 ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
311 .createPolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
313 LOGGER.debug("<-createPolicyTypes: createdServiceTemplate={}", createdServiceTemplate);
314 return createdServiceTemplate;
319 * Update policy types.
321 * @param dao the DAO to use to access the database
322 * @param serviceTemplate the service template containing the definition of the policy types to be modified
323 * @return the TOSCA service template containing the modified policy types
324 * @throws PfModelException on errors updating policy types
326 public ToscaServiceTemplate updatePolicyTypes(@NonNull final PfDao dao,
327 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
329 synchronized (providerLockObject) {
330 LOGGER.debug("->updatePolicyTypes: serviceTemplate={}", serviceTemplate);
332 ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
333 .updatePolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
335 LOGGER.debug("<-updatePolicyTypes: updatedServiceTemplate={}", updatedServiceTemplate);
336 return updatedServiceTemplate;
341 * Delete policy type.
343 * @param dao the DAO to use to access the database
344 * @param name the name of the policy type to delete.
345 * @param version the version of the policy type to delete.
346 * @return the TOSCA service template containing the policy type that was deleted
347 * @throws PfModelException on errors deleting policy types
349 public ToscaServiceTemplate deletePolicyType(@NonNull final PfDao dao, @NonNull final String name,
350 @NonNull final String version) throws PfModelException {
352 synchronized (providerLockObject) {
353 LOGGER.debug("->deletePolicyType: name={}, version={}", name, version);
355 ToscaServiceTemplate deletedServiceTemplate =
356 new SimpleToscaProvider().deletePolicyType(dao, new PfConceptKey(name, version)).toAuthorative();
358 LOGGER.debug("<-deletePolicyType: name={}, version={}, deletedServiceTemplate={}", name, version,
359 deletedServiceTemplate);
360 return deletedServiceTemplate;
367 * @param dao the DAO to use to access the database
368 * @param name the name of the policy to get.
369 * @param version the version of the policy to get.
370 * @return the policies found
371 * @throws PfModelException on errors getting policies
373 public ToscaServiceTemplate getPolicies(@NonNull final PfDao dao, final String name, final String version)
374 throws PfModelException {
376 synchronized (providerLockObject) {
377 LOGGER.debug("->getPolicies: name={}, version={}", name, version);
379 ToscaServiceTemplate gotServiceTemplate =
380 new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative();
382 LOGGER.debug("<-getPolicies: name={}, version={}, gotServiceTemplate={}", name, version,
384 return gotServiceTemplate;
391 * @param dao the DAO to use to access the database
392 * @param name the name of the policy to get, null to get all policies
393 * @param version the version of the policy to get, null to get all versions of a policy
394 * @return the policies found
395 * @throws PfModelException on errors getting policies
397 public List<ToscaPolicy> getPolicyList(@NonNull final PfDao dao, final String name, final String version)
398 throws PfModelException {
400 synchronized (providerLockObject) {
401 LOGGER.debug("->getPolicyList: name={}, version={}", name, version);
403 List<ToscaPolicy> policyList;
406 policyList = asConceptList(new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative()
407 .getToscaTopologyTemplate().getPolicies());
408 } catch (PfModelRuntimeException pfme) {
409 return handlePfModelRuntimeException(pfme);
412 LOGGER.debug("<-getPolicyList: name={}, version={}, policyList={}", name, version, policyList);
418 * Get filtered policies.
420 * @param dao the DAO to use to access the database
421 * @param filter the filter for the policies to get
422 * @return the policies found
423 * @throws PfModelException on errors getting policies
425 public ToscaServiceTemplate getFilteredPolicies(@NonNull final PfDao dao,
426 @NonNull final ToscaTypedEntityFilter<ToscaPolicy> filter) throws PfModelException {
428 synchronized (providerLockObject) {
429 LOGGER.debug("->getFilteredPolicies: filter={}", filter);
431 ToscaTypedEntityFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
433 SimpleToscaProvider simpleToscaProvider = new SimpleToscaProvider();
434 final JpaToscaServiceTemplate dbServiceTemplate =
435 simpleToscaProvider.getPolicies(dao, filter.getName(), version);
437 List<ToscaPolicy> filteredPolicies =
438 dbServiceTemplate.getTopologyTemplate().getPolicies().toAuthorativeList();
439 filteredPolicies = filter.filter(filteredPolicies);
441 if (CollectionUtils.isEmpty(filteredPolicies)) {
442 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
443 "policies for filter " + filter.toString() + " do not exist");
446 JpaToscaServiceTemplate filteredServiceTemplate = new JpaToscaServiceTemplate();
448 for (ToscaPolicy policy : filteredPolicies) {
449 JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
450 .getCascadedPolicies(dbServiceTemplate, policy.getName(), policy.getVersion());
452 filteredServiceTemplate =
453 ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
456 ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
458 LOGGER.debug("<-getFilteredPolicies: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
459 return returnServiceTemplate;
464 * Get filtered policies.
466 * @param dao the DAO to use to access the database
467 * @param filter the filter for the policies to get
468 * @return the policies found
469 * @throws PfModelException on errors getting policies
471 public List<ToscaPolicy> getFilteredPolicyList(@NonNull final PfDao dao,
472 @NonNull final ToscaTypedEntityFilter<ToscaPolicy> filter) throws PfModelException {
474 LOGGER.debug("->getFilteredPolicyList: filter={}", filter);
475 String version = ToscaTypedEntityFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
477 List<ToscaPolicy> policyList = filter.filter(getPolicyList(dao, filter.getName(), version));
479 LOGGER.debug("<-getFilteredPolicyList: filter={}, policyList={}", filter, policyList);
486 * @param dao the DAO to use to access the database
487 * @param serviceTemplate the service template containing the definitions of the new policies to be created.
488 * @return the TOSCA service template containing the policy types that were created
489 * @throws PfModelException on errors creating policies
491 public ToscaServiceTemplate createPolicies(@NonNull final PfDao dao,
492 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
494 synchronized (providerLockObject) {
495 LOGGER.debug("->createPolicies: serviceTemplate={}", serviceTemplate);
497 ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
498 .createPolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
500 LOGGER.debug("<-createPolicies: createdServiceTemplate={}", createdServiceTemplate);
501 return createdServiceTemplate;
508 * @param dao the DAO to use to access the database
509 * @param serviceTemplate the service template containing the definitions of the policies to be updated.
510 * @return the TOSCA service template containing the policies that were updated
511 * @throws PfModelException on errors updating policies
513 public ToscaServiceTemplate updatePolicies(@NonNull final PfDao dao,
514 @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
516 synchronized (providerLockObject) {
517 LOGGER.debug("->updatePolicies: serviceTemplate={}", serviceTemplate);
519 ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
520 .updatePolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
522 LOGGER.debug("<-updatePolicies: updatedServiceTemplate={}", updatedServiceTemplate);
523 return updatedServiceTemplate;
530 * @param dao the DAO to use to access the database
531 * @param name the name of the policy to delete.
532 * @param version the version of the policy to delete.
533 * @return the TOSCA service template containing the policy that was deleted
534 * @throws PfModelException on errors deleting policies
536 public ToscaServiceTemplate deletePolicy(@NonNull final PfDao dao, @NonNull final String name,
537 @NonNull final String version) throws PfModelException {
539 synchronized (providerLockObject) {
540 LOGGER.debug("->deletePolicy: name={}, version={}", name, version);
542 ToscaServiceTemplate deletedServiceTemplate =
543 new SimpleToscaProvider().deletePolicy(dao, new PfConceptKey(name, version)).toAuthorative();
545 LOGGER.debug("<-deletePolicy: name={}, version={}, deletedServiceTemplate={}", name, version,
546 deletedServiceTemplate);
547 return deletedServiceTemplate;
552 * Return the contents of a list of maps as a plain list.
554 * @param listOfMaps the list of maps
555 * @return the plain list
557 private <T> List<T> asConceptList(final List<Map<String, T>> listOfMaps) {
558 List<T> returnList = new ArrayList<>();
559 for (Map<String, T> conceptMap : listOfMaps) {
560 for (T concept : conceptMap.values()) {
561 returnList.add(concept);
569 * Handle a PfModelRuntimeException on a list call.
571 * @param pfme the model exception
572 * @return an empty list on 404
574 private <T extends ToscaEntity> List<T> handlePfModelRuntimeException(final PfModelRuntimeException pfme) {
575 if (Status.NOT_FOUND.equals(pfme.getErrorResponse().getResponseCode())) {
576 LOGGER.trace("request did not find any results", pfme);
577 return Collections.emptyList();