2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2019-2020 Nordix Foundation.
4 * ================================================================================
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
17 * SPDX-License-Identifier: Apache-2.0
18 * ============LICENSE_END=========================================================
21 package org.onap.policy.models.tosca.simple.provider;
23 import java.util.ArrayList;
24 import java.util.Collection;
25 import java.util.List;
26 import javax.ws.rs.core.Response;
27 import lombok.NonNull;
28 import org.apache.commons.collections4.CollectionUtils;
29 import org.onap.policy.models.base.PfConcept;
30 import org.onap.policy.models.base.PfConceptFilter;
31 import org.onap.policy.models.base.PfConceptKey;
32 import org.onap.policy.models.base.PfKey;
33 import org.onap.policy.models.base.PfModelException;
34 import org.onap.policy.models.base.PfModelRuntimeException;
35 import org.onap.policy.models.base.PfValidationResult;
36 import org.onap.policy.models.dao.PfDao;
37 import org.onap.policy.models.tosca.authorative.concepts.ToscaEntity;
38 import org.onap.policy.models.tosca.simple.concepts.JpaToscaDataType;
39 import org.onap.policy.models.tosca.simple.concepts.JpaToscaDataTypes;
40 import org.onap.policy.models.tosca.simple.concepts.JpaToscaEntityType;
41 import org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicies;
42 import org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicy;
43 import org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyType;
44 import org.onap.policy.models.tosca.simple.concepts.JpaToscaPolicyTypes;
45 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
46 import org.onap.policy.models.tosca.simple.concepts.JpaToscaTopologyTemplate;
47 import org.onap.policy.models.tosca.utils.ToscaServiceTemplateUtils;
48 import org.onap.policy.models.tosca.utils.ToscaUtils;
49 import org.slf4j.Logger;
50 import org.slf4j.LoggerFactory;
53 * This class provides the provision of information on TOSCA concepts in the database to callers.
55 * @author Liam Fallon (liam.fallon@est.tech)
57 public class SimpleToscaProvider {
58 private static final Logger LOGGER = LoggerFactory.getLogger(SimpleToscaProvider.class);
60 // Recurring string constants
61 private static final String DATA_TYPE = "data type ";
62 private static final String POLICY_TYPE = "policy type ";
63 private static final String SERVICE_TEMPLATE_NOT_FOUND_IN_DATABASE = "service template not found in database";
64 private static final String DO_NOT_EXIST = " do not exist";
65 private static final String NOT_FOUND = " not found";
68 * Get Service Template.
70 * @param dao the DAO to use to access the database
71 * @return the service template
72 * @throws PfModelException on errors getting the service template
74 public JpaToscaServiceTemplate getServiceTemplate(@NonNull final PfDao dao) throws PfModelException {
75 LOGGER.debug("->getServiceTemplate");
77 JpaToscaServiceTemplate serviceTemplate = new SimpleToscaServiceTemplateProvider().read(dao);
78 if (serviceTemplate == null) {
79 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, SERVICE_TEMPLATE_NOT_FOUND_IN_DATABASE);
82 LOGGER.debug("<-getServiceTemplate: serviceTemplate={}", serviceTemplate);
83 return serviceTemplate;
87 * Append a service template fragment to the service template in the database.
89 * @param dao the DAO to use to access the database
90 * @param incomingServiceTemplateFragment the service template containing the definition of the entities to be
92 * @return the TOSCA service template in the database after the operation
93 * @throws PfModelException on errors appending a service template to the template in the database
95 public JpaToscaServiceTemplate appendToServiceTemplate(@NonNull final PfDao dao,
96 @NonNull final JpaToscaServiceTemplate incomingServiceTemplateFragment) throws PfModelException {
97 LOGGER.debug("->appendServiceTemplateFragment: incomingServiceTemplateFragment={}",
98 incomingServiceTemplateFragment);
100 JpaToscaServiceTemplate dbServiceTemplate = new SimpleToscaServiceTemplateProvider().read(dao);
102 JpaToscaServiceTemplate serviceTemplateToWrite;
103 if (dbServiceTemplate == null) {
104 serviceTemplateToWrite = incomingServiceTemplateFragment;
106 serviceTemplateToWrite =
107 ToscaServiceTemplateUtils.addFragment(dbServiceTemplate, incomingServiceTemplateFragment);
110 PfValidationResult result = serviceTemplateToWrite.validate(new PfValidationResult());
111 if (!result.isValid()) {
112 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, result.toString());
115 new SimpleToscaServiceTemplateProvider().write(dao, serviceTemplateToWrite);
117 LOGGER.debug("<-appendServiceTemplateFragment: returnServiceTempalate={}", serviceTemplateToWrite);
118 return serviceTemplateToWrite;
122 * Delete service template.
124 * @param dao the DAO to use to access the database
125 * @return the TOSCA service template that was deleted
126 * @throws PfModelException on errors deleting the service template
128 public JpaToscaServiceTemplate deleteServiceTemplate(@NonNull final PfDao dao) throws PfModelException {
129 LOGGER.debug("->deleteServiceTemplate");
131 JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao);
133 dao.delete(serviceTemplate);
135 LOGGER.debug("->deleteServiceTemplate: serviceTemplate={}", serviceTemplate);
136 return serviceTemplate;
142 * @param dao the DAO to use to access the database
143 * @param name the name of the data type to get, set to null to get all policy types
144 * @param version the version of the data type to get, set to null to get all versions
145 * @return the data types found
146 * @throws PfModelException on errors getting data types
148 public JpaToscaServiceTemplate getDataTypes(@NonNull final PfDao dao, final String name, final String version)
149 throws PfModelException {
150 LOGGER.debug("->getDataTypes: name={}, version={}", name, version);
152 final JpaToscaServiceTemplate dbServiceTemplate = getServiceTemplate(dao);
154 if (!ToscaUtils.doDataTypesExist(dbServiceTemplate)) {
155 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
156 "data types for " + name + ":" + version + DO_NOT_EXIST);
159 JpaToscaServiceTemplate serviceTemplate = getCascadedDataTypes(dbServiceTemplate, name, version);
161 LOGGER.debug("<-getDataTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
162 return serviceTemplate;
166 * Get the cascaded data types for a data type name and version.
168 * @param dbServiceTemplate the service template to search for the cascaded data types
169 * @param name the data type name we are searching for
170 * @param version the data type version we are searching for
171 * @return a service template containing the cascaded data types
172 * @throws PfModelException on errors getting the data types
174 public JpaToscaServiceTemplate getCascadedDataTypes(@NonNull final JpaToscaServiceTemplate dbServiceTemplate,
175 final String name, final String version) throws PfModelException {
177 JpaToscaServiceTemplate serviceTemplate = new JpaToscaServiceTemplate(dbServiceTemplate);
178 serviceTemplate.setPolicyTypes(null);
179 serviceTemplate.setTopologyTemplate(null);
181 ToscaUtils.getEntityTree(serviceTemplate.getDataTypes(), name, version);
183 if (!ToscaUtils.doDataTypesExist(serviceTemplate)) {
184 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
185 "data types for " + name + ":" + version + DO_NOT_EXIST);
188 for (JpaToscaDataType dataType : serviceTemplate.getDataTypes().getConceptMap().values()) {
189 Collection<PfConceptKey> referencedDataTypeKeys = dataType.getReferencedDataTypes();
191 for (PfConceptKey referencedDataTypeKey : referencedDataTypeKeys) {
192 JpaToscaServiceTemplate dataTypeEntityTreeServiceTemplate = getCascadedDataTypes(dbServiceTemplate,
193 referencedDataTypeKey.getName(), referencedDataTypeKey.getVersion());
196 ToscaServiceTemplateUtils.addFragment(serviceTemplate, dataTypeEntityTreeServiceTemplate);
199 return serviceTemplate;
205 * @param dao the DAO to use to access the database
206 * @param incomingServiceTemplate the service template containing the definition of the data types to be created
207 * @return the TOSCA service template containing the created data types
208 * @throws PfModelException on errors creating data types
210 public JpaToscaServiceTemplate createDataTypes(@NonNull final PfDao dao,
211 @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException {
212 LOGGER.debug("->createDataTypes: incomingServiceTemplate={}", incomingServiceTemplate);
214 ToscaUtils.assertDataTypesExist(incomingServiceTemplate);
216 JpaToscaServiceTemplate writtenServiceTemplate = appendToServiceTemplate(dao, incomingServiceTemplate);
218 LOGGER.debug("<-createDataTypes: writtenServiceTemplate={}", writtenServiceTemplate);
219 return incomingServiceTemplate;
225 * @param dao the DAO to use to access the database
226 * @param serviceTemplate the service template containing the definition of the data types to be modified
227 * @return the TOSCA service template containing the modified data types
228 * @throws PfModelException on errors updating Data types
230 public JpaToscaServiceTemplate updateDataTypes(@NonNull final PfDao dao,
231 @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException {
232 LOGGER.debug("->updateDataTypes: serviceTempalate={}", serviceTemplate);
234 ToscaUtils.assertDataTypesExist(serviceTemplate);
236 for (JpaToscaDataType dataType : serviceTemplate.getDataTypes().getAll(null)) {
237 dao.update(dataType);
240 // Return the created data types
241 JpaToscaDataTypes returnDataTypes = new JpaToscaDataTypes();
243 for (PfConceptKey dataTypeKey : serviceTemplate.getDataTypes().getConceptMap().keySet()) {
244 returnDataTypes.getConceptMap().put(dataTypeKey, dao.get(JpaToscaDataType.class, dataTypeKey));
247 JpaToscaServiceTemplate returnServiceTemplate = new JpaToscaServiceTemplate();
248 returnServiceTemplate.setDataTypes(returnDataTypes);
250 LOGGER.debug("<-updateDataTypes: returnServiceTempalate={}", returnServiceTemplate);
251 return returnServiceTemplate;
257 * @param dao the DAO to use to access the database
258 * @param dataTypeKey the data type key for the Data types to be deleted, if the version of the key is null, all
259 * versions of the data type are deleted.
260 * @return the TOSCA service template containing the data types that were deleted
261 * @throws PfModelException on errors deleting data types
263 public JpaToscaServiceTemplate deleteDataType(@NonNull final PfDao dao, @NonNull final PfConceptKey dataTypeKey)
264 throws PfModelException {
265 LOGGER.debug("->deleteDataType: key={}", dataTypeKey);
267 JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao);
269 if (!ToscaUtils.doDataTypesExist(serviceTemplate)) {
270 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "no data types found");
273 JpaToscaDataType dataType4Deletion = serviceTemplate.getDataTypes().get(dataTypeKey);
274 if (dataType4Deletion == null) {
275 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, DATA_TYPE + dataTypeKey.getId() + NOT_FOUND);
278 for (JpaToscaDataType dataType : serviceTemplate.getDataTypes().getAll(null)) {
279 if (dataType.getReferencedDataTypes().contains(dataTypeKey)) {
280 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE,
281 DATA_TYPE + dataTypeKey.getId() + " is in use, it is referenced in data type " + dataType.getId());
285 if (ToscaUtils.doPolicyTypesExist(serviceTemplate)) {
286 for (JpaToscaPolicyType policyType : serviceTemplate.getPolicyTypes().getAll(null)) {
287 if (policyType.getReferencedDataTypes().contains(dataTypeKey)) {
288 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, DATA_TYPE + dataTypeKey.getId()
289 + " is in use, it is referenced in policy type " + policyType.getId());
294 serviceTemplate.getDataTypes().getConceptMap().remove(dataTypeKey);
295 new SimpleToscaServiceTemplateProvider().write(dao, serviceTemplate);
296 dao.delete(dataType4Deletion);
298 JpaToscaServiceTemplate deletedServiceTemplate = new JpaToscaServiceTemplate();
299 deletedServiceTemplate.setDataTypes(new JpaToscaDataTypes());
300 deletedServiceTemplate.getDataTypes().getConceptMap().put(dataTypeKey, dataType4Deletion);
302 LOGGER.debug("<-deleteDataType: key={}, serviceTempalate={}", dataTypeKey, deletedServiceTemplate);
303 return deletedServiceTemplate;
309 * @param dao the DAO to use to access the database
310 * @param name the name of the policy type to get, set to null to get all policy types
311 * @param version the version of the policy type to get, set to null to get all versions
312 * @return the policy types found
313 * @throws PfModelException on errors getting policy types
315 public JpaToscaServiceTemplate getPolicyTypes(@NonNull final PfDao dao, final String name, final String version)
316 throws PfModelException {
317 LOGGER.debug("->getPolicyTypes: name={}, version={}", name, version);
319 final JpaToscaServiceTemplate dbServiceTemplate = getServiceTemplate(dao);
321 if (!ToscaUtils.doPolicyTypesExist(dbServiceTemplate)) {
322 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
323 "policy types for " + name + ":" + version + DO_NOT_EXIST);
326 JpaToscaServiceTemplate serviceTemplate = getCascadedPolicyTypes(dbServiceTemplate, name, version);
328 LOGGER.debug("<-getPolicyTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
329 return serviceTemplate;
333 * Get the cascaded policy types for a policy type name and version.
335 * @param dbServiceTemplate the service template to search for the cascaded policy types
336 * @param name the policy type name we are searching for
337 * @param version the policy type version we are searching for
338 * @return a service template containing the cascaded policy types
339 * @throws PfModelException on errors getting the policy types
341 public JpaToscaServiceTemplate getCascadedPolicyTypes(final JpaToscaServiceTemplate dbServiceTemplate,
342 final String name, final String version) throws PfModelException {
344 JpaToscaServiceTemplate serviceTemplate = new JpaToscaServiceTemplate(dbServiceTemplate);
346 serviceTemplate.setDataTypes(null);
347 serviceTemplate.setTopologyTemplate(null);
349 ToscaUtils.getEntityTree(serviceTemplate.getPolicyTypes(), name, version);
351 if (!ToscaUtils.doPolicyTypesExist(serviceTemplate)) {
352 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
353 "policy types for " + name + ":" + version + DO_NOT_EXIST);
356 JpaToscaServiceTemplate dataTypeServiceTemplate = new JpaToscaServiceTemplate(serviceTemplate);
357 dataTypeServiceTemplate.setPolicyTypes(null);
359 for (JpaToscaPolicyType policyType : serviceTemplate.getPolicyTypes().getConceptMap().values()) {
360 Collection<PfConceptKey> referencedDataTypeKeys = policyType.getReferencedDataTypes();
362 for (PfConceptKey referencedDataTypeKey : referencedDataTypeKeys) {
363 JpaToscaServiceTemplate dataTypeEntityTreeServiceTemplate = getCascadedDataTypes(dbServiceTemplate,
364 referencedDataTypeKey.getName(), referencedDataTypeKey.getVersion());
366 dataTypeServiceTemplate =
367 ToscaServiceTemplateUtils.addFragment(dataTypeServiceTemplate, dataTypeEntityTreeServiceTemplate);
371 serviceTemplate = ToscaServiceTemplateUtils.addFragment(serviceTemplate, dataTypeServiceTemplate);
372 return serviceTemplate;
376 * Create policy types.
378 * @param dao the DAO to use to access the database
379 * @param incomingServiceTemplate the service template containing the definition of the policy types to be created
380 * @return the TOSCA service template containing the created policy types
381 * @throws PfModelException on errors creating policy types
383 public JpaToscaServiceTemplate createPolicyTypes(@NonNull final PfDao dao,
384 @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException {
385 LOGGER.debug("->createPolicyTypes: serviceTempalate={}", incomingServiceTemplate);
387 ToscaUtils.assertPolicyTypesExist(incomingServiceTemplate);
389 JpaToscaServiceTemplate writtenServiceTemplate = appendToServiceTemplate(dao, incomingServiceTemplate);
391 LOGGER.debug("<-createPolicyTypes: writtenServiceTemplate={}", writtenServiceTemplate);
392 return incomingServiceTemplate;
396 * Update policy types.
398 * @param dao the DAO to use to access the database
399 * @param serviceTemplate the service template containing the definition of the policy types to be modified
400 * @return the TOSCA service template containing the modified policy types
401 * @throws PfModelException on errors updating policy types
403 public JpaToscaServiceTemplate updatePolicyTypes(@NonNull final PfDao dao,
404 @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException {
405 LOGGER.debug("->updatePolicyTypes: serviceTempalate={}", serviceTemplate);
407 ToscaUtils.assertPolicyTypesExist(serviceTemplate);
409 // Update the data types on the policy type
410 if (ToscaUtils.doDataTypesExist(serviceTemplate)) {
411 updateDataTypes(dao, serviceTemplate);
414 for (JpaToscaPolicyType policyType : serviceTemplate.getPolicyTypes().getAll(null)) {
415 dao.update(policyType);
418 // Return the created policy types
419 JpaToscaPolicyTypes returnPolicyTypes = new JpaToscaPolicyTypes();
421 for (PfConceptKey policyTypeKey : serviceTemplate.getPolicyTypes().getConceptMap().keySet()) {
422 returnPolicyTypes.getConceptMap().put(policyTypeKey, dao.get(JpaToscaPolicyType.class, policyTypeKey));
425 JpaToscaServiceTemplate returnServiceTemplate = new JpaToscaServiceTemplate();
426 returnServiceTemplate.setPolicyTypes(returnPolicyTypes);
428 LOGGER.debug("<-updatePolicyTypes: returnServiceTempalate={}", returnServiceTemplate);
429 return returnServiceTemplate;
433 * Delete policy types.
435 * @param dao the DAO to use to access the database
436 * @param policyTypeKey the policy type key for the policy types to be deleted, if the version of the key is null,
437 * all versions of the policy type are deleted.
438 * @return the TOSCA service template containing the policy types that were deleted
439 * @throws PfModelException on errors deleting policy types
441 public JpaToscaServiceTemplate deletePolicyType(@NonNull final PfDao dao, @NonNull final PfConceptKey policyTypeKey)
442 throws PfModelException {
443 LOGGER.debug("->deletePolicyType: key={}", policyTypeKey);
445 JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao);
447 if (!ToscaUtils.doPolicyTypesExist(serviceTemplate)) {
448 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "no policy types found");
451 JpaToscaPolicyType policyType4Deletion = serviceTemplate.getPolicyTypes().get(policyTypeKey);
452 if (policyType4Deletion == null) {
453 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
454 POLICY_TYPE + policyTypeKey.getId() + NOT_FOUND);
457 for (JpaToscaPolicyType policyType : serviceTemplate.getPolicyTypes().getAll(null)) {
458 Collection<JpaToscaEntityType<ToscaEntity>> ancestorList = ToscaUtils
459 .getEntityTypeAncestors(serviceTemplate.getPolicyTypes(), policyType, new PfValidationResult());
461 if (ancestorList.contains(policyType4Deletion)) {
462 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, POLICY_TYPE + policyTypeKey.getId()
463 + " is in use, it is referenced in policy type " + policyType.getId());
467 if (ToscaUtils.doPoliciesExist(serviceTemplate)) {
468 for (JpaToscaPolicy policy : serviceTemplate.getTopologyTemplate().getPolicies().getAll(null)) {
469 if (policyTypeKey.equals(policy.getType())) {
470 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, POLICY_TYPE
471 + policyTypeKey.getId() + " is in use, it is referenced in policy " + policy.getId());
476 serviceTemplate.getPolicyTypes().getConceptMap().remove(policyTypeKey);
477 new SimpleToscaServiceTemplateProvider().write(dao, serviceTemplate);
478 dao.delete(policyType4Deletion);
480 JpaToscaServiceTemplate deletedServiceTemplate = new JpaToscaServiceTemplate();
481 deletedServiceTemplate.setPolicyTypes(new JpaToscaPolicyTypes());
482 deletedServiceTemplate.getPolicyTypes().getConceptMap().put(policyTypeKey, policyType4Deletion);
484 LOGGER.debug("<-deletePolicyType: key={}, serviceTempalate={}", policyTypeKey, deletedServiceTemplate);
485 return deletedServiceTemplate;
491 * @param dao the DAO to use to access the database
492 * @param name the name of the policy to get, set to null to get all policy types
493 * @param version the version of the policy to get, set to null to get all versions
494 * @return the policies found
495 * @throws PfModelException on errors getting policies
497 public JpaToscaServiceTemplate getPolicies(@NonNull final PfDao dao, final String name, final String version)
498 throws PfModelException {
499 LOGGER.debug("->getPolicies: name={}, version={}", name, version);
501 JpaToscaServiceTemplate dbServiceTemplate = getServiceTemplate(dao);
503 if (!ToscaUtils.doPoliciesExist(dbServiceTemplate)) {
504 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
505 "policies for " + name + ":" + version + DO_NOT_EXIST);
508 JpaToscaServiceTemplate returnServiceTemplate = getCascadedPolicies(dbServiceTemplate, name, version);
510 LOGGER.debug("<-getPolicies: name={}, version={}, serviceTemplate={}", name, version, returnServiceTemplate);
511 return returnServiceTemplate;
515 * Get the cascaded policies for a policy name and version.
517 * @param dbServiceTemplate the service template to search for the cascaded policy
518 * @param name the policy name we are searching for
519 * @param version the policy version we are searching for
520 * @return a service template containing the cascaded policy
521 * @throws PfModelException on errors getting the policy
523 public JpaToscaServiceTemplate getCascadedPolicies(final JpaToscaServiceTemplate dbServiceTemplate,
524 final String name, final String version) throws PfModelException {
526 JpaToscaServiceTemplate serviceTemplate = new JpaToscaServiceTemplate(dbServiceTemplate);
527 serviceTemplate.setDataTypes(new JpaToscaDataTypes());
528 serviceTemplate.setPolicyTypes(new JpaToscaPolicyTypes());
530 ToscaUtils.getEntityTree(serviceTemplate.getTopologyTemplate().getPolicies(), name, version);
532 if (!ToscaUtils.doPoliciesExist(serviceTemplate)) {
533 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
534 "policies for " + name + ":" + version + DO_NOT_EXIST);
537 JpaToscaServiceTemplate returnServiceTemplate = new JpaToscaServiceTemplate(serviceTemplate);
538 returnServiceTemplate.getTopologyTemplate().setPolicies(new JpaToscaPolicies());
540 for (JpaToscaPolicy policy : serviceTemplate.getTopologyTemplate().getPolicies().getConceptMap().values()) {
541 JpaToscaServiceTemplate referencedEntitiesServiceTemplate =
542 getCascadedPolicyTypes(dbServiceTemplate, policy.getType().getName(), policy.getType().getVersion());
544 returnServiceTemplate.getTopologyTemplate().getPolicies().getConceptMap().put(policy.getKey(), policy);
545 returnServiceTemplate =
546 ToscaServiceTemplateUtils.addFragment(returnServiceTemplate, referencedEntitiesServiceTemplate);
549 return returnServiceTemplate;
555 * @param dao the DAO to use to access the database
556 * @param incomingServiceTemplate the service template containing the definitions of the new policies to be created.
557 * @return the TOSCA service template containing the policy types that were created
558 * @throws PfModelException on errors creating policies
560 public JpaToscaServiceTemplate createPolicies(@NonNull final PfDao dao,
561 @NonNull final JpaToscaServiceTemplate incomingServiceTemplate) throws PfModelException {
562 LOGGER.debug("->createPolicies: incomingServiceTemplate={}", incomingServiceTemplate);
564 ToscaUtils.assertPoliciesExist(incomingServiceTemplate);
566 JpaToscaServiceTemplate writtenServiceTemplate = appendToServiceTemplate(dao, incomingServiceTemplate);
568 LOGGER.debug("<-createPolicies: writtenServiceTemplate={}", writtenServiceTemplate);
569 return incomingServiceTemplate;
575 * @param dao the DAO to use to access the database
576 * @param serviceTemplate the service template containing the definitions of the policies to be updated.
577 * @return the TOSCA service template containing the policies that were updated
578 * @throws PfModelException on errors updating policies
580 public JpaToscaServiceTemplate updatePolicies(@NonNull final PfDao dao,
581 @NonNull final JpaToscaServiceTemplate serviceTemplate) throws PfModelException {
582 LOGGER.debug("->updatePolicies: serviceTempalate={}", serviceTemplate);
584 ToscaUtils.assertPoliciesExist(serviceTemplate);
586 for (JpaToscaPolicy policy : serviceTemplate.getTopologyTemplate().getPolicies().getAll(null)) {
587 verifyPolicyTypeForPolicy(dao, policy);
591 // Return the created policy types
592 JpaToscaPolicies returnPolicies = new JpaToscaPolicies();
593 returnPolicies.setKey(serviceTemplate.getTopologyTemplate().getPolicies().getKey());
595 for (PfConceptKey policyKey : serviceTemplate.getTopologyTemplate().getPolicies().getConceptMap().keySet()) {
596 returnPolicies.getConceptMap().put(policyKey, dao.get(JpaToscaPolicy.class, policyKey));
599 serviceTemplate.getTopologyTemplate().setPolicies(returnPolicies);
601 LOGGER.debug("<-updatePolicies: serviceTemplate={}", serviceTemplate);
602 return serviceTemplate;
608 * @param dao the DAO to use to access the database
609 * @param policyKey the policy key
610 * @return the TOSCA service template containing the policies that were deleted
611 * @throws PfModelException on errors deleting policies
613 public JpaToscaServiceTemplate deletePolicy(@NonNull final PfDao dao, @NonNull final PfConceptKey policyKey)
614 throws PfModelException {
615 LOGGER.debug("->deletePolicy: key={}", policyKey);
617 JpaToscaServiceTemplate serviceTemplate = getServiceTemplate(dao);
619 if (!ToscaUtils.doPoliciesExist(serviceTemplate)) {
620 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "no policies found");
623 JpaToscaPolicy policy4Deletion = serviceTemplate.getTopologyTemplate().getPolicies().get(policyKey);
624 if (policy4Deletion == null) {
625 throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "policy " + policyKey.getId() + NOT_FOUND);
628 serviceTemplate.getTopologyTemplate().getPolicies().getConceptMap().remove(policyKey);
629 new SimpleToscaServiceTemplateProvider().write(dao, serviceTemplate);
630 dao.delete(policy4Deletion);
632 JpaToscaServiceTemplate deletedServiceTemplate = new JpaToscaServiceTemplate();
633 deletedServiceTemplate.setTopologyTemplate(new JpaToscaTopologyTemplate());
634 deletedServiceTemplate.getTopologyTemplate().setPolicies(new JpaToscaPolicies());
635 deletedServiceTemplate.getTopologyTemplate().getPolicies().getConceptMap().put(policyKey, policy4Deletion);
637 LOGGER.debug("<-deletePolicy: key={}, serviceTempalate={}", policyKey, deletedServiceTemplate);
638 return deletedServiceTemplate;
642 * Verify the policy type for a policy exists.
644 * @param dao the DAO to use to access policy types in the database
645 * @param policy the policy to check the policy type for
647 private void verifyPolicyTypeForPolicy(final PfDao dao, final JpaToscaPolicy policy) {
648 PfConceptKey policyTypeKey = policy.getType();
650 JpaToscaPolicyType policyType = null;
652 if (PfKey.NULL_KEY_VERSION.equals(policyTypeKey.getVersion())) {
653 policyType = getLatestPolicyTypeVersion(dao, policyTypeKey.getName());
655 if (policyType != null) {
656 policy.getType().setVersion(policyType.getKey().getVersion());
659 policyType = dao.get(JpaToscaPolicyType.class, policyTypeKey);
662 if (policyType == null) {
663 String errorMessage =
664 POLICY_TYPE + policyTypeKey.getId() + " for policy " + policy.getId() + " does not exist";
665 throw new PfModelRuntimeException(Response.Status.NOT_ACCEPTABLE, errorMessage);
670 * Get the latest version of the policy type for the given policy type name.
672 * @param dao the DAO to use to access policy types in the database
673 * @param policyTypeName the name of the policy type
674 * @return the latest policy type
676 private JpaToscaPolicyType getLatestPolicyTypeVersion(final PfDao dao, final String policyTypeName) {
677 // Policy type version is not specified, get the latest version from the database
678 List<JpaToscaPolicyType> jpaPolicyTypeList = dao.getFiltered(JpaToscaPolicyType.class, policyTypeName, null);
680 if (CollectionUtils.isEmpty(jpaPolicyTypeList)) {
684 // Create a filter to get the latest version of the policy type
685 PfConceptFilter pfConceptFilter = PfConceptFilter.builder().version(PfConceptFilter.LATEST_VERSION).build();
687 // FIlter the returned policy type list
688 List<PfConcept> policyTypeKeyList = new ArrayList<>(jpaPolicyTypeList);
689 List<PfConcept> filterdPolicyTypeList = pfConceptFilter.filter(policyTypeKeyList);
691 // We should have one and only one returned entry
692 if (filterdPolicyTypeList.size() != 1) {
693 String errorMessage = "search for latest policy type " + policyTypeName + " returned more than one entry";
694 throw new PfModelRuntimeException(Response.Status.CONFLICT, errorMessage);
697 return (JpaToscaPolicyType) filterdPolicyTypeList.get(0);