src/main/java/org/onap/clamp/clds/client/PolicyClient.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP CLAMP
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights
   6  *                             reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END============================================
  20  * ===================================================================
  21  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  22  */
  23
  24 package org.onap.clamp.clds.client;
  25
  26 import com.att.eelf.configuration.EELFLogger;
  27 import com.att.eelf.configuration.EELFManager;
  28
  29 import java.io.IOException;
  30 import java.util.ArrayList;
  31 import java.util.Collection;
  32 import java.util.Collections;
  33 import java.util.Date;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.UUID;
  37
  38 import javax.ws.rs.BadRequestException;
  39
  40 import org.onap.clamp.clds.exception.policy.PolicyClientException;
  41 import org.onap.clamp.clds.model.prop.ModelProperties;
  42 import org.onap.clamp.clds.model.refprop.RefProp;
  43 import org.onap.clamp.clds.util.LoggingUtils;
  44 import org.onap.policy.api.AttributeType;
  45 import org.onap.policy.api.ConfigRequestParameters;
  46 import org.onap.policy.api.DeletePolicyCondition;
  47 import org.onap.policy.api.DeletePolicyParameters;
  48 import org.onap.policy.api.PolicyChangeResponse;
  49 import org.onap.policy.api.PolicyConfig;
  50 import org.onap.policy.api.PolicyConfigException;
  51 import org.onap.policy.api.PolicyConfigType;
  52 import org.onap.policy.api.PolicyEngine;
  53 import org.onap.policy.api.PolicyEngineException;
  54 import org.onap.policy.api.PolicyParameters;
  55 import org.onap.policy.api.PolicyType;
  56 import org.onap.policy.api.PushPolicyParameters;
  57 import org.springframework.beans.factory.annotation.Autowired;
  58 import org.springframework.beans.factory.annotation.Value;
  59 import org.springframework.context.ApplicationContext;
  60
  61 /**
  62  * Policy utility methods - specifically, send the policy.
  63  */
  64 public class PolicyClient {
  65
  66     protected static final String     POLICY_PREFIX_BASE         = "Config_";
  67     protected static final String     POLICY_PREFIX_BRMS_PARAM   = "Config_BRMS_Param_";
  68     protected static final String     POLICY_PREFIX_MICROSERVICE = "Config_MS_";
  69
  70     protected static final String     LOG_POLICY_PREFIX          = "Response is ";
  71
  72     protected static final EELFLogger logger                     = EELFManager.getInstance()
  73             .getLogger(PolicyClient.class);
  74     protected static final EELFLogger metricsLogger              = EELFManager.getInstance().getMetricsLogger();
  75
  76     @Value("${org.onap.clamp.config.files.cldsPolicyConfig:'classpath:/clds/clds-policy-config.properties'}")
  77     protected String                  cldsPolicyConfigFile;
  78
  79     @Autowired
  80     protected ApplicationContext      appContext;
  81
  82     @Autowired
  83     protected RefProp                 refProp;
  84
  85     /**
  86      * Perform BRMS policy type.
  87      *
  88      * @param attributes
  89      *            A map of attributes
  90      * @param prop
  91      *            The ModelProperties
  92      * @param policyRequestUuid
  93      *            PolicyRequest UUID
  94      * @return The response message of policy
  95      *
  96      */
  97     public String sendBrmsPolicy(Map<AttributeType, Map<String, String>> attributes, ModelProperties prop,
  98             String policyRequestUuid) {
  99
 100         PolicyParameters policyParameters = new PolicyParameters();
 101
 102         // Set Policy Type(Mandatory)
 103         policyParameters.setPolicyConfigType(PolicyConfigType.BRMS_PARAM);
 104
 105         // Set Policy Name(Mandatory)
 106         policyParameters.setPolicyName(prop.getPolicyScopeAndNameWithUniqueId());
 107
 108         // documentation says this is options, but when tested, got the
 109         // following failure: java.lang.Exception: Policy send failed: PE300 -
 110         // Data Issue: No policyDescription given.
 111         policyParameters.setPolicyDescription(refProp.getStringValue("op.policyDescription"));
 112
 113         policyParameters.setAttributes(attributes);
 114
 115         // Set a random UUID(Mandatory)
 116         policyParameters.setRequestID(UUID.fromString(policyRequestUuid));
 117         String policyNamePrefix = refProp.getStringValue("policy.op.policyNamePrefix");
 118         String rtnMsg = send(policyParameters, prop, policyNamePrefix);
 119
 120         String policyType = refProp.getStringValue("policy.op.type");
 121         push(policyType, prop);
 122
 123         return rtnMsg;
 124     }
 125
 126     /**
 127      * Perform send of microservice policy in JSON.
 128      *
 129      * @param policyJson
 130      *            The policy JSON
 131      * @param prop
 132      *            The ModelProperties
 133      * @param policyRequestUuid
 134      *            The policy Request UUID
 135      * @return The response message of policy
 136      */
 137     public String sendMicroServiceInJson(String policyJson, ModelProperties prop, String policyRequestUuid) {
 138
 139         PolicyParameters policyParameters = new PolicyParameters();
 140
 141         // Set Policy Type
 142         policyParameters.setPolicyConfigType(PolicyConfigType.MicroService);
 143         policyParameters.setEcompName(refProp.getStringValue("policy.onap.name"));
 144         policyParameters.setPolicyName(prop.getCurrentPolicyScopeAndPolicyName());
 145
 146         policyParameters.setConfigBody(policyJson);
 147         policyParameters.setConfigBodyType(PolicyType.JSON);
 148
 149         policyParameters.setRequestID(UUID.fromString(policyRequestUuid));
 150         String policyNamePrefix = refProp.getStringValue("policy.ms.policyNamePrefix");
 151
 152         // Adding this line to clear the policy id from policy name while
 153         // pushing to policy engine
 154         prop.setPolicyUniqueId("");
 155
 156         String rtnMsg = send(policyParameters, prop, policyNamePrefix);
 157         String policyType = refProp.getStringValue("policy.ms.type");
 158         push(policyType, prop);
 159
 160         return rtnMsg;
 161     }
 162
 163     /**
 164      * Perform send of base policy in OTHER type.
 165      *
 166      * @param configBody
 167      *            The config policy string body
 168      * @param configPolicyName
 169      *            The config policy name of the component that has been pre-deployed in DCAE
 170      * @param prop
 171      *            The ModelProperties
 172      * @param policyRequestUuid
 173      *            The policy request UUID
 174      * @return The answer from policy call
 175      */
 176     public String sendBasePolicyInOther(String configBody, String configPolicyName, ModelProperties prop, String policyRequestUuid) {
 177
 178         PolicyParameters policyParameters = new PolicyParameters();
 179
 180         // Set Policy Type
 181         policyParameters.setPolicyConfigType(PolicyConfigType.Base);
 182         policyParameters.setEcompName(refProp.getStringValue("policy.onap.name"));
 183         policyParameters.setPolicyName(prop.getCurrentPolicyScopeAndPolicyName());
 184
 185         policyParameters.setConfigBody(configBody);
 186         policyParameters.setConfigBodyType(PolicyType.OTHER);
 187         policyParameters.setConfigName("HolmesPolicy");
 188         policyParameters.setPolicyName(configPolicyName);
 189
 190         policyParameters.setRequestID(UUID.fromString(policyRequestUuid));
 191
 192         // Adding this line to clear the policy id from policy name while
 193         // pushing to policy engine
 194         prop.setPolicyUniqueId("");
 195
 196         String rtnMsg = send(policyParameters, prop, POLICY_PREFIX_BASE);
 197         push(PolicyConfigType.Base.toString(), prop);
 198
 199         return rtnMsg;
 200     }
 201
 202     /**
 203      * Perform send of Microservice policy in OTHER type.
 204      *
 205      * @param configBody
 206      *            The config policy string body
 207      * @param prop
 208      *            The ModelProperties
 209      * @param policyRequestUuid
 210      *            The policy request UUID
 211      * @return The answer from policy call
 212      */
 213     public String sendMicroServiceInOther(String configBody, ModelProperties prop, String policyRequestUuid) {
 214
 215         PolicyParameters policyParameters = new PolicyParameters();
 216
 217         // Set Policy Type
 218         policyParameters.setPolicyConfigType(PolicyConfigType.MicroService);
 219         policyParameters.setEcompName(refProp.getStringValue("policy.onap.name"));
 220         policyParameters.setPolicyName(prop.getCurrentPolicyScopeAndPolicyName());
 221
 222         policyParameters.setConfigBody(configBody);
 223         policyParameters.setConfigBodyType(PolicyType.OTHER);
 224
 225         policyParameters.setRequestID(UUID.fromString(policyRequestUuid));
 226         String policyNamePrefix = refProp.getStringValue("policy.ms.policyNamePrefix");
 227
 228         // Adding this line to clear the policy id from policy name while
 229         // pushing to policy engine
 230         prop.setPolicyUniqueId("");
 231
 232         String rtnMsg = send(policyParameters, prop, policyNamePrefix);
 233         String policyType = refProp.getStringValue("policy.ms.type");
 234         push(policyType, prop);
 235
 236         return rtnMsg;
 237     }
 238
 239     /**
 240      * Perform send of policy.
 241      *
 242      * @param policyParameters
 243      *            The PolicyParameters
 244      * @param prop
 245      *            The ModelProperties
 246      * @return The response message of Policy
 247      */
 248     protected String send(PolicyParameters policyParameters, ModelProperties prop, String policyNamePrefix) {
 249         // Verify whether it is triggered by Validation Test button from UI
 250         if (prop.isTest()) {
 251             return "send not executed for test action";
 252         }
 253
 254         // API method to create or update Policy.
 255         PolicyChangeResponse response = null;
 256         String responseMessage = "";
 257         Date startTime = new Date();
 258         try {
 259             List<Integer> versions = getVersions(policyNamePrefix, prop);
 260             if (versions.isEmpty()) {
 261                 LoggingUtils.setTargetContext("Policy", "createPolicy");
 262                 logger.info("Attempting to create policy for action=" + prop.getActionCd());
 263                 response = getPolicyEngine().createPolicy(policyParameters);
 264                 responseMessage = response.getResponseMessage();
 265             } else {
 266                 LoggingUtils.setTargetContext("Policy", "updatePolicy");
 267                 logger.info("Attempting to update policy for action=" + prop.getActionCd());
 268                 response = getPolicyEngine().updatePolicy(policyParameters);
 269                 responseMessage = response.getResponseMessage();
 270             }
 271         } catch (Exception e) {
 272             logger.error("Exception occurred during policy communication", e);
 273             throw new PolicyClientException("Exception while communicating with Policy", e);
 274         }
 275         logger.info(LOG_POLICY_PREFIX + responseMessage);
 276
 277         LoggingUtils.setTimeContext(startTime, new Date());
 278
 279         if (response.getResponseCode() == 200) {
 280             logger.info("Policy send successful");
 281             metricsLogger.info("Policy send success");
 282         } else {
 283             logger.warn("Policy send failed: " + responseMessage);
 284             metricsLogger.info("Policy send failure");
 285             throw new BadRequestException("Policy send failed: " + responseMessage);
 286         }
 287
 288         return responseMessage;
 289     }
 290
 291     /**
 292      * Format and send push of policy.
 293      *
 294      * @param policyType
 295      *            The policy Type
 296      * @param prop
 297      *            The ModelProperties
 298      * @return The response message of policy
 299      */
 300     protected String push(String policyType, ModelProperties prop) {
 301         // Verify whether it is triggered by Validation Test button from UI
 302         if (prop.isTest()) {
 303             return "push not executed for test action";
 304         }
 305
 306         PushPolicyParameters pushPolicyParameters = new PushPolicyParameters();
 307
 308         // Parameter arguments
 309         if (prop.getPolicyUniqueId() != null && !prop.getPolicyUniqueId().isEmpty()) {
 310             pushPolicyParameters.setPolicyName(prop.getPolicyScopeAndNameWithUniqueId());
 311         } else {
 312             pushPolicyParameters.setPolicyName(prop.getCurrentPolicyScopeAndPolicyName());
 313         }
 314         logger.info("Policy Name in Push policy method - " + pushPolicyParameters.getPolicyName());
 315
 316         pushPolicyParameters.setPolicyType(policyType);
 317         pushPolicyParameters.setPdpGroup(refProp.getStringValue("policy.pdp.group"));
 318         pushPolicyParameters.setRequestID(null);
 319
 320         // API method to create or update Policy.
 321         PolicyChangeResponse response = null;
 322         String responseMessage = "";
 323         try {
 324             logger.info("Attempting to push policy...");
 325             response = getPolicyEngine().pushPolicy(pushPolicyParameters);
 326             responseMessage = response.getResponseMessage();
 327         } catch (Exception e) {
 328             logger.error("Exception occurred during policy communication", e);
 329         }
 330         logger.info(LOG_POLICY_PREFIX + responseMessage);
 331
 332         if (response != null && (response.getResponseCode() == 200 || response.getResponseCode() == 204)) {
 333             logger.info("Policy push successful");
 334         } else {
 335             logger.warn("Policy push failed: " + responseMessage);
 336             throw new BadRequestException("Policy push failed: " + responseMessage);
 337         }
 338
 339         return responseMessage;
 340     }
 341
 342     /**
 343      * Use Get Config Policy API to retrieve the versions for a policy. Return
 344      * versions in sorted order. Return empty list if none found.
 345      *
 346      * @param policyNamePrefix
 347      *            The Policy Name Prefix
 348      * @param prop
 349      *            The ModelProperties
 350      * @return The response message from policy
 351      * @throws PolicyConfigException
 352      *             In case of issues with policy engine
 353      */
 354     protected List<Integer> getVersions(String policyNamePrefix, ModelProperties prop) throws PolicyConfigException {
 355
 356         ArrayList<Integer> versions = new ArrayList<>();
 357         ConfigRequestParameters configRequestParameters = new ConfigRequestParameters();
 358         String policyName = "";
 359
 360         if (prop.getPolicyUniqueId() != null && !prop.getPolicyUniqueId().isEmpty()) {
 361             policyName = prop.getCurrentPolicyScopeAndFullPolicyName(policyNamePrefix) + "_" + prop.getPolicyUniqueId();
 362         } else {
 363             policyName = prop.getCurrentPolicyScopeAndFullPolicyName(policyNamePrefix);
 364         }
 365
 366         logger.info("policyName=" + policyName);
 367         configRequestParameters.setPolicyName(policyName);
 368
 369         Collection<PolicyConfig> response = getPolicyEngine().getConfig(configRequestParameters);
 370         for (PolicyConfig policyConfig : response) {
 371             Integer version = Integer.valueOf(policyConfig.getPolicyVersion());
 372             versions.add(version);
 373         }
 374         Collections.sort(versions);
 375         logger.info("Policy versions.size()=" + versions.size());
 376
 377         return versions;
 378
 379     }
 380
 381     /**
 382      * This method create a new policy engine.
 383      *
 384      * @return A new policy engine
 385      */
 386     private PolicyEngine getPolicyEngine() {
 387         PolicyEngine policyEngine;
 388         try {
 389             policyEngine = new PolicyEngine(appContext.getResource(cldsPolicyConfigFile).getFile().getAbsolutePath());
 390         } catch (IOException e1) {
 391             throw new PolicyClientException("Exception when opening policy config file", e1);
 392         } catch (PolicyEngineException e) {
 393             throw new PolicyClientException("Exception when creating a new policy engine", e);
 394         }
 395         return policyEngine;
 396     }
 397
 398     /**
 399      * Format and send delete Micro Service requests to Policy.
 400      *
 401      * @param prop
 402      *            The ModelProperties
 403      * @return The response message from Policy
 404      */
 405     public String deleteMicrosService(ModelProperties prop) {
 406         String policyType = refProp.getStringValue("policy.ms.type");
 407         return deletePolicy(prop, policyType);
 408     }
 409
 410     /**
 411      * This method delete the Base policy.
 412      *
 413      * @param prop
 414      *            The model Properties
 415      * @return A string with the answer from policy
 416      */
 417     public String deleteBasePolicy(ModelProperties prop) {
 418         return deletePolicy(prop, PolicyConfigType.Base.toString());
 419     }
 420
 421     /**
 422      * Format and send delete BRMS requests to Policy.
 423      *
 424      * @param prop
 425      *            The ModelProperties
 426      * @return The response message from policy
 427      */
 428     public String deleteBrms(ModelProperties prop) {
 429         String policyType = refProp.getStringValue("policy.op.type");
 430         return deletePolicy(prop, policyType);
 431     }
 432
 433     /**
 434      * Format and send delete PAP and PDP requests to Policy.
 435      *
 436      * @param prop
 437      *            The ModelProperties
 438      *
 439      * @return The response message from policy
 440      */
 441     protected String deletePolicy(ModelProperties prop, String policyType) {
 442         DeletePolicyParameters deletePolicyParameters = new DeletePolicyParameters();
 443
 444         if (prop.getPolicyUniqueId() != null && !prop.getPolicyUniqueId().isEmpty()) {
 445             deletePolicyParameters.setPolicyName(prop.getPolicyScopeAndNameWithUniqueId());
 446         } else {
 447             deletePolicyParameters.setPolicyName(prop.getCurrentPolicyScopeAndPolicyName());
 448         }
 449         logger.info("Policy Name in delete policy method - " + deletePolicyParameters.getPolicyName());
 450         deletePolicyParameters.setPolicyComponent("PDP");
 451         deletePolicyParameters.setDeleteCondition(DeletePolicyCondition.ALL);
 452         deletePolicyParameters.setPdpGroup(refProp.getStringValue("policy.pdp.group"));
 453         deletePolicyParameters.setPolicyType(policyType);
 454         // send delete request
 455         StringBuilder responseMessage = new StringBuilder(sendDeletePolicy(deletePolicyParameters, prop));
 456
 457         logger.info("Deleting policy from PAP...");
 458         deletePolicyParameters.setPolicyComponent("PAP");
 459         deletePolicyParameters.setDeleteCondition(DeletePolicyCondition.ALL);
 460
 461         // send delete request
 462         responseMessage.append(sendDeletePolicy(deletePolicyParameters, prop));
 463
 464         return responseMessage.toString();
 465     }
 466
 467     /**
 468      * Send delete request to Policy.
 469      *
 470      * @param deletePolicyParameters
 471      *            The DeletePolicyParameters
 472      * @param prop
 473      *            The ModelProperties
 474      * @return The response message from policy
 475      */
 476     protected String sendDeletePolicy(DeletePolicyParameters deletePolicyParameters, ModelProperties prop) {
 477         // Verify whether it is triggered by Validation Test button from UI
 478         if (prop.isTest()) {
 479             return "delete not executed for test action";
 480         }
 481
 482         // API method to create or update Policy.
 483         PolicyChangeResponse response = null;
 484         String responseMessage = "";
 485         try {
 486             logger.info("Attempting to delete policy...");
 487             response = getPolicyEngine().deletePolicy(deletePolicyParameters);
 488             responseMessage = response.getResponseMessage();
 489         } catch (Exception e) {
 490             logger.error("Exception occurred during policy communnication", e);
 491         }
 492         logger.info(LOG_POLICY_PREFIX + responseMessage);
 493
 494         if (response != null && response.getResponseCode() == 200) {
 495             logger.info("Policy delete successful");
 496         } else {
 497             logger.warn("Policy delete failed: " + responseMessage);
 498             throw new BadRequestException("Policy delete failed: " + responseMessage);
 499         }
 500
 501         return responseMessage;
 502     }
 503 }