main/src/main/java/org/onap/policy/pap/main/rest/PdpGroupStateChangeProvider.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 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
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  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.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.pap.main.rest;
  22
  23 import java.util.ArrayList;
  24 import java.util.List;
  25
  26 import javax.ws.rs.core.Response;
  27
  28 import org.apache.commons.lang3.tuple.Pair;
  29 import org.onap.policy.common.utils.services.Registry;
  30 import org.onap.policy.models.base.PfModelException;
  31 import org.onap.policy.models.pap.concepts.PdpGroupStateChangeResponse;
  32 import org.onap.policy.models.pdp.concepts.Pdp;
  33 import org.onap.policy.models.pdp.concepts.PdpGroup;
  34 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
  35 import org.onap.policy.models.pdp.concepts.PdpStateChange;
  36 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  37 import org.onap.policy.models.pdp.concepts.PdpUpdate;
  38 import org.onap.policy.models.pdp.enums.PdpState;
  39 import org.onap.policy.models.provider.PolicyModelsProvider;
  40 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
  41 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
  42 import org.onap.policy.pap.main.PapConstants;
  43 import org.onap.policy.pap.main.PolicyModelsProviderFactoryWrapper;
  44 import org.onap.policy.pap.main.comm.PdpModifyRequestMap;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 /**
  49  * Provider for PAP component to change state of PDP group.
  50  *
  51  * @author Ram Krishna Verma (ram.krishna.verma@est.tech)
  52  */
  53 public class PdpGroupStateChangeProvider {
  54
  55     private static final Logger LOGGER = LoggerFactory.getLogger(PdpGroupStateChangeProvider.class);
  56
  57     PolicyModelsProviderFactoryWrapper modelProviderWrapper;
  58
  59     /**
  60      * Constructs the object.
  61      */
  62     public PdpGroupStateChangeProvider() {
  63         modelProviderWrapper = Registry.get(PapConstants.REG_PAP_DAO_FACTORY, PolicyModelsProviderFactoryWrapper.class);
  64     }
  65
  66     /**
  67      * Changes state of a PDP group.
  68      *
  69      * @param groupName name of the PDP group
  70      * @param groupVersion version of the PDP group
  71      * @param pdpGroupState state of the PDP group
  72      * @return a pair containing the status and the response
  73      * @throws PfModelException in case of errors
  74      */
  75     public Pair<Response.Status, PdpGroupStateChangeResponse> changeGroupState(final String groupName,
  76             final String groupVersion, final PdpState pdpGroupState) throws PfModelException {
  77
  78         switch (pdpGroupState) {
  79             case ACTIVE:
  80                 handleActiveState(groupName, groupVersion);
  81                 break;
  82             case PASSIVE:
  83                 handlePassiveState(groupName, groupVersion);
  84                 break;
  85             default:
  86                 throw new PfModelException(Response.Status.BAD_REQUEST,
  87                         "Only ACTIVE or PASSIVE state changes are allowed");
  88         }
  89         return Pair.of(Response.Status.OK, new PdpGroupStateChangeResponse());
  90     }
  91
  92     private void handleActiveState(final String groupName, final String groupVersion) throws PfModelException {
  93         try (PolicyModelsProvider databaseProvider = modelProviderWrapper.create()) {
  94             final PdpGroupFilter filter = PdpGroupFilter.builder().name(groupName).groupState(PdpState.ACTIVE).build();
  95             final List<PdpGroup> activePdpGroups = databaseProvider.getFilteredPdpGroups(filter);
  96             final List<PdpGroup> pdpGroups = databaseProvider.getPdpGroups(groupName, groupVersion);
  97             if (activePdpGroups.isEmpty() && !pdpGroups.isEmpty()) {
  98                 sendPdpMessage(pdpGroups.get(0), PdpState.ACTIVE, databaseProvider);
  99                 updatePdpGroupAndPdp(databaseProvider, pdpGroups, PdpState.ACTIVE);
 100             } else if (!pdpGroups.isEmpty() && !activePdpGroups.isEmpty()
 101                     && !pdpGroups.get(0).getVersion().equals(activePdpGroups.get(0).getVersion())) {
 102                 sendPdpMessage(pdpGroups.get(0), PdpState.ACTIVE, databaseProvider);
 103                 updatePdpGroupAndPdp(databaseProvider, pdpGroups, PdpState.ACTIVE);
 104                 updatePdpGroup(databaseProvider, activePdpGroups, PdpState.PASSIVE);
 105             }
 106         }
 107     }
 108
 109     private void handlePassiveState(final String groupName, final String groupVersion) throws PfModelException {
 110         try (PolicyModelsProvider databaseProvider = modelProviderWrapper.create()) {
 111             final List<PdpGroup> pdpGroups = databaseProvider.getPdpGroups(groupName, groupVersion);
 112             if (!pdpGroups.isEmpty() && !PdpState.PASSIVE.equals(pdpGroups.get(0).getPdpGroupState())) {
 113                 sendPdpMessage(pdpGroups.get(0), PdpState.PASSIVE, databaseProvider);
 114                 updatePdpGroupAndPdp(databaseProvider, pdpGroups, PdpState.PASSIVE);
 115             }
 116         }
 117     }
 118
 119     private void updatePdpGroup(final PolicyModelsProvider databaseProvider, final List<PdpGroup> pdpGroups,
 120             final PdpState pdpState) throws PfModelException {
 121         pdpGroups.get(0).setPdpGroupState(pdpState);
 122         databaseProvider.updatePdpGroups(pdpGroups);
 123
 124         LOGGER.debug("Updated PdpGroup in DB - {} ", pdpGroups);
 125     }
 126
 127     private void updatePdpGroupAndPdp(final PolicyModelsProvider databaseProvider, final List<PdpGroup> pdpGroups,
 128             final PdpState pdpState) throws PfModelException {
 129         pdpGroups.get(0).setPdpGroupState(pdpState);
 130         for (final PdpSubGroup subGroup : pdpGroups.get(0).getPdpSubgroups()) {
 131             for (final Pdp pdp : subGroup.getPdpInstances()) {
 132                 pdp.setPdpState(pdpState);
 133             }
 134         }
 135         databaseProvider.updatePdpGroups(pdpGroups);
 136
 137         LOGGER.debug("Updated PdpGroup and Pdp in DB - {} ", pdpGroups);
 138     }
 139
 140     private void sendPdpMessage(final PdpGroup pdpGroup, final PdpState pdpState,
 141             final PolicyModelsProvider databaseProvider) throws PfModelException {
 142
 143         for (final PdpSubGroup subGroup : pdpGroup.getPdpSubgroups()) {
 144             for (final Pdp pdp : subGroup.getPdpInstances()) {
 145                 final PdpUpdate pdpUpdatemessage =
 146                         createPdpUpdateMessage(pdpGroup.getName(), subGroup, pdp.getInstanceId(), databaseProvider);
 147                 final PdpStateChange pdpStateChangeMessage =
 148                         createPdpStateChangeMessage(pdpGroup.getName(), subGroup, pdp.getInstanceId(), pdpState);
 149                 final PdpModifyRequestMap requestMap =
 150                         Registry.get(PapConstants.REG_PDP_MODIFY_MAP, PdpModifyRequestMap.class);
 151                 requestMap.addRequest(pdpUpdatemessage, pdpStateChangeMessage);
 152                 LOGGER.debug("Sent PdpUpdate message - {}", pdpUpdatemessage);
 153                 LOGGER.debug("Sent PdpStateChange message - {}", pdpStateChangeMessage);
 154             }
 155         }
 156     }
 157
 158     private PdpUpdate createPdpUpdateMessage(final String pdpGroupName, final PdpSubGroup subGroup,
 159             final String pdpInstanceId, final PolicyModelsProvider databaseProvider) throws PfModelException {
 160
 161         final PdpUpdate update = new PdpUpdate();
 162         update.setName(pdpInstanceId);
 163         update.setPdpGroup(pdpGroupName);
 164         update.setPdpSubgroup(subGroup.getPdpType());
 165         update.setPolicies(getToscaPolicies(subGroup, databaseProvider));
 166
 167         LOGGER.debug("Created PdpUpdate message - {}", update);
 168         return update;
 169     }
 170
 171     private List<ToscaPolicy> getToscaPolicies(final PdpSubGroup subGroup, final PolicyModelsProvider databaseProvider)
 172             throws PfModelException {
 173         final List<ToscaPolicy> policies = new ArrayList<>();
 174         for (final ToscaPolicyIdentifier policyIdentifier : subGroup.getPolicies()) {
 175             policies.addAll(databaseProvider.getPolicyList(policyIdentifier.getName(), policyIdentifier.getVersion()));
 176         }
 177         LOGGER.debug("Created ToscaPolicy list - {}", policies);
 178         return policies;
 179     }
 180
 181     private PdpStateChange createPdpStateChangeMessage(final String pdpGroupName, final PdpSubGroup subGroup,
 182             final String pdpInstanceId, final PdpState pdpState) {
 183
 184         final PdpStateChange stateChange = new PdpStateChange();
 185         stateChange.setName(pdpInstanceId);
 186         stateChange.setPdpGroup(pdpGroupName);
 187         stateChange.setPdpSubgroup(subGroup.getPdpType());
 188         stateChange.setState(pdpState);
 189         LOGGER.debug("Created PdpStateChange message - {}", stateChange);
 190         return stateChange;
 191     }
 192 }