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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019-2020 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
   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 java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.List;
  27 import java.util.Map;
  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.ToscaPolicy;
  38 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyFilter;
  39 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
  40 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeFilter;
  41 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  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;
  47
  48 /**
  49  * This class provides the provision of information on TOSCA concepts in the database to callers.
  50  *
  51  * @author Liam Fallon (liam.fallon@est.tech)
  52  */
  53 public class AuthorativeToscaProvider {
  54     private static final Logger LOGGER = LoggerFactory.getLogger(AuthorativeToscaProvider.class);
  55
  56     // TODO: In next release this locking mechanism should be removed and replaced with proper session handling
  57     private static final Object providerLockObject = "providerLockObject";
  58
  59     /**
  60      * Get a service template.
  61      *
  62      * @param dao the DAO to use to access the database
  63      * @param name the name of the control loop to get.
  64      * @param version the version of the control loop to get.
  65      * @return the control loops found
  66      * @throws PfModelException on errors getting control loops
  67      */
  68     public ToscaServiceTemplate getServiceTemplate(@NonNull final PfDao dao, final String name, final String version)
  69         throws PfModelException {
  70
  71         synchronized (providerLockObject) {
  72             LOGGER.debug("->getServiceTemplate: name={}, version={}", name, version);
  73
  74             ToscaServiceTemplate gotServiceTemplate = new SimpleToscaProvider().getServiceTemplate(dao).toAuthorative();
  75
  76             LOGGER.debug("<-getServiceTemplate: name={}, version={}, gotServiceTemplate={}", name, version,
  77                 gotServiceTemplate);
  78             return gotServiceTemplate;
  79         }
  80     }
  81
  82     /**
  83      * Create a service template.
  84      *
  85      * @param dao the DAO to use to access the database
  86      * @param serviceTemplate the service template to be created.
  87      * @return the TOSCA service template that was created
  88      * @throws PfModelException on errors creating the service template
  89      */
  90     public ToscaServiceTemplate createServiceTemplate(@NonNull final PfDao dao,
  91         @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
  92
  93         synchronized (providerLockObject) {
  94             LOGGER.debug("->createServiceTemplate: serviceTemplate={}", serviceTemplate);
  95
  96             ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
  97                 .appendToServiceTemplate(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
  98
  99             LOGGER.debug("<-createServiceTemplate: createdServiceTemplate={}", createdServiceTemplate);
 100             return createdServiceTemplate;
 101         }
 102     }
 103
 104     /**
 105      * Delete a service template.
 106      *
 107      * @param dao the DAO to use to access the database
 108      * @param name the name of the service template to delete.
 109      * @param version the version of the service template to delete.
 110      * @return the TOSCA service template that was deleted
 111      * @throws PfModelException on errors deleting the control loop
 112      */
 113     public ToscaServiceTemplate deleteServiceTemplate(@NonNull final PfDao dao, @NonNull final String name,
 114         @NonNull final String version) throws PfModelException {
 115
 116         synchronized (providerLockObject) {
 117             LOGGER.debug("->deleteServiceTemplate: name={}, version={}", name, version);
 118
 119             ToscaServiceTemplate deletedServiceTemplate =
 120                 new SimpleToscaProvider().deleteServiceTemplate(dao).toAuthorative();
 121
 122             LOGGER.debug("<-deleteServiceTemplate: name={}, version={}, deletedServiceTemplate={}", name, version,
 123                 deletedServiceTemplate);
 124             return deletedServiceTemplate;
 125         }
 126     }
 127
 128     /**
 129      * Get policy types.
 130      *
 131      * @param dao the DAO to use to access the database
 132      * @param name the name of the policy type to get.
 133      * @param version the version of the policy type to get.
 134      * @return the policy types found
 135      * @throws PfModelException on errors getting policy types
 136      */
 137     public ToscaServiceTemplate getPolicyTypes(@NonNull final PfDao dao, final String name, final String version)
 138         throws PfModelException {
 139
 140         synchronized (providerLockObject) {
 141             LOGGER.debug("->getPolicyTypes: name={}, version={}", name, version);
 142
 143             JpaToscaServiceTemplate jpaServiceTemplate = new SimpleToscaProvider().getPolicyTypes(dao, name, version);
 144
 145             ToscaServiceTemplate serviceTemplate = jpaServiceTemplate.toAuthorative();
 146
 147             LOGGER.debug("<-getPolicyTypes: name={}, version={}, serviceTemplate={}", name, version, serviceTemplate);
 148             return serviceTemplate;
 149         }
 150     }
 151
 152     /**
 153      * Get policy types.
 154      *
 155      * @param dao the DAO to use to access the database
 156      * @param name the name of the policy type to get, set to null to get all policy types
 157      * @param version the version of the policy type to get, set to null to get all versions
 158      * @return the policy types found
 159      * @throws PfModelException on errors getting policy types
 160      */
 161     public List<ToscaPolicyType> getPolicyTypeList(@NonNull final PfDao dao, final String name, final String version)
 162         throws PfModelException {
 163
 164         synchronized (providerLockObject) {
 165             LOGGER.debug("->getPolicyTypeList: name={}, version={}", name, version);
 166
 167             List<ToscaPolicyType> policyTypeList;
 168
 169             try {
 170                 policyTypeList = new ArrayList<>(new SimpleToscaProvider().getPolicyTypes(dao, name, version)
 171                     .toAuthorative().getPolicyTypes().values());
 172             } catch (PfModelRuntimeException pfme) {
 173                 return handlePfModelRuntimeException(pfme);
 174             }
 175
 176             LOGGER.debug("<-getPolicyTypeList: name={}, version={}, policyTypeList={}", name, version, policyTypeList);
 177             return policyTypeList;
 178         }
 179     }
 180
 181     /**
 182      * Get filtered policy types.
 183      *
 184      * @param dao the DAO to use to access the database
 185      * @param filter the filter for the policy types to get
 186      * @return the policy types found
 187      * @throws PfModelException on errors getting policy types
 188      */
 189     public ToscaServiceTemplate getFilteredPolicyTypes(@NonNull final PfDao dao,
 190         @NonNull final ToscaPolicyTypeFilter filter) throws PfModelException {
 191
 192         synchronized (providerLockObject) {
 193             LOGGER.debug("->getFilteredPolicyTypes: filter={}", filter);
 194             SimpleToscaProvider simpleToscaProvider = new SimpleToscaProvider();
 195
 196             final JpaToscaServiceTemplate dbServiceTemplate = simpleToscaProvider.getPolicyTypes(dao, null, null);
 197
 198             List<ToscaPolicyType> filteredPolicyTypes = dbServiceTemplate.getPolicyTypes().toAuthorativeList();
 199             filteredPolicyTypes = filter.filter(filteredPolicyTypes);
 200
 201             if (CollectionUtils.isEmpty(filteredPolicyTypes)) {
 202                 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
 203                     "policy types for filter " + filter.toString() + " do not exist");
 204             }
 205
 206             JpaToscaServiceTemplate filteredServiceTemplate = new JpaToscaServiceTemplate();
 207
 208             for (ToscaPolicyType policyType : filteredPolicyTypes) {
 209                 JpaToscaServiceTemplate cascadedServiceTemplate = simpleToscaProvider
 210                     .getCascadedPolicyTypes(dbServiceTemplate, policyType.getName(), policyType.getVersion());
 211
 212                 filteredServiceTemplate =
 213                     ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
 214             }
 215
 216             ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
 217
 218             LOGGER.debug("<-getFilteredPolicyTypes: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
 219             return returnServiceTemplate;
 220         }
 221     }
 222
 223     /**
 224      * Get filtered policy types.
 225      *
 226      * @param dao the DAO to use to access the database
 227      * @param filter the filter for the policy types to get
 228      * @return the policy types found
 229      * @throws PfModelException on errors getting policy types
 230      */
 231     public List<ToscaPolicyType> getFilteredPolicyTypeList(@NonNull final PfDao dao,
 232         @NonNull final ToscaPolicyTypeFilter filter) throws PfModelException {
 233
 234         LOGGER.debug("->getFilteredPolicyTypeList: filter={}", filter);
 235
 236         List<ToscaPolicyType> filteredPolicyTypeList = filter.filter(getPolicyTypeList(dao, null, null));
 237
 238         LOGGER.debug("<-getFilteredPolicyTypeList: filter={}, filteredPolicyTypeList={}", filter,
 239             filteredPolicyTypeList);
 240
 241         return filteredPolicyTypeList;
 242     }
 243
 244     /**
 245      * Create policy types.
 246      *
 247      * @param dao the DAO to use to access the database
 248      * @param serviceTemplate the service template containing the definition of the policy types to be created
 249      * @return the TOSCA service template containing the created policy types
 250      * @throws PfModelException on errors creating policy types
 251      */
 252     public ToscaServiceTemplate createPolicyTypes(@NonNull final PfDao dao,
 253         @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 254
 255         synchronized (providerLockObject) {
 256             LOGGER.debug("->createPolicyTypes: serviceTemplate={}", serviceTemplate);
 257
 258             ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
 259                 .createPolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 260
 261             LOGGER.debug("<-createPolicyTypes: createdServiceTemplate={}", createdServiceTemplate);
 262             return createdServiceTemplate;
 263         }
 264     }
 265
 266     /**
 267      * Update policy types.
 268      *
 269      * @param dao the DAO to use to access the database
 270      * @param serviceTemplate the service template containing the definition of the policy types to be modified
 271      * @return the TOSCA service template containing the modified policy types
 272      * @throws PfModelException on errors updating policy types
 273      */
 274     public ToscaServiceTemplate updatePolicyTypes(@NonNull final PfDao dao,
 275         @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 276
 277         synchronized (providerLockObject) {
 278             LOGGER.debug("->updatePolicyTypes: serviceTemplate={}", serviceTemplate);
 279
 280             ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
 281                 .updatePolicyTypes(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 282
 283             LOGGER.debug("<-updatePolicyTypes: updatedServiceTemplate={}", updatedServiceTemplate);
 284             return updatedServiceTemplate;
 285         }
 286     }
 287
 288     /**
 289      * Delete policy type.
 290      *
 291      * @param dao the DAO to use to access the database
 292      * @param name the name of the policy type to delete.
 293      * @param version the version of the policy type to delete.
 294      * @return the TOSCA service template containing the policy type that was deleted
 295      * @throws PfModelException on errors deleting policy types
 296      */
 297     public ToscaServiceTemplate deletePolicyType(@NonNull final PfDao dao, @NonNull final String name,
 298         @NonNull final String version) throws PfModelException {
 299
 300         synchronized (providerLockObject) {
 301             LOGGER.debug("->deletePolicyType: name={}, version={}", name, version);
 302
 303             ToscaServiceTemplate deletedServiceTemplate =
 304                 new SimpleToscaProvider().deletePolicyType(dao, new PfConceptKey(name, version)).toAuthorative();
 305
 306             LOGGER.debug("<-deletePolicyType: name={}, version={}, deletedServiceTemplate={}", name, version,
 307                 deletedServiceTemplate);
 308             return deletedServiceTemplate;
 309         }
 310     }
 311
 312     /**
 313      * Get policies.
 314      *
 315      * @param dao the DAO to use to access the database
 316      * @param name the name of the policy to get.
 317      * @param version the version of the policy to get.
 318      * @return the policies found
 319      * @throws PfModelException on errors getting policies
 320      */
 321     public ToscaServiceTemplate getPolicies(@NonNull final PfDao dao, final String name, final String version)
 322         throws PfModelException {
 323
 324         synchronized (providerLockObject) {
 325             LOGGER.debug("->getPolicies: name={}, version={}", name, version);
 326
 327             ToscaServiceTemplate gotServiceTemplate =
 328                 new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative();
 329
 330             LOGGER.debug("<-getPolicies: name={}, version={}, gotServiceTemplate={}", name, version,
 331                 gotServiceTemplate);
 332             return gotServiceTemplate;
 333         }
 334     }
 335
 336     /**
 337      * Get policies.
 338      *
 339      * @param dao the DAO to use to access the database
 340      * @param name the name of the policy to get, null to get all policies
 341      * @param version the version of the policy to get, null to get all versions of a policy
 342      * @return the policies found
 343      * @throws PfModelException on errors getting policies
 344      */
 345     public List<ToscaPolicy> getPolicyList(@NonNull final PfDao dao, final String name, final String version)
 346         throws PfModelException {
 347
 348         synchronized (providerLockObject) {
 349             LOGGER.debug("->getPolicyList: name={}, version={}", name, version);
 350
 351             List<ToscaPolicy> policyList;
 352
 353             try {
 354                 policyList = asConceptList(new SimpleToscaProvider().getPolicies(dao, name, version).toAuthorative()
 355                     .getToscaTopologyTemplate().getPolicies());
 356             } catch (PfModelRuntimeException pfme) {
 357                 return handlePfModelRuntimeException(pfme);
 358             }
 359
 360             LOGGER.debug("<-getPolicyList: name={}, version={}, policyList={}", name, version, policyList);
 361             return policyList;
 362         }
 363     }
 364
 365     /**
 366      * Get filtered policies.
 367      *
 368      * @param dao the DAO to use to access the database
 369      * @param filter the filter for the policies to get
 370      * @return the policies found
 371      * @throws PfModelException on errors getting policies
 372      */
 373     public ToscaServiceTemplate getFilteredPolicies(@NonNull final PfDao dao, @NonNull final ToscaPolicyFilter filter)
 374         throws PfModelException {
 375
 376         synchronized (providerLockObject) {
 377             LOGGER.debug("->getFilteredPolicies: filter={}", filter);
 378             String version = ToscaPolicyFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
 379
 380             SimpleToscaProvider simpleToscaProvider = new SimpleToscaProvider();
 381             final JpaToscaServiceTemplate dbServiceTemplate =
 382                 simpleToscaProvider.getPolicies(dao, filter.getName(), version);
 383
 384             List<ToscaPolicy> filteredPolicies =
 385                 dbServiceTemplate.getTopologyTemplate().getPolicies().toAuthorativeList();
 386             filteredPolicies = filter.filter(filteredPolicies);
 387
 388             if (CollectionUtils.isEmpty(filteredPolicies)) {
 389                 throw new PfModelRuntimeException(Response.Status.NOT_FOUND,
 390                     "policies for filter " + filter.toString() + " do not exist");
 391             }
 392
 393             JpaToscaServiceTemplate filteredServiceTemplate = new JpaToscaServiceTemplate();
 394
 395             for (ToscaPolicy policy : filteredPolicies) {
 396                 JpaToscaServiceTemplate cascadedServiceTemplate =
 397                     simpleToscaProvider.getCascadedPolicies(dbServiceTemplate, policy.getName(), policy.getVersion());
 398
 399                 filteredServiceTemplate =
 400                     ToscaServiceTemplateUtils.addFragment(filteredServiceTemplate, cascadedServiceTemplate);
 401             }
 402
 403             ToscaServiceTemplate returnServiceTemplate = filteredServiceTemplate.toAuthorative();
 404
 405             LOGGER.debug("<-getFilteredPolicies: filter={}, serviceTemplate={}", filter, returnServiceTemplate);
 406             return returnServiceTemplate;
 407         }
 408     }
 409
 410     /**
 411      * Get filtered policies.
 412      *
 413      * @param dao the DAO to use to access the database
 414      * @param filter the filter for the policies to get
 415      * @return the policies found
 416      * @throws PfModelException on errors getting policies
 417      */
 418     public List<ToscaPolicy> getFilteredPolicyList(@NonNull final PfDao dao, @NonNull final ToscaPolicyFilter filter)
 419         throws PfModelException {
 420
 421         LOGGER.debug("->getFilteredPolicyList: filter={}", filter);
 422         String version = ToscaPolicyFilter.LATEST_VERSION.equals(filter.getVersion()) ? null : filter.getVersion();
 423
 424         List<ToscaPolicy> policyList = filter.filter(getPolicyList(dao, filter.getName(), version));
 425
 426         LOGGER.debug("<-getFilteredPolicyList: filter={}, policyList={}", filter, policyList);
 427         return policyList;
 428     }
 429
 430     /**
 431      * Create policies.
 432      *
 433      * @param dao the DAO to use to access the database
 434      * @param serviceTemplate the service template containing the definitions of the new policies to be created.
 435      * @return the TOSCA service template containing the policy types that were created
 436      * @throws PfModelException on errors creating policies
 437      */
 438     public ToscaServiceTemplate createPolicies(@NonNull final PfDao dao,
 439         @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 440
 441         synchronized (providerLockObject) {
 442             LOGGER.debug("->createPolicies: serviceTemplate={}", serviceTemplate);
 443
 444             ToscaServiceTemplate createdServiceTemplate = new SimpleToscaProvider()
 445                 .createPolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 446
 447             LOGGER.debug("<-createPolicies: createdServiceTemplate={}", createdServiceTemplate);
 448             return createdServiceTemplate;
 449         }
 450     }
 451
 452     /**
 453      * Update policies.
 454      *
 455      * @param dao the DAO to use to access the database
 456      * @param serviceTemplate the service template containing the definitions of the policies to be updated.
 457      * @return the TOSCA service template containing the policies that were updated
 458      * @throws PfModelException on errors updating policies
 459      */
 460     public ToscaServiceTemplate updatePolicies(@NonNull final PfDao dao,
 461         @NonNull final ToscaServiceTemplate serviceTemplate) throws PfModelException {
 462
 463         synchronized (providerLockObject) {
 464             LOGGER.debug("->updatePolicies: serviceTemplate={}", serviceTemplate);
 465
 466             ToscaServiceTemplate updatedServiceTemplate = new SimpleToscaProvider()
 467                 .updatePolicies(dao, new JpaToscaServiceTemplate(serviceTemplate)).toAuthorative();
 468
 469             LOGGER.debug("<-updatePolicies: updatedServiceTemplate={}", updatedServiceTemplate);
 470             return updatedServiceTemplate;
 471         }
 472     }
 473
 474     /**
 475      * Delete policy.
 476      *
 477      * @param dao the DAO to use to access the database
 478      * @param name the name of the policy to delete.
 479      * @param version the version of the policy to delete.
 480      * @return the TOSCA service template containing the policy that was deleted
 481      * @throws PfModelException on errors deleting policies
 482      */
 483     public ToscaServiceTemplate deletePolicy(@NonNull final PfDao dao, @NonNull final String name,
 484         @NonNull final String version) throws PfModelException {
 485
 486         synchronized (providerLockObject) {
 487             LOGGER.debug("->deletePolicy: name={}, version={}", name, version);
 488
 489             ToscaServiceTemplate deletedServiceTemplate =
 490                 new SimpleToscaProvider().deletePolicy(dao, new PfConceptKey(name, version)).toAuthorative();
 491
 492             LOGGER.debug("<-deletePolicy: name={}, version={}, deletedServiceTemplate={}", name, version,
 493                 deletedServiceTemplate);
 494             return deletedServiceTemplate;
 495         }
 496     }
 497
 498     /**
 499      * Return the contents of a list of maps as a plain list.
 500      *
 501      * @param listOfMaps the list of maps
 502      * @return the plain list
 503      */
 504     private <T> List<T> asConceptList(final List<Map<String, T>> listOfMaps) {
 505         List<T> returnList = new ArrayList<>();
 506         for (Map<String, T> conceptMap : listOfMaps) {
 507             for (T concept : conceptMap.values()) {
 508                 returnList.add(concept);
 509             }
 510         }
 511
 512         return returnList;
 513     }
 514
 515     /**
 516      * Handle a PfModelRuntimeException on a list call.
 517      *
 518      * @param pfme the model exception
 519      * @return an empty list on 404
 520      */
 521     private <T extends ToscaEntity> List<T> handlePfModelRuntimeException(final PfModelRuntimeException pfme) {
 522         if (Status.NOT_FOUND.equals(pfme.getErrorResponse().getResponseCode())) {
 523             LOGGER.trace("request did not find any results", pfme);
 524             return Collections.emptyList();
 525         } else {
 526             throw pfme;
 527         }
 528     }
 529 }