summaryrefslogtreecommitdiffstats
path: root/ONAP-PAP-REST
diff options
context:
space:
mode:
authorpa834y <pa834y@att.com>2019-03-11 10:34:22 -0400
committerpa834y <pa834y@att.com>2019-03-20 15:30:20 -0400
commit2903daf20f5e473a96a36342151a26e9f2e55005 (patch)
treee6da180b8eda43c4f20c05121e265b403fdb1b4a /ONAP-PAP-REST
parentd71b3cf8a983a95fced20eed0cb09aea84aa1b3c (diff)
use hibernate and breakup dbdao and papservlet
Change-Id: Ifa655d56bda0ab4c748f188767122e7bd927155b Issue-ID: POLICY-1417 Signed-off-by: pa834y <pa834y@att.com>
Diffstat (limited to 'ONAP-PAP-REST')
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/ConsoleAndApiService.java956
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/DataToNotifyPdp.java182
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/Heartbeat.java244
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/UpdatePdpThread.java204
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/XACMLPapServlet.java1931
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicy.java44
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/FirewallConfigPolicy.java56
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/HandleIncomingNotifications.java593
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/NotifyOtherPaps.java225
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDao.java2505
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTransaction.java35
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDbDaoTransactionInstance.java1538
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyController.java33
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandler.java121
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandler.java63
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/SavePolicyHandler.java18
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/PolicyCreation.java21
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/MetricService.java56
-rw-r--r--ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JPAUtils.java69
-rw-r--r--ONAP-PAP-REST/src/test/java/org/onap/policy/pap/test/XACMLPAPTest.java549
-rw-r--r--ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicyTest.java18
-rw-r--r--ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTest.java698
-rw-r--r--ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyControllerTest.java39
-rw-r--r--ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandlerTest.java71
-rw-r--r--ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandlerTest.java79
-rw-r--r--ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/util/JPAUtilsTest.java29
26 files changed, 5392 insertions, 4985 deletions
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/ConsoleAndApiService.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/ConsoleAndApiService.java
new file mode 100644
index 000000000..a9ef7eee6
--- /dev/null
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/ConsoleAndApiService.java
@@ -0,0 +1,956 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP-PAP-REST
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.pap.xacml.rest;
+
+import com.att.research.xacml.api.pap.PAPException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Scanner;
+import java.util.Set;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.onap.policy.common.logging.ONAPLoggingContext;
+import org.onap.policy.common.logging.eelf.MessageCodes;
+import org.onap.policy.common.logging.eelf.PolicyLogger;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.pap.xacml.rest.components.PolicyDBDao;
+import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTransaction;
+import org.onap.policy.pap.xacml.rest.handler.PushPolicyHandler;
+import org.onap.policy.xacml.api.XACMLErrorConstants;
+import org.onap.policy.xacml.api.pap.OnapPDP;
+import org.onap.policy.xacml.api.pap.OnapPDPGroup;
+import org.onap.policy.xacml.api.pap.PAPPolicyEngine;
+import org.onap.policy.xacml.std.pap.StdPDP;
+import org.onap.policy.xacml.std.pap.StdPDPGroup;
+import org.onap.policy.xacml.std.pap.StdPDPPolicy;
+
+public class ConsoleAndApiService {
+
+ private static final Logger LOGGER = FlexLogger.getLogger(ConsoleAndApiService.class);
+ private static final Logger auditLogger = FlexLogger.getLogger("auditLogger");
+ private static final String ADD_GROUP_ERROR = "addGroupError";
+ private static final String REGEX = "[0-9a-zA-Z._, ]*";
+ private static final String TRANSACTIONFAILED = "Transaction Failed - See Error.log";
+ private static final String PAPSERVLETDOACPOST = "XACMLPapServlet.doACPost";
+ private static final String ACPOSTCOMMITTRANS = "XACMLPapServlet doACPost commitTransaction";
+ private static final String XACMLPAPSERVLET = "XACMLPapServlet";
+ private static final String SUCCESS = "Success";
+ private static final String ERROR = "error";
+ private static final String MESSAGE = "message";
+ private static final String POLICYID = "policyId";
+ private static final String TRANSENDED = "Transaction Ended Successfully";
+
+ /**
+ * Requests from the Admin Console for operations not on single specific objects.
+ *
+ * @param request Servlet request
+ * @param response Servlet response
+ * @param groupId the group id
+ * @param loggingContext the logging context
+ * @param papEngine the pap engine
+ * @throws ServletException the servlet exception
+ * @throws IOException Signals that an I/O exception has occurred.
+ */
+ public void doAcPost(HttpServletRequest request, HttpServletResponse response, String groupId,
+ ONAPLoggingContext loggingContext, PAPPolicyEngine papEngine) throws IOException {
+ PolicyDBDaoTransaction doAcPostTransaction = null;
+ try {
+ String groupName = request.getParameter("groupName");
+ String groupDescription = request.getParameter("groupDescription");
+ String apiflag = request.getParameter("apiflag");
+ String userId = request.getParameter("userId");
+ if (groupName != null && groupDescription != null) {
+ // Args: group=<groupId> groupName=<name>
+ // groupDescription=<description> <= create a new group
+ loggingContext.setServiceName("AC:PAP.createGroup");
+ String unescapedName = null;
+ String unescapedDescription = null;
+ try {
+ unescapedName = URLDecoder.decode(groupName, "UTF-8");
+ unescapedDescription = URLDecoder.decode(groupDescription, "UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ LOGGER.error(e);
+ }
+ PolicyDBDaoTransaction newGroupTransaction = XACMLPapServlet.policyDBDao.getNewTransaction();
+ try {
+ newGroupTransaction.createGroup(PolicyDBDao.createNewPDPGroupId(unescapedName), unescapedName,
+ unescapedDescription, PAPSERVLETDOACPOST);
+ papEngine.newGroup(unescapedName, unescapedDescription);
+ loggingContext.metricStarted();
+ newGroupTransaction.commitTransaction();
+ loggingContext.metricEnded();
+ PolicyLogger.metrics(ACPOSTCOMMITTRANS);
+ } catch (Exception e) {
+ newGroupTransaction.rollbackTransaction();
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET,
+ " Unable to create new group");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
+ "Unable to create new group '" + groupId + "'");
+ return;
+ }
+ response.setStatus(HttpServletResponse.SC_NO_CONTENT);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("New Group '" + groupId + "' created");
+ }
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ }
+ // for all remaining POST operations the group must exist before the
+ // operation can be done
+ OnapPDPGroup group = null;
+ try {
+ group = papEngine.getGroup(groupId);
+ } catch (PAPException e) {
+ LOGGER.error(e);
+ }
+ if (group == null) {
+ String message = "Unknown groupId '" + groupId + "'";
+ // for fixing Header Manipulation of Fortify issue
+ if (!message.matches(REGEX)) {
+ response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+ response.addHeader(ERROR, ADD_GROUP_ERROR);
+ response.addHeader(MESSAGE, "GroupId Id is not valid");
+ return;
+ }
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message);
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ if (apiflag != null) {
+ response.addHeader(ERROR, "unknownGroupId");
+ response.addHeader("operation", "push");
+ response.addHeader(MESSAGE, message);
+ response.setStatus(HttpServletResponse.SC_NOT_FOUND);
+ } else {
+ setResponseError(response, HttpServletResponse.SC_NOT_FOUND, message);
+ }
+ return;
+ }
+
+ // If the request contains a policyId then we know we are pushing
+ // the policy to PDP
+ if (request.getParameter(POLICYID) != null) {
+ String policyName = request.getParameter(POLICYID);
+ List<String> policyIdList = Arrays.asList(policyName.split(","));
+
+ loggingContext.setServiceName("PolicyEngineAPI:PAP.postPolicy");
+ LOGGER.info("PushPolicy Request - " + policyName + ", UserId - " + userId);
+
+ StdPDPGroup updatedGroup = null;
+ StdPDPPolicy policyForSafetyCheck = new StdPDPPolicy();
+ for (String policyId : policyIdList) {
+ PolicyDBDaoTransaction addPolicyToGroupTransaction =
+ XACMLPapServlet.policyDBDao.getNewTransaction();
+ try {
+ // Copying the policy to the file system and updating groups
+ // in database
+ LOGGER.info("PapServlet: calling PolicyDBDao.addPolicyToGroup()");
+ updatedGroup = addPolicyToGroupTransaction.addPolicyToGroup(group.getId(), policyId,
+ PAPSERVLETDOACPOST, userId);
+ loggingContext.metricStarted();
+ addPolicyToGroupTransaction.commitTransaction();
+ loggingContext.metricEnded();
+ PolicyLogger.metrics(ACPOSTCOMMITTRANS);
+ LOGGER.info("PapServlet: addPolicyToGroup() succeeded, transaction was committed");
+
+ if (policyId.contains("Config_MS_") || policyId.contains("BRMS_Param")) {
+ PushPolicyHandler pushPolicyHandler = PushPolicyHandler.getInstance();
+ policyForSafetyCheck.setId(policyId);
+ if (pushPolicyHandler.preSafetyCheck(policyForSafetyCheck, XACMLPapServlet.getConfigHome())) {
+ LOGGER.debug("Precheck Successful.");
+ }
+ }
+
+ // delete temporary policy file from the bin directory
+ Files.deleteIfExists(Paths.get(policyId));
+
+ } catch (Exception e) {
+ addPolicyToGroupTransaction.rollbackTransaction();
+ String message = "Policy '" + policyName + "' not copied to group '" + groupId + "': " + e;
+ // for fixing Header Manipulation of Fortify issue
+ if (!message.matches(REGEX)) {
+ response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+ response.addHeader(ERROR, ADD_GROUP_ERROR);
+ response.addHeader(MESSAGE, "Policy Id is not valid");
+ return;
+ }
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " " + message);
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ if (apiflag != null) {
+ response.addHeader(ERROR, "policyCopyError");
+ response.addHeader(MESSAGE, message);
+ response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+ } else {
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
+ }
+ return;
+ }
+ }
+
+ /*
+ * If request comes from the API we need to run the PolicyDBDao updateGroup() to
+ * notify other paps of the change. The GUI does this from the POLICY-SDK-APP code.
+ */
+
+ // Get new transaction to perform updateGroup()
+ PolicyDBDaoTransaction acPutTransaction = XACMLPapServlet.policyDBDao.getNewTransaction();
+ try {
+ // Assume that this is an update of an existing PDP
+ // Group
+ loggingContext.setServiceName("PolicyEngineAPI:PAP.updateGroup");
+ try {
+ acPutTransaction.updateGroup(updatedGroup, "XACMLPapServlet.doACPut", userId);
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET,
+ " Error occurred when notifying PAPs of a group change: " + e);
+ throw new PAPException(e.getMessage());
+ }
+
+ LOGGER.info("Calling updatGroup() with new group");
+ papEngine.updateGroup(updatedGroup);
+
+ LOGGER.info("Group - '" + updatedGroup.getId() + "' updated");
+
+ // Commit transaction to send notification to other PAPs
+ loggingContext.metricStarted();
+ acPutTransaction.commitTransaction();
+ loggingContext.metricEnded();
+ PolicyLogger.metrics("XACMLPapServlet updateGroupsFromAPI commitTransaction");
+ // Group changed to send notification to PDPs, which
+ // might include changing the policies
+ getPapInstance().groupChanged(updatedGroup, loggingContext);
+ loggingContext.transactionEnded();
+ LOGGER.info(SUCCESS);
+ } catch (Exception e) {
+ acPutTransaction.rollbackTransaction();
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET, " API PUT exception");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ String message = XACMLErrorConstants.ERROR_PROCESS_FLOW
+ + "Exception occurred when updating the group from API.";
+ LOGGER.error(message);
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
+ response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+ response.addHeader(ERROR, ADD_GROUP_ERROR);
+ response.addHeader(MESSAGE, message);
+ return;
+ }
+ // policy file copied ok and the Group was updated on the PDP
+ response.setStatus(HttpServletResponse.SC_NO_CONTENT);
+ response.addHeader("operation", "push");
+ response.addHeader(POLICYID, policyName);
+ response.addHeader("groupId", groupId);
+
+ LOGGER.info("policy '" + policyName + "' copied to directory for group '" + groupId + "'");
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ LOGGER.info(TRANSENDED);
+
+ return;
+ } else if (request.getParameter("default") != null) {
+ // Args: group=<groupId> default=true <= make default
+ // change the current default group to be the one identified in
+ // the request.
+ loggingContext.setServiceName("AC:PAP.setDefaultGroup");
+ // This is a POST operation rather than a PUT "update group"
+ // because of the side-effect that the current default group is
+ // also changed.
+ // It should never be the case that multiple groups are
+ // currently marked as the default, but protect against that
+ // anyway.
+ PolicyDBDaoTransaction setDefaultGroupTransaction = XACMLPapServlet.policyDBDao.getNewTransaction();
+ try {
+ setDefaultGroupTransaction.changeDefaultGroup(group, PAPSERVLETDOACPOST);
+ papEngine.setDefaultGroup(group);
+ loggingContext.metricStarted();
+ setDefaultGroupTransaction.commitTransaction();
+ loggingContext.metricEnded();
+ PolicyLogger.metrics(ACPOSTCOMMITTRANS);
+ } catch (Exception e) {
+ setDefaultGroupTransaction.rollbackTransaction();
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET, " Unable to set group");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
+ "Unable to set group '" + groupId + "' to default");
+ return;
+ }
+ response.setStatus(HttpServletResponse.SC_NO_CONTENT);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("Group- '" + groupId + "' set to be default");
+ }
+ auditLogger.info(SUCCESS);
+ LOGGER.info(TRANSENDED);
+ return;
+ } else if (request.getParameter("pdpId") != null) {
+ doAcPostTransaction = XACMLPapServlet.policyDBDao.getNewTransaction();
+ // Args: group=<groupId> pdpId=<pdpId> <= move PDP to group
+ loggingContext.setServiceName("AC:PAP.movePDP");
+ String pdpId = request.getParameter("pdpId");
+ OnapPDP pdp = papEngine.getPDP(pdpId);
+ OnapPDPGroup originalGroup = papEngine.getPDPGroup(pdp);
+ try {
+ doAcPostTransaction.movePdp(pdp, group, PAPSERVLETDOACPOST);
+ } catch (Exception e) {
+ doAcPostTransaction.rollbackTransaction();
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET,
+ " Error while moving pdp in the database: " + "pdp=" + pdp.getId() + ",to group="
+ + group.getId());
+ throw new PAPException(e.getMessage());
+ }
+ papEngine.movePDP(pdp, group);
+ response.setStatus(HttpServletResponse.SC_NO_CONTENT);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug(
+ "PDP - '" + pdp.getId() + "' moved to group - '" + group.getId() + "' set to be default");
+ }
+ // update the status of both the original group and the new one
+ ((StdPDPGroup) originalGroup).resetStatus();
+ ((StdPDPGroup) group).resetStatus();
+ // Need to notify the PDP that it's config may have changed
+ getPapInstance().pdpChanged(pdp, loggingContext);
+ loggingContext.metricStarted();
+ doAcPostTransaction.commitTransaction();
+ loggingContext.metricEnded();
+ PolicyLogger.metrics(ACPOSTCOMMITTRANS);
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ }
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET, " AC POST exception");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
+ return;
+ }
+ }
+
+ /**
+ * Requests from the Admin Console to GET info about the Groups and PDPs.
+ *
+ * @param request the request
+ * @param response the response
+ * @param groupId the group id
+ * @param loggingContext the logging context
+ * @param papEngine the pap engine
+ * @throws IOException Signals that an I/O exception has occurred.
+ */
+ public void doAcGet(HttpServletRequest request, HttpServletResponse response, String groupId,
+ ONAPLoggingContext loggingContext, PAPPolicyEngine papEngine) throws IOException {
+ try {
+ String parameterDefault = request.getParameter("default");
+ String pdpId = request.getParameter("pdpId");
+ String pdpGroup = request.getParameter("getPDPGroup");
+ if ("".equals(groupId)) {
+ // request IS from AC but does not identify a group by name
+ if (parameterDefault != null) {
+ // Request is for the Default group (whatever its id)
+ loggingContext.setServiceName("AC:PAP.getDefaultGroup");
+ OnapPDPGroup group = papEngine.getDefaultGroup();
+ // convert response object to JSON and include in the
+ // response
+ mapperWriteValue(new ObjectMapper(), response, group);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("GET Default group req from '" + request.getRequestURL() + "'");
+ }
+ response.setStatus(HttpServletResponse.SC_OK);
+ response.setHeader("content-type", "application/json");
+ try {
+ response.getOutputStream().close();
+ } catch (IOException e) {
+ LOGGER.error(e);
+ }
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ } else if (pdpId != null) {
+ // Request is related to a PDP
+ if (pdpGroup == null) {
+ // Request is for the (unspecified) group containing a
+ // given PDP
+ loggingContext.setServiceName("AC:PAP.getPDP");
+ OnapPDP pdp = null;
+ try {
+ pdp = papEngine.getPDP(pdpId);
+ } catch (PAPException e) {
+ LOGGER.error(e);
+ }
+ // convert response object to JSON and include in the
+ // response
+ mapperWriteValue(new ObjectMapper(), response, pdp);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("GET pdp '" + pdpId + "' req from '" + request.getRequestURL() + "'");
+ }
+ response.setStatus(HttpServletResponse.SC_OK);
+ response.setHeader("content-type", "application/json");
+ try {
+ response.getOutputStream().close();
+ } catch (IOException e) {
+ LOGGER.error(e);
+ }
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ } else {
+ // Request is for the group containing a given PDP
+ loggingContext.setServiceName("AC:PAP.getGroupForPDP");
+ OnapPDPGroup group = null;
+ try {
+ OnapPDP pdp = papEngine.getPDP(pdpId);
+ group = papEngine.getPDPGroup(pdp);
+ } catch (PAPException e) {
+ LOGGER.error(e);
+ }
+ // convert response object to JSON and include in the
+ // response
+ mapperWriteValue(new ObjectMapper(), response, group);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("GET PDP '" + pdpId + "' Group req from '" + request.getRequestURL() + "'");
+ }
+ response.setStatus(HttpServletResponse.SC_OK);
+ response.setHeader("content-type", "application/json");
+ try {
+ response.getOutputStream().close();
+ } catch (IOException e) {
+ LOGGER.error(e);
+ }
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ }
+ } else {
+ // request is for top-level properties about all groups
+ loggingContext.setServiceName("AC:PAP.getAllGroups");
+ Set<OnapPDPGroup> groups = null;
+ try {
+ groups = papEngine.getOnapPDPGroups();
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET, " AC Get exception");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
+ return;
+ }
+ // convert response object to JSON and include in the
+ // response
+ mapperWriteValue(new ObjectMapper(), response, groups);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("GET All groups req");
+ }
+ response.setStatus(HttpServletResponse.SC_OK);
+ response.setHeader("content-type", "application/json");
+ try {
+ response.getOutputStream().close();
+ } catch (IOException e) {
+ LOGGER.error(e);
+ }
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ }
+ }
+ // for all other GET operations the group must exist before the
+ // operation can be done
+ OnapPDPGroup group = null;
+ try {
+ group = papEngine.getGroup(groupId);
+ } catch (PAPException e) {
+ LOGGER.error(e);
+ }
+ if (group == null) {
+ String message = "Unknown groupId '" + groupId + "'";
+ // for fixing Header Manipulation of Fortify issue
+ if (!message.matches(REGEX)) {
+ response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+ response.addHeader(ERROR, ADD_GROUP_ERROR);
+ response.addHeader(MESSAGE, "Group Id is not valid");
+ return;
+ }
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message);
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_NOT_FOUND, message);
+ return;
+ }
+ // Figure out which request this is based on the parameters
+ String policyId = request.getParameter(POLICYID);
+ if (policyId != null) {
+ // retrieve a policy
+ loggingContext.setServiceName("AC:PAP.getPolicy");
+ // convert response object to JSON and include in the response
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " GET Policy not implemented");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_BAD_REQUEST, "GET Policy not implemented");
+ } else {
+ // No other parameters, so return the identified Group
+ loggingContext.setServiceName("AC:PAP.getGroup");
+ // convert response object to JSON and include in the response
+ mapperWriteValue(new ObjectMapper(), response, group);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("GET group '" + group.getId() + "' req from '" + request.getRequestURL() + "'");
+ }
+ response.setStatus(HttpServletResponse.SC_OK);
+ response.setHeader("content-type", "application/json");
+ try {
+ response.getOutputStream().close();
+ } catch (IOException e) {
+ LOGGER.error(e);
+ }
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ }
+ // Currently there are no other GET calls from the AC.
+ // The AC uses the "GET All Groups" operation to fill its local
+ // cache and uses that cache for all other GETs without calling the
+ // PAP.
+ // Other GETs that could be called:
+ // Specific Group (groupId=<groupId>)
+ // A Policy (groupId=<groupId> policyId=<policyId>)
+ // A PDP (groupId=<groupId> pdpId=<pdpId>)
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " UNIMPLEMENTED ");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED");
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET, " AC Get exception");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
+ return;
+ }
+ }
+
+ /**
+ * Requests from the Admin Console to create new items or update existing ones.
+ *
+ * @param request the request
+ * @param response the response
+ * @param groupId the group id
+ * @param loggingContext the logging context
+ * @param papEngine the pap engine
+ * @throws IOException Signals that an I/O exception has occurred.
+ */
+ public void doAcPut(HttpServletRequest request, HttpServletResponse response, String groupId,
+ ONAPLoggingContext loggingContext, PAPPolicyEngine papEngine) throws IOException {
+ PolicyDBDaoTransaction acPutTransaction = XACMLPapServlet.policyDBDao.getNewTransaction();
+ try {
+ String userId = request.getParameter("userId");
+ // for PUT operations the group may or may not need to exist before
+ // the operation can be done
+ OnapPDPGroup group = papEngine.getGroup(groupId);
+ // determine the operation needed based on the parameters in the
+ // request
+ // for remaining operations the group must exist before the
+ // operation can be done
+ if (group == null) {
+ String message = "Unknown groupId '" + groupId + "'";
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message);
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_NOT_FOUND, message);
+ return;
+ }
+ if (request.getParameter("policy") != null) {
+ // group=<groupId> policy=<policyId> contents=policy file <=
+ // Create new policy file in group dir, or replace it if it
+ // already exists (do not touch properties)
+ loggingContext.setServiceName("AC:PAP.putPolicy");
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE
+ + " PARTIALLY IMPLEMENTED!!! ACTUAL CHANGES SHOULD BE MADE BY PAP SERVLET!!! ");
+ response.setStatus(HttpServletResponse.SC_NO_CONTENT);
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ } else if (request.getParameter("pdpId") != null) {
+ // ARGS: group=<groupId> pdpId=<pdpId/URL> <= create a new PDP
+ // or Update an Existing one
+ String pdpId = request.getParameter("pdpId");
+ if (papEngine.getPDP(pdpId) == null) {
+ loggingContext.setServiceName("AC:PAP.createPDP");
+ } else {
+ loggingContext.setServiceName("AC:PAP.updatePDP");
+ }
+ // get the request content into a String
+ String json = null;
+ // read the inputStream into a buffer (trick found online scans
+ // entire input looking for end-of-file)
+ try {
+ Scanner scanner = new Scanner(request.getInputStream());
+ scanner.useDelimiter("\\A");
+ json = scanner.hasNext() ? scanner.next() : "";
+ scanner.close();
+ } catch (IOException e) {
+ LOGGER.error(e);
+ }
+ LOGGER.info("JSON request from AC: " + json);
+ // convert Object sent as JSON into local object
+ ObjectMapper mapper = new ObjectMapper();
+ Object objectFromJson = null;
+ try {
+ objectFromJson = mapper.readValue(json, StdPDP.class);
+ } catch (Exception e) {
+ LOGGER.error(e);
+ }
+ if (pdpId == null || objectFromJson == null || !(objectFromJson instanceof StdPDP)
+ || ((StdPDP) objectFromJson).getId() == null
+ || !((StdPDP) objectFromJson).getId().equals(pdpId)) {
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " PDP new/update had bad input. pdpId=" + pdpId
+ + " objectFromJSON=" + objectFromJson);
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
+ "Bad input pdpid for object:" + objectFromJson);
+ }
+ StdPDP pdp = (StdPDP) objectFromJson;
+ if (pdp != null) {
+ OnapPDP origPdp = null;
+ try {
+ origPdp = papEngine.getPDP(pdpId);
+ } catch (PAPException e) {
+ LOGGER.error(e);
+ }
+ if (origPdp == null) {
+ // this is a request to create a new PDP object
+ try {
+ acPutTransaction.addPdpToGroup(pdp.getId(), group.getId(), pdp.getName(),
+ pdp.getDescription(), pdp.getJmxPort(), "XACMLPapServlet.doACPut");
+ papEngine.newPDP(pdp.getId(), group, pdp.getName(), pdp.getDescription(), pdp.getJmxPort());
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET,
+ " Error while adding pdp to group in the database: " + "pdp=" + (pdp.getId())
+ + ",to group=" + group.getId());
+ throw new PAPException(e.getMessage());
+ }
+ } else {
+ // this is a request to update the pdp
+ try {
+ acPutTransaction.updatePdp(pdp, "XACMLPapServlet.doACPut");
+ papEngine.updatePDP(pdp);
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET,
+ " Error while updating pdp in the database: " + "pdp=" + pdp.getId());
+ throw new PAPException(e.getMessage());
+ }
+ }
+ response.setStatus(HttpServletResponse.SC_NO_CONTENT);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("PDP '" + pdpId + "' created/updated");
+ }
+ // adjust the group's state including the new PDP
+ ((StdPDPGroup) group).resetStatus();
+ // this might affect the PDP, so notify it of the change
+ getPapInstance().pdpChanged(pdp, loggingContext);
+ loggingContext.metricStarted();
+ acPutTransaction.commitTransaction();
+ loggingContext.metricEnded();
+ PolicyLogger.metrics("XACMLPapServlet doACPut commitTransaction");
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ } else {
+ try {
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, XACMLPAPSERVLET,
+ " Error while adding pdp to group in the database: " + "pdp=null" + ",to group="
+ + group.getId());
+ throw new PAPException("PDP is null");
+ } catch (Exception e) {
+ throw new PAPException("PDP is null" + e.getMessage() + e);
+ }
+ }
+ } else if (request.getParameter("pipId") != null) {
+ // group=<groupId> pipId=<pipEngineId> contents=pip properties
+ // <= add a PIP to pip config, or replace it if it already
+ // exists (lenient operation)
+ loggingContext.setServiceName("AC:PAP.putPIP");
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " UNIMPLEMENTED");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED");
+ return;
+ } else {
+ // Assume that this is an update of an existing PDP Group
+ // ARGS: group=<groupId> <= Update an Existing Group
+ loggingContext.setServiceName("AC:PAP.updateGroup");
+ // get the request content into a String
+ String json = null;
+ // read the inputStream into a buffer (trick found online scans
+ // entire input looking for end-of-file)
+ try {
+ Scanner scanner = new Scanner(request.getInputStream());
+ scanner.useDelimiter("\\A");
+ json = scanner.hasNext() ? scanner.next() : "";
+ scanner.close();
+ } catch (IOException e) {
+ LOGGER.error(e);
+ }
+ LOGGER.info("JSON request from AC: " + json);
+ // convert Object sent as JSON into local object
+ ObjectMapper mapper = new ObjectMapper();
+ Object objectFromJson = null;
+ try {
+ objectFromJson = mapper.readValue(json, StdPDPGroup.class);
+ } catch (Exception e) {
+ LOGGER.error(e);
+ }
+ if (objectFromJson == null || !(objectFromJson instanceof StdPDPGroup)
+ || !((StdPDPGroup) objectFromJson).getId().equals(group.getId())) {
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Group update had bad input. id="
+ + group.getId() + " objectFromJSON=" + objectFromJson);
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
+ "Bad input id for object:" + objectFromJson);
+ }
+ // The Path on the PAP side is not carried on the RESTful
+ // interface with the AC
+ // (because it is local to the PAP)
+ // so we need to fill that in before submitting the group for
+ // update
+ if (objectFromJson != null) {
+ ((StdPDPGroup) objectFromJson).setDirectory(((StdPDPGroup) group).getDirectory());
+ }
+ try {
+ if ("delete".equals(((StdPDPGroup) objectFromJson).getOperation())) {
+ acPutTransaction.updateGroup((StdPDPGroup) objectFromJson, "XACMLPapServlet.doDelete", userId);
+ } else {
+ acPutTransaction.updateGroup((StdPDPGroup) objectFromJson, "XACMLPapServlet.doACPut", userId);
+ }
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " Error while updating group in the database: "
+ + "group=" + group.getId());
+ LOGGER.error(e);
+ throw new PAPException(e.getMessage());
+ }
+
+ PushPolicyHandler pushPolicyHandler = PushPolicyHandler.getInstance();
+ OnapPDPGroup updatedGroup = (StdPDPGroup) objectFromJson;
+ if (pushPolicyHandler.preSafetyCheck(updatedGroup, XACMLPapServlet.getConfigHome())) {
+ LOGGER.debug("Precheck Successful.");
+ }
+ try {
+ papEngine.updateGroup((StdPDPGroup) objectFromJson);
+ } catch (PAPException e) {
+ LOGGER.error(e);
+ }
+ response.setStatus(HttpServletResponse.SC_NO_CONTENT);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("Group '" + group.getId() + "' updated");
+ }
+ loggingContext.metricStarted();
+ acPutTransaction.commitTransaction();
+ loggingContext.metricEnded();
+ PolicyLogger.metrics("XACMLPapServlet doACPut commitTransaction");
+ // Group changed, which might include changing the policies
+ getPapInstance().groupChanged(group, loggingContext);
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ }
+ } catch (PAPException e) {
+ LOGGER.debug(e);
+ acPutTransaction.rollbackTransaction();
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET, " AC PUT exception");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
+ return;
+ }
+ }
+
+ /**
+ * Requests from the Admin Console to delete/remove items.
+ *
+ * @param request the request
+ * @param response the response
+ * @param groupId the group id
+ * @param loggingContext the logging context
+ * @param papEngine the pap engine
+ * @throws IOException Signals that an I/O exception has occurred.
+ */
+ public void doAcDelete(HttpServletRequest request, HttpServletResponse response, String groupId,
+ ONAPLoggingContext loggingContext, PAPPolicyEngine papEngine) throws IOException {
+ PolicyDBDaoTransaction removePdpOrGroupTransaction = XACMLPapServlet.policyDBDao.getNewTransaction();
+ try {
+ // for all DELETE operations the group must exist before the
+ // operation can be done
+ loggingContext.setServiceName("AC:PAP.delete");
+ OnapPDPGroup group = papEngine.getGroup(groupId);
+ if (group == null) {
+ String message = "Unknown groupId '" + groupId + "'";
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message);
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_NOT_FOUND, "Unknown groupId '" + groupId + "'");
+ return;
+ }
+ // determine the operation needed based on the parameters in the
+ // request
+ if (request.getParameter("policy") != null) {
+ // group=<groupId> policy=<policyId> [delete=<true|false>] <=
+ // delete policy file from group
+ loggingContext.setServiceName("AC:PAP.deletePolicy");
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " UNIMPLEMENTED");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED");
+ return;
+ } else if (request.getParameter("pdpId") != null) {
+ // ARGS: group=<groupId> pdpId=<pdpId> <= delete PDP
+ String pdpId = request.getParameter("pdpId");
+ OnapPDP pdp = papEngine.getPDP(pdpId);
+ removePdpFromGroup(removePdpOrGroupTransaction, pdp, papEngine);
+ // adjust the status of the group, which may have changed when
+ // we removed this PDP
+ ((StdPDPGroup) group).resetStatus();
+ response.setStatus(HttpServletResponse.SC_NO_CONTENT);
+ // update the PDP and tell it that it has NO Policies (which
+ // prevents it from serving PEP Requests)
+ getPapInstance().pdpChanged(pdp, loggingContext);
+ loggingContext.metricStarted();
+ removePdpOrGroupTransaction.commitTransaction();
+ loggingContext.metricEnded();
+ PolicyLogger.metrics("XACMLPapServlet doACPut commitTransaction");
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ } else if (request.getParameter("pipId") != null) {
+ // group=<groupId> pipId=<pipEngineId> <= delete PIP config for
+ // given engine
+ loggingContext.setServiceName("AC:PAP.deletePIPConfig");
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " UNIMPLEMENTED");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED");
+ return;
+ } else {
+ // ARGS: group=<groupId> movePDPsToGroupId=<movePDPsToGroupId>
+ // <= delete a group and move all its PDPs to the given group
+ String moveToGroupId = request.getParameter("movePDPsToGroupId");
+ OnapPDPGroup moveToGroup = null;
+ if (moveToGroupId != null) {
+ try {
+ moveToGroup = papEngine.getGroup(moveToGroupId);
+ } catch (PAPException e) {
+ LOGGER.error(e);
+ }
+ }
+ // get list of PDPs in the group being deleted so we can notify
+ // them that they got changed
+ Set<OnapPDP> movedPdps = new HashSet<>();
+ movedPdps.addAll(group.getOnapPdps());
+ // do the move/remove
+ deleteGroup(removePdpOrGroupTransaction, group, moveToGroup, papEngine);
+ response.setStatus(HttpServletResponse.SC_NO_CONTENT);
+ // notify any PDPs in the removed set that their config may have
+ // changed
+ for (OnapPDP pdp : movedPdps) {
+ getPapInstance().pdpChanged(pdp, loggingContext);
+ }
+ loggingContext.metricStarted();
+ removePdpOrGroupTransaction.commitTransaction();
+ loggingContext.metricEnded();
+ PolicyLogger.metrics("XACMLPapServlet doACPut commitTransaction");
+ loggingContext.transactionEnded();
+ auditLogger.info(SUCCESS);
+ PolicyLogger.audit(TRANSENDED);
+ return;
+ }
+ } catch (PAPException e) {
+ removePdpOrGroupTransaction.rollbackTransaction();
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET, " AC DELETE exception");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit(TRANSACTIONFAILED);
+ setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
+ return;
+ }
+ }
+
+ private void deleteGroup(PolicyDBDaoTransaction removePdpOrGroupTransaction, OnapPDPGroup group,
+ OnapPDPGroup moveToGroup, PAPPolicyEngine papEngine) throws PAPException {
+ try {
+ removePdpOrGroupTransaction.deleteGroup(group, moveToGroup, "XACMLPapServlet.doACDelete");
+ papEngine.removeGroup(group, moveToGroup);
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.ERROR_UNKNOWN, e, XACMLPAPSERVLET,
+ " Failed to delete PDP Group. Exception");
+ throw new PAPException(e.getMessage());
+ }
+ }
+
+ private void removePdpFromGroup(PolicyDBDaoTransaction removePdpOrGroupTransaction, OnapPDP pdp,
+ PAPPolicyEngine papEngine) throws PAPException {
+ try {
+ removePdpOrGroupTransaction.removePdpFromGroup(pdp.getId(), "XACMLPapServlet.doACDelete");
+ papEngine.removePDP(pdp);
+ } catch (Exception e) {
+ throw new PAPException(e);
+ }
+ }
+
+ private XACMLPapServlet getPapInstance() {
+ return new XACMLPapServlet();
+ }
+
+ private static void mapperWriteValue(ObjectMapper mapper, HttpServletResponse response, Object value) {
+ try {
+ mapper.writeValue(response.getOutputStream(), value);
+ } catch (Exception e) {
+ LOGGER.error(e);
+ }
+ }
+
+ private void setResponseError(HttpServletResponse response, int responseCode, String message) {
+ try {
+ if (message != null && !message.isEmpty()) {
+ response.sendError(responseCode, message);
+ }
+ } catch (IOException e) {
+ LOGGER.error("Error setting Error response Header ", e);
+ }
+ return;
+ }
+}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/DataToNotifyPdp.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/DataToNotifyPdp.java
new file mode 100644
index 000000000..825aeb774
--- /dev/null
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/DataToNotifyPdp.java
@@ -0,0 +1,182 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP-PAP-REST
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.pap.xacml.rest;
+
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.util.XACMLProperties;
+import com.google.common.base.Joiner;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Properties;
+import java.util.TreeSet;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.rest.dao.CommonClassDao;
+import org.onap.policy.rest.jpa.GroupEntity;
+import org.onap.policy.rest.jpa.PolicyEntity;
+import org.onap.policy.xacml.api.pap.OnapPDP;
+import org.onap.policy.xacml.api.pap.OnapPDPGroup;
+import org.onap.policy.xacml.api.pap.PAPPolicyEngine;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class DataToNotifyPdp {
+
+ private static final Logger LOGGER = FlexLogger.getLogger(DataToNotifyPdp.class);
+ private static CommonClassDao commonClassDao;
+ private Properties policyLocations = null;
+ private static Properties pipProperties = null;
+
+ @Autowired
+ public DataToNotifyPdp(CommonClassDao commonClassDao) {
+ DataToNotifyPdp.commonClassDao = commonClassDao;
+ }
+
+ public DataToNotifyPdp() {
+ // default constructor.
+ }
+
+
+ private static Properties readPipProperties() throws IOException {
+ if (pipProperties == null) {
+ try (FileInputStream inputStream = new FileInputStream(Paths.get("pip.properties").toString())) {
+ pipProperties = new Properties();
+ pipProperties.load(inputStream);
+ }
+ }
+ return pipProperties;
+ }
+
+ /**
+ * Sets the policy config properties.
+ *
+ * @param pdp the pdp
+ * @param papEngine the pap engine
+ * @return the list
+ */
+ public List<Properties> setPolicyConfigProperties(OnapPDP pdp, PAPPolicyEngine papEngine) {
+ OnapPDPGroup group = null;
+ try {
+ group = papEngine.getPDPGroup(pdp);
+ } catch (PAPException e) {
+ LOGGER.error("Pdp Id not found in PDP Groups.", e);
+ }
+ return setPolicyConfigProperties(group);
+ }
+
+ /**
+ * This method is used to set the policyGroupEntity data to properties. So, we can update the
+ * pdp thread with the latest policy info. Hence, considering Database as master instead of File
+ * System. To overcome the redundancy issues.
+ *
+ * @param group Input is OnapPDP Group name.
+ */
+ public List<Properties> setPolicyConfigProperties(OnapPDPGroup group) {
+ boolean groupCheck = false;
+ List<Properties> properties = new ArrayList<>();
+ policyLocations = new Properties();
+ Properties policyProperties = new Properties();
+ Properties pipProps = new Properties();
+ if (group != null && group.getName() != null) {
+ GroupEntity data =
+ (GroupEntity) commonClassDao.getEntityItem(GroupEntity.class, "groupName", group.getName());
+ if (data != null) {
+ policyProperties = setPolicyProperties(data);
+ try {
+ pipProps = readPipProperties();
+ } catch (IOException e) {
+ LOGGER.error("Error Occured while reading the pip properties.", e);
+ }
+ groupCheck = true;
+ } else {
+ LOGGER.info("Group Name exists, but not exists in DB. So, adding the empty properties list.");
+ setEmptyPolicyProperties(policyProperties, pipProps);
+ }
+ } else {
+ LOGGER.info("Group Name is null. So, adding the empty properties list.");
+ setEmptyPolicyProperties(policyProperties, pipProps);
+ }
+ properties.add(policyProperties);
+ properties.add(pipProps);
+ if (groupCheck) {
+ properties.add(policyLocations);
+ }
+ return properties;
+ }
+
+ /**
+ * Based on the Group Entity list, write the policyNames to properties.
+ *
+ * @param data group entity object.
+ * @return properties.
+ */
+ private Properties setPolicyProperties(GroupEntity data) {
+ GroupEntity entity = data;
+ Properties policyProperties = new Properties() {
+ private static final long serialVersionUID = 1L;
+
+ // For Debugging it is helpful for the file to be in a sorted order,
+ // any by returning the keys in the natural Alpha order for strings we get close enough.
+ // TreeSet is sorted, and this just overrides the normal Properties method to get the
+ // keys.
+ @Override
+ public synchronized Enumeration<Object> keys() {
+ return Collections.enumeration(new TreeSet<Object>(super.keySet()));
+ }
+ };
+ List<String> roots = new ArrayList<>();
+ for (PolicyEntity policy : entity.getPolicies()) {
+ // for all policies need to tell PDP the "name", which is the base name for the file id
+ String policyName = policy.getScope() + "." + policy.getPolicyName();
+ String policyNameWithNoScope = policy.getPolicyName();
+ if (policyName != null) {
+ policyProperties.setProperty(policyName + ".name", policy.getScope() + "."
+ + policyNameWithNoScope.substring(0, policyNameWithNoScope.indexOf('.')));
+ policyLocations.put(policyName + ".url", XACMLPapServlet.papURL + "?id=" + policyName);
+ }
+ roots.add(policyName);
+ }
+ policyProperties.setProperty(XACMLProperties.PROP_ROOTPOLICIES, Joiner.on(',').join(roots));
+ policyProperties.setProperty(XACMLProperties.PROP_REFERENCEDPOLICIES, "");
+ return policyProperties;
+ }
+
+ /**
+ * When Group name is null, then we need to consider group is deleted and notify pdp with empty
+ * properties.
+ *
+ * @param policyProperties policyProperties input.
+ * @param pipProps pipProps input.
+ */
+ private void setEmptyPolicyProperties(Properties policyProperties, Properties pipProps) {
+ // create blank properties files
+ policyProperties.put(XACMLProperties.PROP_ROOTPOLICIES, "");
+ policyProperties.put(XACMLProperties.PROP_REFERENCEDPOLICIES, "");
+ pipProps.setProperty(XACMLProperties.PROP_PIP_ENGINES, "");
+ }
+
+}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/Heartbeat.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/Heartbeat.java
new file mode 100644
index 000000000..2687799cc
--- /dev/null
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/Heartbeat.java
@@ -0,0 +1,244 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP-PAP-REST
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.pap.xacml.rest;
+
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.api.pap.PDPStatus;
+import com.att.research.xacml.util.XACMLProperties;
+import java.net.ConnectException;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.SocketTimeoutException;
+import java.net.URL;
+import java.net.UnknownHostException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+import org.onap.policy.common.logging.eelf.MessageCodes;
+import org.onap.policy.common.logging.eelf.PolicyLogger;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.pap.xacml.restAuth.CheckPDP;
+import org.onap.policy.rest.XACMLRestProperties;
+import org.onap.policy.xacml.api.pap.OnapPDP;
+import org.onap.policy.xacml.api.pap.OnapPDPGroup;
+import org.onap.policy.xacml.api.pap.PAPPolicyEngine;
+
+
+/**
+ * Heartbeat thread - periodically check on PDPs' status.
+ * Heartbeat with all known PDPs.
+ * Implementation note:
+ * The PDPs are contacted Sequentially, not in Parallel.
+ * If we did this in parallel using multiple threads we would simultaneously use - 1 thread and - 1
+ * connection for EACH PDP. This could become a resource problem since we already use multiple
+ * threads and connections for updating the PDPs when user changes occur. Using separate threads can
+ * also make it tricky dealing with timeouts on PDPs that are non-responsive.
+ * The Sequential operation does a heartbeat request to each PDP one at a time. This has the flaw
+ * that any PDPs that do not respond will hold up the entire heartbeat sequence until they timeout.
+ * If there are a lot of non-responsive PDPs and the timeout is large-ish (the default is 20
+ * seconds) it could take a long time to cycle through all of the PDPs. That means that this may not
+ * notice a PDP being down in a predictable time.
+ */
+public class Heartbeat implements Runnable {
+
+ private static final Logger LOGGER = FlexLogger.getLogger(Heartbeat.class);
+
+ private PAPPolicyEngine papEngine;
+ private Set<OnapPDP> pdps = new HashSet<>();
+ private int heartbeatInterval;
+ private int heartbeatTimeout;
+ private static final String HEARTBEATSTRING = " Heartbeat '";
+ private static final String XACMLPAPSERVLET = "XacmlPapServlet";
+ private static final String ISRUNNINGFALSE = "isRunning is false, getting out of loop.";
+ private volatile boolean isRunning = false;
+
+ public synchronized boolean isHeartBeatRunning() {
+ return this.isRunning;
+ }
+
+ public synchronized void terminate() {
+ this.isRunning = false;
+ }
+
+ /**
+ * Instantiates a new heartbeat.
+ *
+ * @param papEngine2 the pap engine 2
+ */
+ public Heartbeat(PAPPolicyEngine papEngine2) {
+ papEngine = papEngine2;
+ this.heartbeatInterval =
+ Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_HEARTBEAT_INTERVAL, "10000"));
+ this.heartbeatTimeout =
+ Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_HEARTBEAT_TIMEOUT, "10000"));
+ }
+
+ @Override
+ public void run() {
+ // Set ourselves as running
+ synchronized (this) {
+ this.isRunning = true;
+ }
+ try {
+ while (this.isHeartBeatRunning()) {
+ // Wait the given time
+ Thread.sleep(heartbeatInterval);
+ // get the list of PDPs (may have changed since last time)
+ pdps.clear();
+ synchronized (papEngine) {
+ getPdpsFromGroup();
+ }
+ // Check for shutdown
+ if (!this.isHeartBeatRunning()) {
+ LOGGER.info(ISRUNNINGFALSE);
+ break;
+ }
+ notifyEachPdp();
+ // Check for shutdown
+ if (!this.isHeartBeatRunning()) {
+ LOGGER.info(ISRUNNINGFALSE);
+ break;
+ }
+ }
+ } catch (InterruptedException e) {
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " Heartbeat interrupted. Shutting down");
+ this.terminate();
+ Thread.currentThread().interrupt();
+ }
+ }
+
+ private void getPdpsFromGroup() {
+ try {
+ for (OnapPDPGroup g : papEngine.getOnapPDPGroups()) {
+ for (OnapPDP p : g.getOnapPdps()) {
+ pdps.add(p);
+ }
+ }
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, XACMLPAPSERVLET,
+ "Heartbeat unable to read PDPs from PAPEngine");
+ }
+ }
+
+ private void notifyEachPdp() {
+ HashMap<String, URL> idToUrlMap = new HashMap<>();
+ for (OnapPDP pdp : pdps) {
+ // Check for shutdown
+ if (!this.isHeartBeatRunning()) {
+ LOGGER.info(ISRUNNINGFALSE);
+ break;
+ }
+ // the id of the PDP is its url (though we add a query
+ // parameter)
+ URL pdpUrl = idToUrlMap.get(pdp.getId());
+ if (pdpUrl == null) {
+ // haven't seen this PDP before
+ String fullUrlString = null;
+ try {
+ // Check PDP ID
+ if (CheckPDP.validateID(pdp.getId())) {
+ fullUrlString = pdp.getId() + "?type=hb";
+ pdpUrl = new URL(fullUrlString);
+ idToUrlMap.put(pdp.getId(), pdpUrl);
+ }
+ } catch (MalformedURLException e) {
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, XACMLPAPSERVLET,
+ " PDP id '" + fullUrlString + "' is not a valid URL");
+ }
+ }
+ updatePdpStatus(pdp, openPdpConnection(pdpUrl, pdp));
+ }
+ }
+
+ private String openPdpConnection(URL pdpUrl, OnapPDP pdp) {
+ // Do a GET with type HeartBeat
+ String newStatus = "";
+ HttpURLConnection connection = null;
+ try {
+ // Open up the connection
+ if (pdpUrl != null) {
+ connection = (HttpURLConnection) pdpUrl.openConnection();
+ // Setup our method and headers
+ connection.setRequestMethod("GET");
+ connection.setConnectTimeout(heartbeatTimeout);
+ // Authentication
+ String encoding = CheckPDP.getEncoding(pdp.getId());
+ if (encoding != null) {
+ connection.setRequestProperty("Authorization", "Basic " + encoding);
+ }
+ // Do the connect
+ connection.connect();
+ if (connection.getResponseCode() == 204) {
+ newStatus = connection.getHeaderField(XACMLRestProperties.PROP_PDP_HTTP_HEADER_HB);
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("Heartbeat '" + pdp.getId() + "' status='" + newStatus + "'");
+ }
+ } else {
+ // anything else is an unexpected result
+ newStatus = PDPStatus.Status.UNKNOWN.toString();
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " Heartbeat connect response code "
+ + connection.getResponseCode() + ": " + pdp.getId());
+ }
+ }
+ } catch (UnknownHostException e) {
+ newStatus = PDPStatus.Status.NO_SUCH_HOST.toString();
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, XACMLPAPSERVLET,
+ HEARTBEATSTRING + pdp.getId() + "' NO_SUCH_HOST");
+ } catch (SocketTimeoutException e) {
+ newStatus = PDPStatus.Status.CANNOT_CONNECT.toString();
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, XACMLPAPSERVLET,
+ HEARTBEATSTRING + pdp.getId() + "' connection timeout");
+ } catch (ConnectException e) {
+ newStatus = PDPStatus.Status.CANNOT_CONNECT.toString();
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, XACMLPAPSERVLET,
+ HEARTBEATSTRING + pdp.getId() + "' cannot connect");
+ } catch (Exception e) {
+ newStatus = PDPStatus.Status.UNKNOWN.toString();
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, XACMLPAPSERVLET,
+ HEARTBEATSTRING + pdp.getId() + "' connect exception");
+ } finally {
+ // cleanup the connection
+ if (connection != null)
+ connection.disconnect();
+ }
+ return newStatus;
+ }
+
+ private void updatePdpStatus(OnapPDP pdp, String newStatus) {
+ if (!pdp.getStatus().getStatus().toString().equals(newStatus)) {
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("previous status='" + pdp.getStatus().getStatus() + "' new Status='" + newStatus + "'");
+ }
+ try {
+ getPAPInstance().setPDPSummaryStatus(pdp, newStatus);
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, XACMLPAPSERVLET,
+ "Unable to set state for PDP '" + pdp.getId());
+ }
+ }
+ }
+
+ private XACMLPapServlet getPAPInstance() {
+ return new XACMLPapServlet();
+ }
+
+}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/UpdatePdpThread.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/UpdatePdpThread.java
new file mode 100644
index 000000000..11576d314
--- /dev/null
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/UpdatePdpThread.java
@@ -0,0 +1,204 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP-PAP-REST
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.pap.xacml.rest;
+
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.api.pap.PDPStatus;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.List;
+import java.util.Properties;
+import java.util.UUID;
+import org.onap.policy.common.logging.ONAPLoggingContext;
+import org.onap.policy.common.logging.eelf.MessageCodes;
+import org.onap.policy.common.logging.eelf.PolicyLogger;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.pap.xacml.restAuth.CheckPDP;
+import org.onap.policy.xacml.api.pap.OnapPDP;
+
+public class UpdatePdpThread implements Runnable {
+
+ private static final Logger LOGGER = FlexLogger.getLogger(UpdatePdpThread.class);
+ private ONAPLoggingContext baseLoggingContext = new XACMLPapServlet().getBaseLoggingContext();
+ private static final Logger auditLogger = FlexLogger.getLogger("auditLogger");
+ private static final String XACMLPAPSERVLET = "XACMLPapServlet";
+ private static final String MESSAGE = " message: ";
+
+ private OnapPDP pdp;
+ private String requestId;
+ private ONAPLoggingContext loggingContext;
+ private List<Properties> properties;
+
+
+ public UpdatePdpThread(OnapPDP pdp, List<Properties> properties) {
+ this.pdp = pdp;
+ this.properties = properties;
+ }
+
+ /**
+ * Instantiates a new update pdp thread.
+ *
+ * @param pdp the pdp
+ * @param loggingContext the logging context
+ * @param properties the properties
+ */
+ public UpdatePdpThread(OnapPDP pdp, ONAPLoggingContext loggingContext, List<Properties> properties) {
+ this.pdp = pdp;
+ if (loggingContext != null
+ && (loggingContext.getRequestID() != null || "".equals(loggingContext.getRequestID()))) {
+ this.requestId = loggingContext.getRequestID();
+ }
+ this.loggingContext = loggingContext;
+ this.properties = properties;
+ }
+
+ @Override
+ public void run() {
+ // send the current configuration to one PDP
+ HttpURLConnection connection = null;
+ // get a new logging context for the thread
+ try {
+ if (this.loggingContext == null) {
+ loggingContext = new ONAPLoggingContext(baseLoggingContext);
+ }
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, XACMLPAPSERVLET,
+ " Failed to send property file to " + pdp.getId());
+ // Since this is a server-side error, it probably does not
+ // reflect a problem on the client,
+ // so do not change the PDP status.
+ return;
+ }
+ try {
+ loggingContext.setServiceName("PAP:PDP.putConfig");
+ // If a requestId was provided, use it, otherwise generate one;
+ // post to loggingContext to be used later when calling PDP
+ if (requestId == null || "".equals(requestId)) {
+ UUID requestId = UUID.randomUUID();
+ loggingContext.setRequestID(requestId.toString());
+ PolicyLogger
+ .info("requestID not provided in call to XACMLPapSrvlet (UpdatePDPThread) so we generated one: "
+ + loggingContext.getRequestID());
+ } else {
+ loggingContext.setRequestID(requestId);
+ PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (UpdatePDPThread): "
+ + loggingContext.getRequestID());
+ }
+ loggingContext.transactionStarted();
+ // the Id of the PDP is its URL
+ if (LOGGER.isDebugEnabled()) {
+ LOGGER.debug("creating url for id '" + pdp.getId() + "'");
+ }
+ URL url = new URL(pdp.getId() + "?cache=all");
+ // Open up the connection
+ connection = (HttpURLConnection) url.openConnection();
+ // Setup our method and headers
+ connection.setRequestMethod("PUT");
+ // Authentication
+ String encoding = CheckPDP.getEncoding(pdp.getId());
+ if (encoding != null) {
+ connection.setRequestProperty("Authorization", "Basic " + encoding);
+ }
+ connection.setRequestProperty("Content-Type", "text/x-java-properties");
+ connection.setRequestProperty("X-ECOMP-RequestID", loggingContext.getRequestID());
+ connection.setInstanceFollowRedirects(true);
+ connection.setDoOutput(true);
+ if (!writePropertiesToStream(connection)) {
+ return;
+ }
+ // Do the connect
+ loggingContext.metricStarted();
+ connection.connect();
+ loggingContext.metricEnded();
+ PolicyLogger.metrics("XACMLPapServlet UpdatePDPThread connection connect");
+ if (connection.getResponseCode() == 204) {
+ LOGGER.info("Success. We are configured correctly - " + pdp.getId());
+ loggingContext.transactionEnded();
+ auditLogger.info("Success. PDP is configured correctly.");
+ PolicyLogger.audit("Transaction Success. PDP is configured correctly.");
+ getPapInstance().setPDPSummaryStatus(pdp, PDPStatus.Status.UP_TO_DATE);
+ } else if (connection.getResponseCode() == 200) {
+ LOGGER.info("Success. PDP needs to update its configuration - " + pdp.getId());
+ loggingContext.transactionEnded();
+ auditLogger.info("Success. PDP needs to update its configuration.");
+ PolicyLogger.audit("Transaction Success. PDP is configured correctly.");
+ getPapInstance().setPDPSummaryStatus(pdp, PDPStatus.Status.OUT_OF_SYNCH);
+ } else {
+ LOGGER.warn("Failed: " + connection.getResponseCode() + MESSAGE + connection.getResponseMessage()
+ + pdp.getId());
+ loggingContext.transactionEnded();
+ auditLogger.warn("Failed: " + connection.getResponseCode() + MESSAGE + connection.getResponseMessage());
+ PolicyLogger.audit("Transaction Failed: " + connection.getResponseCode() + MESSAGE
+ + connection.getResponseMessage());
+ getPapInstance().setPDPSummaryStatus(pdp, PDPStatus.Status.UNKNOWN);
+ }
+ } catch (Exception e) {
+ LOGGER.debug(e);
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, XACMLPAPSERVLET,
+ " Unable to sync config with PDP '" + pdp.getId() + "'");
+ loggingContext.transactionEnded();
+ PolicyLogger.audit("Transaction Failed: Unable to sync config with PDP '" + pdp.getId() + "': " + e);
+ LOGGER.info("Transaction Failed: Unable to sync config with PDP '" + pdp.getId() + "': " + e);
+ try {
+ getPapInstance().setPDPSummaryStatus(pdp, PDPStatus.Status.UNKNOWN);
+ } catch (PAPException e1) {
+ LOGGER.debug(e1);
+ PolicyLogger
+ .audit("Transaction Failed: Unable to set status of PDP " + pdp.getId() + " to UNKNOWN: " + e);
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, XACMLPAPSERVLET,
+ " Unable to set status of PDP '" + pdp.getId() + "' to UNKNOWN");
+ }
+ } finally {
+ // cleanup the connection
+ if (connection != null) {
+ connection.disconnect();
+ }
+ }
+ }
+
+ private boolean writePropertiesToStream(HttpURLConnection connection) {
+ try (OutputStream os = connection.getOutputStream()) {
+ // Policy Properties
+ properties.get(0).store(os, "");
+ // Pip Properties
+ properties.get(1).store(os, "");
+ // Policy Locations
+ if (properties.size() == 3) {
+ properties.get(2).store(os, "");
+ }
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, XACMLPAPSERVLET,
+ " Failed to send property file to " + pdp.getId());
+ // Since this is a server-side error, it probably does not
+ // reflect a problem on the client,
+ // so do not change the PDP status.
+ return false;
+ }
+ return true;
+ }
+
+ private XACMLPapServlet getPapInstance() {
+ return new XACMLPapServlet();
+ }
+
+}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/XACMLPapServlet.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/XACMLPapServlet.java
index 680c4d579..30d09edb5 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/XACMLPapServlet.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/XACMLPapServlet.java
@@ -2,7 +2,7 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -20,34 +20,28 @@
package org.onap.policy.pap.xacml.rest;
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.api.pap.PDPPolicy;
+import com.att.research.xacml.api.pap.PDPStatus;
+import com.att.research.xacml.util.FactoryException;
+import com.att.research.xacml.util.XACMLProperties;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Splitter;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
-import java.io.UnsupportedEncodingException;
-import java.net.ConnectException;
-import java.net.HttpURLConnection;
import java.net.InetAddress;
-import java.net.MalformedURLException;
-import java.net.SocketTimeoutException;
-import java.net.URL;
-import java.net.URLDecoder;
import java.net.UnknownHostException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
-import java.util.Objects;
import java.util.Properties;
-import java.util.Scanner;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
-
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.PersistenceException;
@@ -59,7 +53,6 @@ import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-
import org.apache.commons.io.IOUtils;
import org.onap.policy.common.ia.IntegrityAudit;
import org.onap.policy.common.im.AdministrativeStateException;
@@ -74,6 +67,7 @@ import org.onap.policy.common.logging.eelf.MessageCodes;
import org.onap.policy.common.logging.eelf.PolicyLogger;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.pap.xacml.rest.components.HandleIncomingNotifications;
import org.onap.policy.pap.xacml.rest.components.PolicyDBDao;
import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTransaction;
import org.onap.policy.pap.xacml.rest.handler.APIRequestHandler;
@@ -96,31 +90,18 @@ import org.onap.policy.xacml.std.pap.StdPDPItemSetChangeNotifier.StdItemSetChang
import org.onap.policy.xacml.std.pap.StdPDPPolicy;
import org.onap.policy.xacml.std.pap.StdPDPStatus;
-import com.att.research.xacml.api.pap.PAPException;
-import com.att.research.xacml.api.pap.PDPPolicy;
-import com.att.research.xacml.api.pap.PDPStatus;
-import com.att.research.xacml.util.FactoryException;
-import com.att.research.xacml.util.XACMLProperties;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.base.Splitter;
-
/**
* Servlet implementation class XacmlPapServlet
*/
-@WebServlet(
- description = "Implements the XACML PAP RESTful API.",
- urlPatterns = {"/"},
- loadOnStartup = 1,
- initParams = {
- @WebInitParam(name = "XACML_PROPERTIES_NAME", value = "xacml.pap.properties",
- description = "The location of the properties file holding configuration information.")
- })
+@WebServlet(description = "Implements the XACML PAP RESTful API.", urlPatterns = {"/"}, loadOnStartup = 1,
+ initParams = {@WebInitParam(name = "XACML_PROPERTIES_NAME", value = "xacml.pap.properties",
+ description = "The location of the properties file holding configuration information.")})
public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeListener, Runnable {
private static final long serialVersionUID = 1L;
private static final Logger LOGGER = FlexLogger.getLogger(XACMLPapServlet.class);
// audit (transaction) LOGGER
private static final Logger auditLogger = FlexLogger.getLogger("auditLogger");
- //Persistence Unit for JPA
+ // Persistence Unit for JPA
private static final String PERSISTENCE_UNIT = "XACML-PAP-REST";
private static final String AUDIT_PAP_PERSISTENCE_UNIT = "auditPapPU";
// Client Headers.
@@ -131,27 +112,25 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
private static final String REGEX = "[0-9a-zA-Z._ ]*";
/*
- * List of Admin Console URLs.
- * Used to send notifications when configuration changes.
+ * List of Admin Console URLs. Used to send notifications when configuration changes.
*
- * The CopyOnWriteArrayList *should* protect from concurrency errors.
- * This list is seldom changed but often read, so the costs of this approach make sense.
+ * The CopyOnWriteArrayList *should* protect from concurrency errors. This list is seldom changed
+ * but often read, so the costs of this approach make sense.
*/
private static final CopyOnWriteArrayList<String> adminConsoleURLStringList = new CopyOnWriteArrayList<>();
private static String configHome;
private static String actionHome;
/*
- * This PAP instance's own URL.
- * Need this when creating URLs to send to the PDPs so they can GET the Policy files from this process.
+ * This PAP instance's own URL. Need this when creating URLs to send to the PDPs so they can GET the
+ * Policy files from this process.
*/
- private static String papURL = null;
+ public static String papURL = null;
// The heartbeat thread.
private static Heartbeat heartbeat = null;
private static Thread heartbeatThread = null;
- //The entity manager factory for JPA access
private static EntityManagerFactory emf;
- private static PolicyDBDao policyDBDao;
+ public static PolicyDBDao policyDBDao;
/*
* papEngine - This is our engine workhorse that manages the PDP Groups and Nodes.
*/
@@ -163,7 +142,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
private static String papDbDriver = null;
private static String papDbUrl = null;
private static String papDbUser = null;
- private static String papDbPassword = null;
+ private static String papDbPd = null;
private static String papResourceName = null;
private static String[] papDependencyGroupsFlatArray = null;
private static String environment = null;
@@ -172,7 +151,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
private transient IntegrityMonitor im;
private transient IntegrityAudit ia;
- //MicroService Model Properties
+ // MicroService Model Properties
private static String msOnapName;
private static String msPolicyName;
/*
@@ -181,6 +160,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
*/
private static transient Thread initiateThread = null;
private transient ONAPLoggingContext baseLoggingContext = null;
+ private static final String GROUPID = "groupId";
/**
* @see HttpServlet#HttpServlet()
@@ -192,6 +172,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
/**
* @see Servlet#init(ServletConfig)
*/
+ @Override
public void init(ServletConfig config) throws ServletException {
try {
// Logging
@@ -203,6 +184,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
} catch (UnknownHostException e) {
LOGGER.warn(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "Unable to get hostname for logging", e);
}
+
// Initialize
XACMLRest.xacmlInit(config);
// Load the properties
@@ -223,13 +205,15 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
" ERROR: Bad papNodeType property entry");
throw new PAPException("papNodeType is null");
}
- //Integer will throw an exception of anything is missing or unrecognized
+ // Integer will throw an exception of anything is missing or
+ // unrecognized
int papTransWait = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT));
int papTransTimeout =
Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT));
int papAuditTimeout =
Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_AUDIT_TIMEOUT));
- //Boolean will default to false if anything is missing or unrecognized
+ // Boolean will default to false if anything is missing or
+ // unrecognized
boolean papAuditFlag =
Boolean.parseBoolean(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_RUN_AUDIT_FLAG));
boolean papFileSystemAudit =
@@ -239,7 +223,8 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
throw new PAPException("papDependencyGroups is null");
}
setPAPDependencyGroups(papDependencyGroups);
- //Integer will throw an exception of anything is missing or unrecognized
+ // Integer will throw an exception of anything is missing or
+ // unrecognized
int fpMonitorInterval =
Integer.parseInt(XACMLProperties.getProperty(IntegrityMonitorProperties.FP_MONITOR_INTERVAL));
int failedCounterThreshold =
@@ -248,41 +233,26 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
Integer.parseInt(XACMLProperties.getProperty(IntegrityMonitorProperties.TEST_TRANS_INTERVAL));
int writeFpcInterval =
Integer.parseInt(XACMLProperties.getProperty(IntegrityMonitorProperties.WRITE_FPC_INTERVAL));
- LOGGER.debug("\n\n\n**************************************"
- + "\n*************************************"
- + "\n"
- + "\n papDbDriver = " + papDbDriver
- + "\n papDbUrl = " + papDbUrl
- + "\n papDbUser = " + papDbUser
- + "\n papTransWait = " + papTransWait
- + "\n papTransTimeout = " + papTransTimeout
- + "\n papAuditTimeout = " + papAuditTimeout
- + "\n papAuditFlag = " + papAuditFlag
- + "\n papFileSystemAudit = " + papFileSystemAudit
- + "\n papResourceName = " + papResourceName
- + "\n fpMonitorInterval = " + fpMonitorInterval
- + "\n failedCounterThreshold = " + failedCounterThreshold
- + "\n testTransInterval = " + testTransInterval
- + "\n writeFpcInterval = " + writeFpcInterval
- + "\n papSiteName = " + papSiteName
- + "\n papNodeType = " + papNodeType
- + "\n papDependencyGroupsList = " + papDependencyGroups
- + "\n papIntegrityAuditPeriodSeconds = " + papIntegrityAuditPeriodSeconds
- + "\n\n*************************************"
+ LOGGER.debug("\n\n\n**************************************" + "\n*************************************"
+ + "\n" + "\n papDbDriver = " + papDbDriver + "\n papDbUrl = " + papDbUrl + "\n papDbUser = "
+ + papDbUser + "\n papTransWait = " + papTransWait + "\n papTransTimeout = " + papTransTimeout
+ + "\n papAuditTimeout = " + papAuditTimeout + "\n papAuditFlag = " + papAuditFlag
+ + "\n papFileSystemAudit = " + papFileSystemAudit + "\n papResourceName = " + papResourceName
+ + "\n fpMonitorInterval = " + fpMonitorInterval + "\n failedCounterThreshold = "
+ + failedCounterThreshold + "\n testTransInterval = " + testTransInterval + "\n writeFpcInterval = "
+ + writeFpcInterval + "\n papSiteName = " + papSiteName + "\n papNodeType = " + papNodeType
+ + "\n papDependencyGroupsList = " + papDependencyGroups + "\n papIntegrityAuditPeriodSeconds = "
+ + papIntegrityAuditPeriodSeconds + "\n\n*************************************"
+ "\n**************************************");
// Pull custom persistence settings
Properties properties;
try {
properties = XACMLProperties.getProperties();
- LOGGER.debug("\n\n\n**************************************"
- + "\n**************************************"
- + "\n\n"
- + "properties = " + properties
- + "\n\n**************************************");
+ LOGGER.debug("\n\n\n**************************************" + "\n**************************************"
+ + "\n\n" + "properties = " + properties + "\n\n**************************************");
} catch (IOException e) {
- PolicyLogger
- .error(MessageCodes.ERROR_DATA_ISSUE, e, "XACMLPapServlet", " Error loading properties with: "
- + "XACMLProperties.getProperties()");
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "XACMLPapServlet",
+ " Error loading properties with: " + "XACMLProperties.getProperties()");
throw new ServletException(e.getMessage(), e.getCause());
}
// Create an IntegrityMonitor
@@ -294,49 +264,33 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
// Create an IntegrityAudit
ia = new IntegrityAudit(papResourceName, AUDIT_PAP_PERSISTENCE_UNIT, properties);
ia.startAuditThread();
- // Create the entity manager factory
- setEMF(properties);
+
// we are about to call the PDPs and give them their configuration.
- // To do that we need to have the URL of this PAP so we can construct the Policy file URLs
+ // To do that we need to have the URL of this PAP so we can
+ // construct the Policy file URLs
setPAPURL(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_URL));
- //Create the policyDBDao
+ // Create the policyDBDao
setPolicyDBDao();
// Load our PAP engine, first create a factory
ONAPPapEngineFactory factory = ONAPPapEngineFactory
.newInstance(XACMLProperties.getProperty(XACMLProperties.PROP_PAP_PAPENGINEFACTORY));
// The factory knows how to go about creating a PAP Engine
- setPAPEngine((PAPPolicyEngine) factory.newEngine());
- PolicyDBDaoTransaction addNewGroup = null;
+ setPAPEngine(factory.newEngine());
if (((org.onap.policy.xacml.std.pap.StdEngine) papEngine).wasDefaultGroupJustAdded) {
- try {
- addNewGroup = policyDBDao.getNewTransaction();
- OnapPDPGroup group = papEngine.getDefaultGroup();
- addNewGroup.createGroup(group.getId(), group.getName(), group.getDescription(),
- "automaticallyAdded");
- addNewGroup.commitTransaction();
- addNewGroup = policyDBDao.getNewTransaction();
- addNewGroup.changeDefaultGroup(group, "automaticallyAdded");
- addNewGroup.commitTransaction();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet",
- " Error creating new default group in the database");
- if (addNewGroup != null) {
- addNewGroup.rollbackTransaction();
- }
- }
+ createDefaultGroupOnInit();
}
- policyDBDao.setPapEngine((PAPPolicyEngine) XACMLPapServlet.papEngine);
+ policyDBDao.setPapEngine(XACMLPapServlet.papEngine);
if (Boolean.parseBoolean(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_RUN_AUDIT_FLAG))) {
/*
* Auditing the local File System groups to be in sync with the Database
*/
- //get an AuditTransaction to lock out all other transactions
+ // get an AuditTransaction to lock out all other transactions
PolicyDBDaoTransaction auditTrans = policyDBDao.getNewAuditTransaction();
LOGGER.info("PapServlet: calling auditLocalFileSystem for PDP group audit");
LOGGER.info("PapServlet: old group is " + papEngine.getDefaultGroup().toString());
- //get the current filesystem group and update from the database if needed
+ // get the current filesystem group and update from the database if needed
StdPDPGroup group = (StdPDPGroup) papEngine.getDefaultGroup();
StdPDPGroup updatedGroup = policyDBDao.auditLocalFileSystem(group);
if (updatedGroup != null) {
@@ -344,23 +298,23 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
}
LOGGER.info("PapServlet: updated group is " + papEngine.getDefaultGroup().toString());
- //release the transaction lock
+ // sync up the config data from DB to file system
+ LOGGER.info("PapServlet: Sync config data from DB to file system");
+ policyDBDao.synchronizeConfigDataInFileSystem();
+
+ // release the transaction lock
auditTrans.close();
}
- // Sanity check for URL.
- if (XACMLPapServlet.papURL == null) {
- throw new PAPException("The property " + XACMLRestProperties.PROP_PAP_URL + " is not valid: " +
- XACMLPapServlet.papURL);
- }
- // Configurable - have the PAP servlet initiate sending the latest PDP policy/pip configuration
+ // Configurable - have the PAP servlet initiate sending the latest
+ // PDP policy/pip configuration
// to all its known PDP nodes.
if (Boolean.parseBoolean(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_INITIATE_PDP_CONFIG))) {
startInitiateThreadService(new Thread(this));
}
- // After startup, the PAP does Heartbeat's to each of the PDPs periodically
- startHeartBeatService(new Heartbeat((PAPPolicyEngine) XACMLPapServlet.papEngine));
-
+ // After startup, the PAP does Heartbeat's to each of the PDPs
+ // periodically
+ startHeartBeatService(new Heartbeat(XACMLPapServlet.papEngine));
} catch (FactoryException | PAPException e) {
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Failed to create engine");
throw new ServletException(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "PAP not initialized; error: " + e);
@@ -370,6 +324,26 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
throw new ServletException(
XACMLErrorConstants.ERROR_SYSTEM_ERROR + "PAP not initialized; unexpected error: " + e);
}
+
+ }
+
+ private void createDefaultGroupOnInit() {
+ PolicyDBDaoTransaction addNewGroup = null;
+ try {
+ addNewGroup = policyDBDao.getNewTransaction();
+ OnapPDPGroup group = papEngine.getDefaultGroup();
+ addNewGroup.createGroup(group.getId(), group.getName(), group.getDescription(), "automaticallyAdded");
+ addNewGroup.commitTransaction();
+ addNewGroup = policyDBDao.getNewTransaction();
+ addNewGroup.changeDefaultGroup(group, "automaticallyAdded");
+ addNewGroup.commitTransaction();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet",
+ " Error creating new default group in the database");
+ if (addNewGroup != null) {
+ addNewGroup.rollbackTransaction();
+ }
+ }
}
private static void startInitiateThreadService(Thread thread) {
@@ -393,7 +367,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
private static void setPolicyDBDao() throws ServletException {
try {
- policyDBDao = PolicyDBDao.getPolicyDBDaoInstance(getEmf());
+ policyDBDao = PolicyDBDao.getPolicyDBDaoInstance();
} catch (Exception e) {
throw new ServletException("Unable to Create Policy DBDao Instance", e);
}
@@ -402,9 +376,8 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
private static void setEMF(Properties properties) throws ServletException {
emf = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT, properties);
if (emf == null) {
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE +
- " Error creating entity manager factory with persistence unit: "
- + PERSISTENCE_UNIT);
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE
+ + " Error creating entity manager factory with persistence unit: " + PERSISTENCE_UNIT);
throw new ServletException("Unable to create Entity Manager Factory");
}
}
@@ -419,9 +392,9 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
private static void setPAPDependencyGroups(String papDependencyGroups) throws PAPException {
try {
- //Now we have flattened the array into a simple comma-separated list
+ // Now we have flattened the array into a simple comma-separated list
papDependencyGroupsFlatArray = papDependencyGroups.split("[;,]");
- //clean up the entries
+ // clean up the entries
for (int i = 0; i < papDependencyGroupsFlatArray.length; i++) {
papDependencyGroupsFlatArray[i] = papDependencyGroupsFlatArray[i].trim();
}
@@ -448,8 +421,8 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
setActionHome();
papDbDriver = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_DRIVER);
if (papDbDriver == null) {
- PolicyLogger
- .error(MessageCodes.ERROR_DATA_ISSUE, "XACMLPapServlet", " ERROR: Bad papDbDriver property entry");
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, "XACMLPapServlet",
+ " ERROR: Bad papDbDriver property entry");
throw new PAPException("papDbDriver is null");
}
setPapDbDriver(papDbDriver);
@@ -461,19 +434,19 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
setPapDbUrl(papDbUrl);
papDbUser = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_USER);
if (papDbUser == null) {
- PolicyLogger
- .error(MessageCodes.ERROR_DATA_ISSUE, "XACMLPapServlet", " ERROR: Bad papDbUser property entry");
+ PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, "XACMLPapServlet",
+ " ERROR: Bad papDbUser property entry");
throw new PAPException("papDbUser is null");
}
setPapDbUser(papDbUser);
- papDbPassword = CryptoUtils
+ papDbPd = CryptoUtils
.decryptTxtNoExStr(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_PASSWORD, ""));
- if (papDbPassword == null) {
+ if (papDbPd == null) {
PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, "XACMLPapServlet",
" ERROR: Bad papDbPassword property entry");
throw new PAPException("papDbPassword is null");
}
- setPapDbPassword(papDbPassword);
+ setPapDbPassword(papDbPd);
papResourceName = XACMLProperties.getProperty(XACMLRestProperties.PAP_RESOURCE_NAME);
if (papResourceName == null) {
PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, "XACMLPapServlet",
@@ -481,24 +454,24 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
throw new PAPException("papResourceName is null");
}
environment = XACMLProperties.getProperty("ENVIRONMENT", "DEVL");
- //Micro Service Properties
+ // Micro Service Properties
msOnapName = XACMLProperties.getProperty("xacml.policy.msOnapName");
setMsOnapName(msOnapName);
msPolicyName = XACMLProperties.getProperty("xacml.policy.msPolicyName");
setMsPolicyName(msPolicyName);
- // PDPId File location
+ // PDPId File location
XACMLPapServlet.pdpFile = XACMLProperties.getProperty(XACMLRestProperties.PROP_PDP_IDFILE);
if (XACMLPapServlet.pdpFile == null) {
PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " The PDP Id Authentication File Property is not valid: "
+ XACMLRestProperties.PROP_PDP_IDFILE);
- throw new PAPException("The PDP Id Authentication File Property :" + XACMLRestProperties.PROP_PDP_IDFILE +
- " is not Valid. ");
+ throw new PAPException("The PDP Id Authentication File Property :" + XACMLRestProperties.PROP_PDP_IDFILE
+ + " is not Valid. ");
}
}
/**
- * Thread used only during PAP startup to initiate change messages to all known PDPs.
- * This must be on a separate thread so that any GET requests from the PDPs during this update can be serviced.
+ * Thread used only during PAP startup to initiate change messages to all known PDPs. This must be
+ * on a separate thread so that any GET requests from the PDPs during this update can be serviced.
*/
@Override
public void run() {
@@ -508,9 +481,9 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
/**
* @see Servlet#destroy()
- * <p>
- * Depending on how this servlet is run, we may or may not care about cleaning up the resources.
- * For now we assume that we do care.
+ * <p>
+ * Depending on how this servlet is run, we may or may not care about cleaning up the
+ * resources. For now we assume that we do care.
*/
@Override
public void destroy() {
@@ -539,35 +512,31 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
}
}
+ private ConsoleAndApiService getAcServiceInstance() {
+ return new ConsoleAndApiService();
+ }
+
/**
- * Called by:
- * - PDP nodes to register themselves with the PAP, and
- * - Admin Console to make changes in the PDP Groups.
+ * Called by: - PDP nodes to register themselves with the PAP, and - Admin Console to make changes
+ * in the PDP Groups.
*
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
+ @Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
ONAPLoggingContext loggingContext = ONAPLoggingUtils.getLoggingContextForRequest(request, baseLoggingContext);
- loggingContext.transactionStarted();
- loggingContext.setServiceName("PAP.post");
- if ((loggingContext.getRequestID() == null) || (Objects.equals(loggingContext.getRequestID(), ""))) {
- UUID requestID = UUID.randomUUID();
- loggingContext.setRequestID(requestID.toString());
- PolicyLogger.info("requestID not provided in call to XACMLPapSrvlet (doPost) so we generated one");
- } else {
- PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (doPost)");
- }
+ setLoggingContext(loggingContext, "doPost", "PAP.post");
PolicyDBDaoTransaction pdpTransaction = null;
- loggingContext.metricStarted();
try {
+ loggingContext.metricStarted();
im.startTransaction();
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet doPost im startTransaction");
} catch (AdministrativeStateException ae) {
String message = "POST interface called for PAP " + papResourceName + " but it has an Administrative"
- + " state of " + im.getStateManager().getAdminState()
- + "\n Exception Message: " + PolicyUtils.CATCH_EXCEPTION;
+ + " state of " + im.getStateManager().getAdminState() + "\n Exception Message: "
+ + PolicyUtils.CATCH_EXCEPTION;
LOGGER.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message, ae);
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet doPost im startTransaction");
@@ -577,8 +546,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
return;
} catch (StandbyStatusException se) {
String message = "POST interface called for PAP " + papResourceName + " but it has a Standby Status"
- + " of " + im.getStateManager().getStandbyStatus()
- + "\n Exception Message: " + se.getMessage();
+ + " of " + im.getStateManager().getStandbyStatus() + "\n Exception Message: " + se.getMessage();
LOGGER.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message, se);
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet doPost im startTransaction");
@@ -586,31 +554,24 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
PolicyLogger.audit("Transaction Failed - See Error.log");
setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
return;
- } catch (IntegrityMonitorException e) {
- String message = "POST interface called for PAP " + papResourceName + " but an exception occurred"
- + "\n Exception Message: " + e.getMessage();
- LOGGER.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message, e);
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doPost im startTransaction");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
- return;
}
try {
loggingContext.metricStarted();
XACMLRest.dumpRequest(request);
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet doPost dumpRequest");
- // since getParameter reads the content string, explicitly get the content before doing that.
- // Simply getting the inputStream seems to protect it against being consumed by getParameter.
+ // since getParameter reads the content string, explicitly get the
+ // content before doing that.
+ // Simply getting the inputStream seems to protect it against being
+ // consumed by getParameter.
request.getInputStream();
- String groupId = request.getParameter("groupId");
+ String groupId = request.getParameter(GROUPID);
String apiflag = request.getParameter("apiflag");
if (groupId != null) {
// Is this from the Admin Console or API?
- if (apiflag != null && apiflag.equalsIgnoreCase("api")) {
- // this is from the API so we need to check the client credentials before processing the request
+ if (apiflag != null && "api".equalsIgnoreCase(apiflag)) {
+ // this is from the API so we need to check the client
+ // credentials before processing the request
if (!authorizeRequest(request)) {
String message = "PEP not Authorized for making this Request!!";
PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + " " + message);
@@ -622,7 +583,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
}
}
loggingContext.metricStarted();
- doACPost(request, response, groupId, loggingContext);
+ getAcServiceInstance().doAcPost(request, response, groupId, loggingContext, papEngine);
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet doPost doACPost");
loggingContext.transactionEnded();
@@ -649,7 +610,8 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
"Registered on first startup", Integer.parseInt(jmxport), "PDP autoregister");
XACMLPapServlet.papEngine.newPDP(id, XACMLPapServlet.papEngine.getDefaultGroup(), id,
"Registered on first startup", Integer.parseInt(jmxport));
- } catch (NullPointerException | PAPException | IllegalArgumentException | IllegalStateException | PersistenceException | PolicyDBException e) {
+ } catch (NullPointerException | PAPException | IllegalArgumentException | IllegalStateException
+ | PersistenceException | PolicyDBException e) {
pdpTransaction.rollbackTransaction();
String message = "Failed to create new PDP for id: " + id;
PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " " + message);
@@ -682,8 +644,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
loggingContext.transactionEnded();
PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + " " + message);
setResponseError(response, HttpServletResponse.SC_UNAUTHORIZED,
- "PDP not Authorized to connect to this PAP. Please contact the PAP Admin for registration" +
- ".");
+ "PDP not Authorized to connect to this PAP. Please contact the PAP Admin for registration.");
PolicyLogger.audit("Transaction Failed - See Error.log");
im.endTransaction();
return;
@@ -698,7 +659,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
"Could not commit transaction to put pdp in the database");
}
}
- if (jmxport != null && !Objects.equals(jmxport, "")) {
+ if (jmxport != null && !"".equals(jmxport)) {
try {
((StdPDP) pdp).setJmxPort(Integer.valueOf(jmxport));
} catch (NumberFormatException e) {
@@ -708,13 +669,13 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
// Get the PDP's Group
OnapPDPGroup group = null;
try {
- group = XACMLPapServlet.papEngine.getPDPGroup((OnapPDP) pdp);
+ group = XACMLPapServlet.papEngine.getPDPGroup(pdp);
} catch (PAPException e) {
LOGGER.error(e);
}
if (group == null) {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW +
- " PDP not associated with any group, even the default");
+ PolicyLogger.error(
+ MessageCodes.ERROR_PROCESS_FLOW + " PDP not associated with any group, even the default");
loggingContext.transactionEnded();
PolicyLogger.audit("Transaction Failed - See Error.log");
setResponseError(response, HttpServletResponse.SC_UNAUTHORIZED,
@@ -739,8 +700,9 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
// Validate the node's properties
boolean isCurrent = this.isPDPCurrent(policies, pipconfig, pdpProperties);
// Send back current configuration
- if (isCurrent == false) {
- // Tell the PDP we are sending back the current policies/pip config
+ if (!isCurrent) {
+ // Tell the PDP we are sending back the current policies/pip
+ // config
LOGGER.info("PDP configuration NOT current.");
if (policies != null) {
// Put URL's into the properties in case the PDP needs to
@@ -777,12 +739,6 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
LOGGER.error(e);
}
}
- // tell the AC that something changed
- loggingContext.metricStarted();
- notifyAC();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doPost notifyAC");
- loggingContext.transactionEnded();
auditLogger.info("Success");
PolicyLogger.audit("Transaction Ended Successfully");
} catch (PAPException | IOException | NumberFormatException e) {
@@ -796,7 +752,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
im.endTransaction();
return;
}
- //Catch anything that fell through
+ // Catch anything that fell through
loggingContext.transactionEnded();
PolicyLogger.audit("Transaction Ended");
im.endTransaction();
@@ -815,36 +771,27 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
+ @Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
ONAPLoggingContext loggingContext = ONAPLoggingUtils.getLoggingContextForRequest(request, baseLoggingContext);
- loggingContext.transactionStarted();
- loggingContext.setServiceName("PAP.get");
- if ((loggingContext.getRequestID() == null) || (Objects.equals(loggingContext.getRequestID(), ""))) {
- UUID requestID = UUID.randomUUID();
- loggingContext.setRequestID(requestID.toString());
- PolicyLogger.info("requestID not provided in call to XACMLPapSrvlet (doGet) so we generated one");
- } else {
- PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (doGet)");
- }
+ setLoggingContext(loggingContext, "doGet", "PAP.get");
loggingContext.metricStarted();
XACMLRest.dumpRequest(request);
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet doGet dumpRequest");
String pathInfo = request.getRequestURI();
LOGGER.info("path info: " + pathInfo);
- if (pathInfo != null) {
- //DO NOT do a im.startTransaction for the test request
- if (pathInfo.equals("/pap/test")) {
- try {
- testService(loggingContext, response);
- } catch (IOException e) {
- LOGGER.debug(e);
- }
- return;
+ if (pathInfo != null && "/pap/test".equals(pathInfo)) {
+ // DO NOT do a im.startTransaction for the test request
+ try {
+ testService(loggingContext, response);
+ } catch (IOException e) {
+ LOGGER.debug(e);
}
+ return;
}
- //This im.startTransaction() covers all other Get transactions
+ // This im.startTransaction() covers all other Get transactions
try {
loggingContext.metricStarted();
im.startTransaction();
@@ -852,8 +799,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
PolicyLogger.metrics("XACMLPapServlet doGet im startTransaction");
} catch (AdministrativeStateException ae) {
String message = "GET interface called for PAP " + papResourceName + " but it has an Administrative"
- + " state of " + im.getStateManager().getAdminState()
- + "\n Exception Message: " + ae.getMessage();
+ + " state of " + im.getStateManager().getAdminState() + "\n Exception Message: " + ae.getMessage();
LOGGER.info(message, ae);
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message);
loggingContext.transactionEnded();
@@ -861,24 +807,14 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
return;
} catch (StandbyStatusException se) {
- String message = "GET interface called for PAP " + papResourceName + " but it has a Standby Status"
- + " of " + im.getStateManager().getStandbyStatus()
- + "\n Exception Message: " + se.getMessage();
+ String message = "GET interface called for PAP " + papResourceName + " but it has a Standby Status" + " of "
+ + im.getStateManager().getStandbyStatus() + "\n Exception Message: " + se.getMessage();
LOGGER.info(message, se);
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message);
loggingContext.transactionEnded();
PolicyLogger.audit("Transaction Failed - See Error.log");
setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
return;
- } catch (IntegrityMonitorException e) {
- String message = "GET interface called for PAP " + papResourceName + " but an exception occurred"
- + "\n Exception Message: " + e.getMessage();
- LOGGER.info(message, e);
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
- return;
}
// Request from the API to get the gitPath
String apiflag = request.getParameter("apiflag");
@@ -909,12 +845,12 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
}
}
// Is this from the Admin Console?
- String groupId = request.getParameter("groupId");
+ String groupId = request.getParameter(GROUPID);
if (groupId != null) {
// this is from the Admin Console, so handle separately
try {
loggingContext.metricStarted();
- doACGet(request, response, groupId, loggingContext);
+ getAcServiceInstance().doAcGet(request, response, groupId, loggingContext, papEngine);
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet doGet doACGet");
} catch (IOException e) {
@@ -938,8 +874,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
// Is it known?
if (pdp == null) {
// Check if request came from localhost
- if (request.getRemoteHost().equals("localhost") ||
- request.getRemoteHost().equals(request.getLocalAddr())) {
+ if ("localhost".equals(request.getRemoteHost()) || request.getRemoteHost().equals(request.getLocalAddr())) {
// Return status information - basically all the groups
loggingContext.setServiceName("PAP.getGroups");
Set<OnapPDPGroup> groups = null;
@@ -976,7 +911,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
// Get the PDP's Group
OnapPDPGroup group = null;
try {
- group = XACMLPapServlet.papEngine.getPDPGroup((OnapPDP) pdp);
+ group = XACMLPapServlet.papEngine.getPDPGroup(pdp);
} catch (PAPException e) {
LOGGER.error(e);
}
@@ -1011,14 +946,14 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
return;
}
try {
- LOGGER.warn("PolicyDebugging: Policy Validity: " + policy.isValid() + "\n "
- + "Policy Name : " + policy.getName() + "\n Policy URI: " + policy.getLocation().toString());
+ LOGGER.warn("PolicyDebugging: Policy Validity: " + policy.isValid() + "\n " + "Policy Name : "
+ + policy.getName() + "\n Policy URI: " + policy.getLocation().toString());
} catch (PAPException | IOException e) {
LOGGER.error(e);
}
- try (InputStream is = new FileInputStream(
- ((StdPDPGroup) group).getDirectory().toString() + File.separator + policyId);
- OutputStream os = response.getOutputStream()) {
+ try (InputStream is =
+ new FileInputStream(((StdPDPGroup) group).getDirectory().toString() + File.separator + policyId);
+ OutputStream os = response.getOutputStream()) {
// Send the policy back
IOUtils.copy(is, os);
response.setStatus(HttpServletResponse.SC_OK);
@@ -1041,18 +976,11 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
/**
* @see HttpServlet#doPut(HttpServletRequest request, HttpServletResponse response)
*/
+ @Override
protected void doPut(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
ONAPLoggingContext loggingContext = ONAPLoggingUtils.getLoggingContextForRequest(request, baseLoggingContext);
- loggingContext.transactionStarted();
- loggingContext.setServiceName("PAP.put");
- if ((loggingContext.getRequestID() == null) || (Objects.equals(loggingContext.getRequestID(), ""))) {
- UUID requestID = UUID.randomUUID();
- loggingContext.setRequestID(requestID.toString());
- PolicyLogger.info("requestID not provided in call to XACMLPapSrvlet (doPut) so we generated one");
- } else {
- PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (doPut)");
- }
+ setLoggingContext(loggingContext, "doPut", "PAP.put");
try {
loggingContext.metricStarted();
im.startTransaction();
@@ -1061,11 +989,9 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
} catch (IntegrityMonitorException e) {
String message = "PUT interface called for PAP " + papResourceName;
if (e instanceof AdministrativeStateException) {
- message += " but it has an Administrative state of "
- + im.getStateManager().getAdminState();
+ message += " but it has an Administrative state of " + im.getStateManager().getAdminState();
} else if (e instanceof StandbyStatusException) {
- message += " but it has a Standby Status of "
- + im.getStateManager().getStandbyStatus();
+ message += " but it has a Standby Status of " + im.getStateManager().getStandbyStatus();
} else {
message += " but an exception occurred";
@@ -1081,12 +1007,16 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
}
loggingContext.metricStarted();
- XACMLRest.dumpRequest(request);
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doPut dumpRequest");
- //need to check if request is from the API or Admin console
+ // need to check if request is from the API or Admin console
String apiflag = request.getParameter("apiflag");
- //This would occur if a PolicyDBDao notification was received
+ // For Debug purposes
+ if (!"api".equals(apiflag) && PolicyLogger.isDebugEnabled()) {
+ XACMLRest.dumpRequest(request);
+ PolicyLogger.metrics("XACMLPapServlet doPut dumpRequest");
+ }
+ loggingContext.metricEnded();
+
+ // This would occur if a PolicyDBDao notification was received
String policyDBDaoRequestUrl = request.getParameter("policydbdaourl");
if (policyDBDaoRequestUrl != null) {
LOGGER.info("XACMLPapServlet: PolicyDBDao Notification received.");
@@ -1102,8 +1032,9 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
}
loggingContext.metricStarted();
LOGGER.info("XACMLPapServlet: Calling PolicyDBDao to handlIncomingHttpNotification");
- policyDBDao.handleIncomingHttpNotification(policyDBDaoRequestUrl, policyDBDaoRequestEntityId,
- policyDBDaoRequestEntityType, policyDBDaoRequestExtraData, this);
+ HandleIncomingNotifications handleIncomingNotifications = new HandleIncomingNotifications();
+ handleIncomingNotifications.handleIncomingHttpNotification(policyDBDaoRequestUrl,
+ policyDBDaoRequestEntityId, policyDBDaoRequestEntityType, policyDBDaoRequestExtraData, this);
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet doPut handle incoming http notification");
response.setStatus(200);
@@ -1160,11 +1091,11 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
return;
}
/*
- * This is to update the PDP Group with the policy/policies being pushed
- * Part of a 2 step process to push policies to the PDP that can now be done
- * From both the Admin Console and the PolicyEngine API
+ * This is to update the PDP Group with the policy/policies being pushed Part of a 2 step process to
+ * push policies to the PDP that can now be done From both the Admin Console and the PolicyEngine
+ * API
*/
- String groupId = request.getParameter("groupId");
+ String groupId = request.getParameter(GROUPID);
if (groupId != null) {
if (apiflag != null) {
if (!authorizeRequest(request)) {
@@ -1191,7 +1122,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
// this is from the Admin Console, so handle separately
try {
loggingContext.metricEnded();
- doACPut(request, response, groupId, loggingContext);
+ getAcServiceInstance().doAcPut(request, response, groupId, loggingContext, papEngine);
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet goPut doACPut");
} catch (IOException e) {
@@ -1260,18 +1191,11 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
/**
* @see HttpServlet#doDelete(HttpServletRequest request, HttpServletResponse response)
*/
+ @Override
protected void doDelete(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
ONAPLoggingContext loggingContext = ONAPLoggingUtils.getLoggingContextForRequest(request, baseLoggingContext);
- loggingContext.transactionStarted();
- loggingContext.setServiceName("PAP.delete");
- if ((loggingContext.getRequestID() == null) || (Objects.equals(loggingContext.getRequestID(), ""))) {
- UUID requestID = UUID.randomUUID();
- loggingContext.setRequestID(requestID.toString());
- PolicyLogger.info("requestID not provided in call to XACMLPapSrvlet (doDelete) so we generated one");
- } else {
- PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (doDelete)");
- }
+ setLoggingContext(loggingContext, "doDelete", "PAP.delete");
try {
loggingContext.metricStarted();
im.startTransaction();
@@ -1279,8 +1203,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
PolicyLogger.metrics("XACMLPapServlet doDelete im startTransaction");
} catch (AdministrativeStateException ae) {
String message = "DELETE interface called for PAP " + papResourceName + " but it has an Administrative"
- + " state of " + im.getStateManager().getAdminState()
- + "\n Exception Message: " + ae.getMessage();
+ + " state of " + im.getStateManager().getAdminState() + "\n Exception Message: " + ae.getMessage();
LOGGER.info(message, ae);
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message);
loggingContext.transactionEnded();
@@ -1288,30 +1211,20 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
return;
} catch (StandbyStatusException se) {
- String message = "PUT interface called for PAP " + papResourceName + " but it has a Standby Status"
- + " of " + im.getStateManager().getStandbyStatus()
- + "\n Exception Message: " + se.getMessage();
+ String message = "PUT interface called for PAP " + papResourceName + " but it has a Standby Status" + " of "
+ + im.getStateManager().getStandbyStatus() + "\n Exception Message: " + se.getMessage();
LOGGER.info(message, se);
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message);
loggingContext.transactionEnded();
PolicyLogger.audit("Transaction Failed - See Error.log");
setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
return;
- } catch (IntegrityMonitorException e) {
- String message = "PUT interface called for PAP " + papResourceName + " but an exception occurred"
- + "\n Exception Message: " + e.getMessage();
- LOGGER.info(message, e);
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
- return;
}
loggingContext.metricStarted();
XACMLRest.dumpRequest(request);
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet doDelete dumpRequest");
- String groupId = request.getParameter("groupId");
+ String groupId = request.getParameter(GROUPID);
String apiflag = request.getParameter("apiflag");
if (groupId != null) {
// Is this from the Admin Console or API?
@@ -1342,7 +1255,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
// this is from the Admin Console, so handle separately
try {
loggingContext.metricStarted();
- doACDelete(request, response, groupId, loggingContext);
+ getAcServiceInstance().doAcDelete(request, response, groupId, loggingContext, papEngine);
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet doDelete doACDelete");
} catch (IOException e) {
@@ -1353,7 +1266,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
im.endTransaction();
return;
}
- //Catch anything that fell through
+ // Catch anything that fell through
PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Request does not have groupId");
loggingContext.transactionEnded();
PolicyLogger.audit("Transaction Failed - See Error.log");
@@ -1365,8 +1278,8 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
String localRootPolicies = policies.getProperty(XACMLProperties.PROP_ROOTPOLICIES);
String localReferencedPolicies = policies.getProperty(XACMLProperties.PROP_REFERENCEDPOLICIES);
if (localRootPolicies == null || localReferencedPolicies == null) {
- LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE + "Missing property on PAP server: RootPolicies=" +
- localRootPolicies + " ReferencedPolicies=" + localReferencedPolicies);
+ LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE + "Missing property on PAP server: RootPolicies="
+ + localRootPolicies + " ReferencedPolicies=" + localReferencedPolicies);
return false;
}
// Compare the policies and pipconfig properties to the pdpProperties
@@ -1375,16 +1288,19 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
// xacml.referencedPolicies without any .url entries
Properties pdpPolicies = XACMLProperties.getPolicyProperties(pdpProperties, false);
Properties pdpPipConfig = XACMLProperties.getPipProperties(pdpProperties);
- if (localRootPolicies.equals(pdpPolicies.getProperty(XACMLProperties.PROP_ROOTPOLICIES)) &&
- localReferencedPolicies.equals(pdpPolicies.getProperty(XACMLProperties.PROP_REFERENCEDPOLICIES)) &&
- pdpPipConfig.equals(pipconfig)) {
+ if (localRootPolicies.equals(pdpPolicies.getProperty(XACMLProperties.PROP_ROOTPOLICIES))
+ && localReferencedPolicies.equals(pdpPolicies.getProperty(XACMLProperties.PROP_REFERENCEDPOLICIES))
+ && pdpPipConfig.equals(pipconfig)) {
// The PDP is current
return true;
}
} catch (Exception e) {
- // we get here if the PDP did not include either xacml.rootPolicies or xacml.pip.engines,
- // or if there are policies that do not have a corresponding ".url" property.
- // Either of these cases means that the PDP is not up-to-date, so just drop-through to return false.
+ // we get here if the PDP did not include either xacml.rootPolicies
+ // or xacml.pip.engines,
+ // or if there are policies that do not have a corresponding ".url"
+ // property.
+ // Either of these cases means that the PDP is not up-to-date, so
+ // just drop-through to return false.
PolicyLogger.error(MessageCodes.ERROR_SCHEMA_INVALID, e, "XACMLPapServlet", " PDP Error");
}
return false;
@@ -1419,8 +1335,8 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
String pdpJMMX = request.getHeader(XACMLRestProperties.PROP_PDP_HTTP_HEADER_JMX_PORT);
if (pdpJMMX == null || pdpJMMX.isEmpty()) {
// Should send back its port for identification
- LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE +
- "PDP did not send custom header for JMX Port so the value of 0 is assigned");
+ LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE
+ + "PDP did not send custom header for JMX Port so the value of 0 is assigned");
return null;
}
return pdpJMMX;
@@ -1437,11 +1353,13 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
* @throws IOException
*/
public void updateGroupsFromAPI(HttpServletRequest request, HttpServletResponse response, String groupId,
- ONAPLoggingContext loggingContext) throws IOException {
+ ONAPLoggingContext loggingContext) throws IOException {
PolicyDBDaoTransaction acPutTransaction = policyDBDao.getNewTransaction();
PolicyLogger.audit("PolicyDBDaoTransaction started for updateGroupsFromAPI");
try {
- // for PUT operations the group may or may not need to exist before the operation can be done
+ String userId = request.getParameter("userId");
+ // for PUT operations the group may or may not need to exist before
+ // the operation can be done
StdPDPGroup group = (StdPDPGroup) papEngine.getGroup(groupId);
// get the request input stream content into a String
@@ -1456,14 +1374,13 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
// convert Object sent as JSON into local object
StdPDPPolicy policy = PolicyUtils.jsonStringToObject(json, StdPDPPolicy.class);
- //Get the current policies from the Group and Add the new one
- Set<PDPPolicy> currentPoliciesInGroup = new HashSet<>();
- currentPoliciesInGroup = group.getPolicies();
- //If the selected policy is in the group we must remove the old version of it
+ // Get the current policies from the Group and Add the new one
+ // If the selected policy is in the group we must remove the old
+ // version of it
LOGGER.info("Removing old version of the policy");
- for (PDPPolicy existingPolicy : currentPoliciesInGroup) {
- if (existingPolicy.getName().equals(policy.getName()) &&
- !existingPolicy.getId().equals(policy.getId())) {
+ for (PDPPolicy existingPolicy : group.getPolicies()) {
+ if (existingPolicy.getName().equals(policy.getName())
+ && !existingPolicy.getId().equals(policy.getId())) {
group.removePolicy(existingPolicy);
LOGGER.info("Removing policy: " + existingPolicy);
break;
@@ -1473,11 +1390,10 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
// Assume that this is an update of an existing PDP Group
loggingContext.setServiceName("PolicyEngineAPI:PAP.updateGroup");
try {
- acPutTransaction.updateGroup(group, "XACMLPapServlet.doACPut");
+ acPutTransaction.updateGroup(group, "XACMLPapServlet.doACPut", null);
} catch (Exception e) {
PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet",
- " Error while updating group in the database: "
- + "group=" + group.getId());
+ " Error while updating group in the database: " + "group=" + group.getId());
throw new PAPException(e.getMessage());
}
@@ -1496,7 +1412,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
response.setStatus(HttpServletResponse.SC_NO_CONTENT);
response.addHeader("operation", "push");
response.addHeader("policyId", policyId);
- response.addHeader("groupId", groupId);
+ response.addHeader(GROUPID, groupId);
LOGGER.info("Group '" + group.getId() + "' updated");
@@ -1504,18 +1420,14 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
acPutTransaction.commitTransaction();
loggingContext.metricEnded();
PolicyLogger.metrics("XACMLPapServlet updateGroupsFromAPI commitTransaction");
- loggingContext.metricStarted();
- notifyAC();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet updateGroupsFromAPI notifyAC");
// Group changed, which might include changing the policies
groupChanged(group, loggingContext);
loggingContext.transactionEnded();
LOGGER.info("Success");
- if (policy != null &&
- ((policy.getId().contains("Config_MS_")) || (policy.getId().contains("BRMS_Param")))) {
+ if (policy != null
+ && ((policy.getId().contains("Config_MS_")) || (policy.getId().contains("BRMS_Param")))) {
PushPolicyHandler pushPolicyHandler = PushPolicyHandler.getInstance();
if (pushPolicyHandler.preSafetyCheck(policy, configHome)) {
LOGGER.debug("Precheck Successful.");
@@ -1523,1115 +1435,39 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
}
PolicyLogger.audit("Transaction Ended Successfully");
+ return;
} catch (PAPException e) {
acPutTransaction.rollbackTransaction();
PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " API PUT exception");
loggingContext.transactionEnded();
PolicyLogger.audit("Transaction Failed - See Error.log");
- String message = XACMLErrorConstants.ERROR_PROCESS_FLOW +
- "Exception in request to update group from API - See Error.log on on the PAP.";
+ String message = XACMLErrorConstants.ERROR_PROCESS_FLOW
+ + "Exception in request to update group from API - See Error.log on on the PAP.";
setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
response.addHeader("error", ADD_GROUP_ERROR);
response.addHeader("message", message);
- }
- }
-
- /**
- * Requests from the Admin Console for operations not on single specific objects
- *
- * @param request
- * @param response
- * @param groupId
- * @param loggingContext
- * @throws ServletException
- * @throws IOException
- */
- private void doACPost(HttpServletRequest request, HttpServletResponse response, String groupId,
- ONAPLoggingContext loggingContext) throws ServletException, IOException {
- PolicyDBDaoTransaction doACPostTransaction = null;
- try {
- String groupName = request.getParameter("groupName");
- String groupDescription = request.getParameter("groupDescription");
- String apiflag = request.getParameter("apiflag");
- if (groupName != null && groupDescription != null) {
- // Args: group=<groupId> groupName=<name> groupDescription=<description> <= create
- // a new group
- loggingContext.setServiceName("AC:PAP.createGroup");
- String unescapedName = null;
- String unescapedDescription = null;
- try {
- unescapedName = URLDecoder.decode(groupName, "UTF-8");
- unescapedDescription = URLDecoder.decode(groupDescription, "UTF-8");
- } catch (UnsupportedEncodingException e) {
- LOGGER.error(e);
- }
- PolicyDBDaoTransaction newGroupTransaction = policyDBDao.getNewTransaction();
- try {
- newGroupTransaction.createGroup(PolicyDBDao.createNewPDPGroupId(unescapedName), unescapedName,
- unescapedDescription, "XACMLPapServlet.doACPost");
- papEngine.newGroup(unescapedName, unescapedDescription);
- loggingContext.metricStarted();
- newGroupTransaction.commitTransaction();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPost commitTransaction");
- } catch (Exception e) {
- newGroupTransaction.rollbackTransaction();
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet",
- " Unable to create new group");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
- "Unable to create new group '" + groupId + "'");
- return;
- }
- response.setStatus(HttpServletResponse.SC_NO_CONTENT);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("New Group '" + groupId + "' created");
- }
- // tell the Admin Consoles there is a change
- loggingContext.metricStarted();
- notifyAC();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPost notifyAC");
- // new group by definition has no PDPs, so no need to notify them of changes
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- return;
- }
- // for all remaining POST operations the group must exist before the operation can be done
- OnapPDPGroup group = null;
- try {
- group = papEngine.getGroup(groupId);
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- if (group == null) {
- String message = "Unknown groupId '" + groupId + "'";
- //for fixing Header Manipulation of Fortify issue
- if (!message.matches(REGEX)) {
- response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
- response.addHeader("error", ADD_GROUP_ERROR);
- response.addHeader("message", "GroupId Id is not valid");
- return;
- }
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- if (apiflag != null) {
- response.addHeader("error", "unknownGroupId");
- response.addHeader("operation", "push");
- response.addHeader("message", message);
- response.setStatus(HttpServletResponse.SC_NOT_FOUND);
- } else {
- setResponseError(response, HttpServletResponse.SC_NOT_FOUND, message);
- }
- return;
- }
-
- // If the request contains a policyId then we know we are pushing the policy to PDP
- if (request.getParameter("policyId") != null) {
-
- if (apiflag != null) {
- loggingContext.setServiceName("PolicyEngineAPI:PAP.postPolicy");
- LOGGER.info("PushPolicy Request From The API");
- } else {
- loggingContext.setServiceName("AC:PAP.postPolicy");
- LOGGER.info("PushPolicy Request From The AC");
- }
-
- String policyId = request.getParameter("policyId");
- PolicyDBDaoTransaction addPolicyToGroupTransaction = policyDBDao.getNewTransaction();
- StdPDPGroup updatedGroup = null;
- try {
- //Copying the policy to the file system and updating groups in database
- LOGGER.info("PapServlet: calling PolicyDBDao.addPolicyToGroup()");
- updatedGroup = addPolicyToGroupTransaction
- .addPolicyToGroup(group.getId(), policyId, "XACMLPapServlet.doACPost");
- loggingContext.metricStarted();
- addPolicyToGroupTransaction.commitTransaction();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPost commitTransaction");
- LOGGER.info("PapServlet: addPolicyToGroup() succeeded, transaction was committed");
-
- } catch (Exception e) {
- addPolicyToGroupTransaction.rollbackTransaction();
- String message = "Policy '" + policyId + "' not copied to group '" + groupId + "': " + e;
- //for fixing Header Manipulation of Fortify issue
- if (!message.matches(REGEX)) {
- response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
- response.addHeader("error", ADD_GROUP_ERROR);
- response.addHeader("message", "Policy Id is not valid");
- return;
- }
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " " + message);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- if (apiflag != null) {
- response.addHeader("error", "policyCopyError");
- response.addHeader("message", message);
- response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
- } else {
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
- }
- return;
- }
-
- if (apiflag != null) {
- /*
- * If request comes from the API we need to run the PolicyDBDao updateGroup() to notify other
- * paps of the change.
- * The GUI does this from the POLICY-SDK-APP code.
- */
-
- // Get new transaction to perform updateGroup()
- PolicyDBDaoTransaction acPutTransaction = policyDBDao.getNewTransaction();
- try {
- // get the request content into a String and read the inputStream into a buffer
- java.util.Scanner scanner = new java.util.Scanner(request.getInputStream());
- scanner.useDelimiter("\\A");
- String json = scanner.hasNext() ? scanner.next() : "";
- scanner.close();
-
- // convert Object sent as JSON into local object
- ObjectMapper mapper = new ObjectMapper();
- Object objectFromJSON = mapper.readValue(json, StdPDPPolicy.class);
- StdPDPPolicy policy = (StdPDPPolicy) objectFromJSON;
-
- LOGGER.info("Request JSON Payload: " + json);
-
- // Assume that this is an update of an existing PDP Group
- loggingContext.setServiceName("PolicyEngineAPI:PAP.updateGroup");
- try {
- acPutTransaction.updateGroup(updatedGroup, "XACMLPapServlet.doACPut");
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet",
- " Error occurred when notifying PAPs of a group change: "
- + e);
- throw new PAPException(e.getMessage());
- }
-
- LOGGER.info("Calling updatGroup() with new group");
- papEngine.updateGroup(updatedGroup);
-
- LOGGER.info("Group '" + updatedGroup.getId() + "' updated");
-
- // Commit transaction to send notification to other PAPs
- loggingContext.metricStarted();
- acPutTransaction.commitTransaction();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet updateGroupsFromAPI commitTransaction");
- loggingContext.metricStarted();
-
- notifyAC();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet updateGroupsFromAPI notifyAC");
-
- // Group changed to send notification to PDPs, which might include changing the policies
- groupChanged(updatedGroup, loggingContext);
- loggingContext.transactionEnded();
- LOGGER.info("Success");
-
- if (policy != null && ((policy.getName().contains("Config_MS_")) ||
- (policy.getId().contains("BRMS_Param")))) {
- PushPolicyHandler pushPolicyHandler = PushPolicyHandler.getInstance();
- if (pushPolicyHandler.preSafetyCheck(policy, configHome)) {
- LOGGER.debug("Precheck Successful.");
- }
- }
-
- //delete temporary policy file from the bin directory
- Files.deleteIfExists(Paths.get(policy.getId()));
-
- } catch (Exception e) {
- acPutTransaction.rollbackTransaction();
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " API PUT exception");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- String message = XACMLErrorConstants.ERROR_PROCESS_FLOW +
- "Exception occurred when updating the group from API.";
- LOGGER.error(message);
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
- response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
- response.addHeader("error", ADD_GROUP_ERROR);
- response.addHeader("message", message);
- return;
- }
- }
-
- // policy file copied ok and the Group was updated on the PDP
- response.setStatus(HttpServletResponse.SC_NO_CONTENT);
- response.addHeader("operation", "push");
- response.addHeader("policyId", policyId);
- response.addHeader("groupId", groupId);
-
- LOGGER.info("policy '" + policyId + "' copied to directory for group '" + groupId + "'");
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- LOGGER.info("Transaction Ended Successfully");
-
- } else if (request.getParameter("default") != null) {
- // Args: group=<groupId> default=true <= make default
- // change the current default group to be the one identified in the request.
- loggingContext.setServiceName("AC:PAP.setDefaultGroup");
- // This is a POST operation rather than a PUT "update group" because of the side-effect that the
- // current default group is also changed.
- // It should never be the case that multiple groups are currently marked as the default, but protect
- // against that anyway.
- PolicyDBDaoTransaction setDefaultGroupTransaction = policyDBDao.getNewTransaction();
- try {
- setDefaultGroupTransaction.changeDefaultGroup(group, "XACMLPapServlet.doACPost");
- papEngine.setDefaultGroup(group);
- loggingContext.metricStarted();
- setDefaultGroupTransaction.commitTransaction();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPost commitTransaction");
- } catch (Exception e) {
- setDefaultGroupTransaction.rollbackTransaction();
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " Unable to set group");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
- "Unable to set group '" + groupId + "' to default");
- return;
- }
- response.setStatus(HttpServletResponse.SC_NO_CONTENT);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("Group '" + groupId + "' set to be default");
- }
- // Notify the Admin Consoles that something changed
- // For now the AC cannot handle anything more detailed than the whole set of PDPGroups, so just
- // notify on that
- //TODO - Future: FIGURE OUT WHAT LEVEL TO NOTIFY: 2 groups or entire set - currently notify AC to
- // update whole configuration of all groups
- loggingContext.metricStarted();
- notifyAC();
- // This does not affect any PDPs in the existing groups, so no need to notify them of this change
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPost notifyAC");
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- LOGGER.info("Transaction Ended Successfully");
- } else if (request.getParameter("pdpId") != null) {
- doACPostTransaction = policyDBDao.getNewTransaction();
- // Args: group=<groupId> pdpId=<pdpId> <= move PDP to group
- loggingContext.setServiceName("AC:PAP.movePDP");
- String pdpId = request.getParameter("pdpId");
- OnapPDP pdp = papEngine.getPDP(pdpId);
- OnapPDPGroup originalGroup = papEngine.getPDPGroup((OnapPDP) pdp);
- try {
- doACPostTransaction.movePdp(pdp, group, "XACMLPapServlet.doACPost");
- } catch (Exception e) {
- doACPostTransaction.rollbackTransaction();
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet",
- " Error while moving pdp in the database: "
- + "pdp=" + pdp.getId() + ",to group=" + group.getId());
- throw new PAPException(e.getMessage());
- }
- papEngine.movePDP((OnapPDP) pdp, group);
- response.setStatus(HttpServletResponse.SC_NO_CONTENT);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("PDP '" + pdp.getId() + "' moved to group '" + group.getId() + "' set to be default");
- }
- // update the status of both the original group and the new one
- ((StdPDPGroup) originalGroup).resetStatus();
- ((StdPDPGroup) group).resetStatus();
- // Notify the Admin Consoles that something changed
- // For now the AC cannot handle anything more detailed than the whole set of PDPGroups, so just
- // notify on that
- loggingContext.metricStarted();
- notifyAC();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPost notifyAC");
- // Need to notify the PDP that it's config may have changed
- pdpChanged(pdp, loggingContext);
- loggingContext.metricStarted();
- doACPostTransaction.commitTransaction();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPost commitTransaction");
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- }
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " AC POST exception");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
- }
- }
-
- /**
- * Requests from the Admin Console to GET info about the Groups and PDPs
- *
- * @param request
- * @param response
- * @param groupId
- * @param loggingContext
- * @throws ServletException
- * @throws IOException
- */
- private void doACGet(HttpServletRequest request, HttpServletResponse response, String groupId,
- ONAPLoggingContext loggingContext) throws IOException {
- try {
- String parameterDefault = request.getParameter("default");
- String pdpId = request.getParameter("pdpId");
- String pdpGroup = request.getParameter("getPDPGroup");
- if ("".equals(groupId)) {
- // request IS from AC but does not identify a group by name
- if (parameterDefault != null) {
- // Request is for the Default group (whatever its id)
- loggingContext.setServiceName("AC:PAP.getDefaultGroup");
- OnapPDPGroup group = papEngine.getDefaultGroup();
- // convert response object to JSON and include in the response
- mapperWriteValue(new ObjectMapper(), response, group);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("GET Default group req from '" + request.getRequestURL() + "'");
- }
- response.setStatus(HttpServletResponse.SC_OK);
- response.setHeader("content-type", "application/json");
- try {
- response.getOutputStream().close();
- } catch (IOException e) {
- LOGGER.error(e);
- }
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- return;
- } else if (pdpId != null) {
- // Request is related to a PDP
- if (pdpGroup == null) {
- // Request is for the (unspecified) group containing a given PDP
- loggingContext.setServiceName("AC:PAP.getPDP");
- OnapPDP pdp = null;
- try {
- pdp = papEngine.getPDP(pdpId);
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- // convert response object to JSON and include in the response
- mapperWriteValue(new ObjectMapper(), response, pdp);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("GET pdp '" + pdpId + "' req from '" + request.getRequestURL() + "'");
- }
- response.setStatus(HttpServletResponse.SC_OK);
- response.setHeader("content-type", "application/json");
- try {
- response.getOutputStream().close();
- } catch (IOException e) {
- LOGGER.error(e);
- }
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- return;
- } else {
- // Request is for the group containing a given PDP
- loggingContext.setServiceName("AC:PAP.getGroupForPDP");
- OnapPDPGroup group = null;
- try {
- OnapPDP pdp = papEngine.getPDP(pdpId);
- group = papEngine.getPDPGroup((OnapPDP) pdp);
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- // convert response object to JSON and include in the response
- mapperWriteValue(new ObjectMapper(), response, group);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("GET PDP '" + pdpId + "' Group req from '" + request.getRequestURL() + "'");
- }
- response.setStatus(HttpServletResponse.SC_OK);
- response.setHeader("content-type", "application/json");
- try {
- response.getOutputStream().close();
- } catch (IOException e) {
- LOGGER.error(e);
- }
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- return;
- }
- } else {
- // request is for top-level properties about all groups
- loggingContext.setServiceName("AC:PAP.getAllGroups");
- Set<OnapPDPGroup> groups = null;
- try {
- groups = papEngine.getOnapPDPGroups();
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " AC Get exception");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
- return;
- }
- // convert response object to JSON and include in the response
- mapperWriteValue(new ObjectMapper(), response, groups);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("GET All groups req");
- }
- response.setStatus(HttpServletResponse.SC_OK);
- response.setHeader("content-type", "application/json");
- try {
- response.getOutputStream().close();
- } catch (IOException e) {
- LOGGER.error(e);
- }
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- return;
- }
- }
- // for all other GET operations the group must exist before the operation can be done
- OnapPDPGroup group = null;
- try {
- group = papEngine.getGroup(groupId);
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- if (group == null) {
- String message = "Unknown groupId '" + groupId + "'";
- //for fixing Header Manipulation of Fortify issue
- if (!message.matches(REGEX)) {
- response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
- response.addHeader("error", ADD_GROUP_ERROR);
- response.addHeader("message", "Group Id is not valid");
- return;
- }
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_NOT_FOUND, message);
- return;
- }
- // Figure out which request this is based on the parameters
- String policyId = request.getParameter("policyId");
- if (policyId != null) {
- // retrieve a policy
- loggingContext.setServiceName("AC:PAP.getPolicy");
- // convert response object to JSON and include in the response
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " GET Policy not implemented");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_BAD_REQUEST, "GET Policy not implemented");
- } else {
- // No other parameters, so return the identified Group
- loggingContext.setServiceName("AC:PAP.getGroup");
- // convert response object to JSON and include in the response
- mapperWriteValue(new ObjectMapper(), response, group);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("GET group '" + group.getId() + "' req from '" + request.getRequestURL() + "'");
- }
- response.setStatus(HttpServletResponse.SC_OK);
- response.setHeader("content-type", "application/json");
- try {
- response.getOutputStream().close();
- } catch (IOException e) {
- LOGGER.error(e);
- }
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- return;
- }
- // Currently there are no other GET calls from the AC.
- // The AC uses the "GET All Groups" operation to fill its local cache and uses that cache for all other
- // GETs without calling the PAP.
- // Other GETs that could be called:
- // Specific Group (groupId=<groupId>)
- // A Policy (groupId=<groupId> policyId=<policyId>)
- // A PDP (groupId=<groupId> pdpId=<pdpId>)
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " UNIMPLEMENTED ");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED");
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " AC Get exception");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
- }
- }
-
- /**
- * Requests from the Admin Console to create new items or update existing ones
- *
- * @param request
- * @param response
- * @param groupId
- * @param loggingContext
- * @throws ServletException
- * @throws IOException
- */
- private void doACPut(HttpServletRequest request, HttpServletResponse response, String groupId,
- ONAPLoggingContext loggingContext) throws IOException {
- PolicyDBDaoTransaction acPutTransaction = policyDBDao.getNewTransaction();
- try {
- // for PUT operations the group may or may not need to exist before the operation can be done
- OnapPDPGroup group = papEngine.getGroup(groupId);
- // determine the operation needed based on the parameters in the request
- // for remaining operations the group must exist before the operation can be done
- if (group == null) {
- String message = "Unknown groupId '" + groupId + "'";
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_NOT_FOUND, message);
- return;
- }
- if (request.getParameter("policy") != null) {
- // group=<groupId> policy=<policyId> contents=policy file <= Create new policy
- // file in group dir, or replace it if it already exists (do not touch properties)
- loggingContext.setServiceName("AC:PAP.putPolicy");
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE +
- " PARTIALLY IMPLEMENTED!!! ACTUAL CHANGES SHOULD BE MADE BY PAP SERVLET!!! ");
- response.setStatus(HttpServletResponse.SC_NO_CONTENT);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- } else if (request.getParameter("pdpId") != null) {
- // ARGS: group=<groupId> pdpId=<pdpId/URL> <= create a new PDP or Update an Existing one
- String pdpId = request.getParameter("pdpId");
- if (papEngine.getPDP(pdpId) == null) {
- loggingContext.setServiceName("AC:PAP.createPDP");
- } else {
- loggingContext.setServiceName("AC:PAP.updatePDP");
- }
- // get the request content into a String
- String json = null;
- // read the inputStream into a buffer (trick found online scans entire input looking for end-of-file)
- try {
- Scanner scanner = new Scanner(request.getInputStream());
- scanner.useDelimiter("\\A");
- json = scanner.hasNext() ? scanner.next() : "";
- scanner.close();
- } catch (IOException e) {
- LOGGER.error(e);
- }
- LOGGER.info("JSON request from AC: " + json);
- // convert Object sent as JSON into local object
- ObjectMapper mapper = new ObjectMapper();
- Object objectFromJSON = null;
- try {
- objectFromJSON = mapper.readValue(json, StdPDP.class);
- } catch (Exception e) {
- LOGGER.error(e);
- }
- if (pdpId == null ||
- objectFromJSON == null ||
- !(objectFromJSON instanceof StdPDP) ||
- ((StdPDP) objectFromJSON).getId() == null ||
- !((StdPDP) objectFromJSON).getId().equals(pdpId)) {
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " PDP new/update had bad input. pdpId=" + pdpId +
- " objectFromJSON=" + objectFromJSON);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
- "Bad input pdpid for object:" + objectFromJSON);
- }
- StdPDP pdp = (StdPDP) objectFromJSON;
- if (pdp != null) {
- OnapPDP oPDP = null;
- try {
- oPDP = papEngine.getPDP(pdpId);
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- if (oPDP == null) {
- // this is a request to create a new PDP object
- try {
- acPutTransaction.addPdpToGroup(pdp.getId(), group.getId(), pdp.getName(),
- pdp.getDescription(), pdp.getJmxPort(), "XACMLPapServlet.doACPut");
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet",
- " Error while adding pdp to group in the database: "
- + "pdp=" + (pdp.getId()) + ",to group=" + group.getId());
- throw new PAPException(e.getMessage());
- }
- try {
- papEngine.newPDP(pdp.getId(), group, pdp.getName(), pdp.getDescription(), pdp.getJmxPort());
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- } else {
- try {
- acPutTransaction.updatePdp(pdp, "XACMLPapServlet.doACPut");
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet",
- " Error while updating pdp in the database: "
- + "pdp=" + pdp.getId());
- throw new PAPException(e.getMessage());
- }
- // this is a request to update the pdp
- try {
- papEngine.updatePDP(pdp);
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- }
- response.setStatus(HttpServletResponse.SC_NO_CONTENT);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("PDP '" + pdpId + "' created/updated");
- }
- // adjust the group's state including the new PDP
- ((StdPDPGroup) group).resetStatus();
- // tell the Admin Consoles there is a change
- loggingContext.metricStarted();
- notifyAC();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPut notifyAC");
- // this might affect the PDP, so notify it of the change
- pdpChanged(pdp, loggingContext);
- loggingContext.metricStarted();
- acPutTransaction.commitTransaction();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPut commitTransaction");
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- } else {
- try {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, "XACMLPapServlet",
- " Error while adding pdp to group in the database: "
- + "pdp=null" + ",to group=" + group.getId());
- throw new PAPException("PDP is null");
- } catch (Exception e) {
- throw new PAPException("PDP is null" + e.getMessage() + e);
- }
- }
- } else if (request.getParameter("pipId") != null) {
- // group=<groupId> pipId=<pipEngineId> contents=pip properties <= add a
- // PIP to pip config, or replace it if it already exists (lenient operation)
- loggingContext.setServiceName("AC:PAP.putPIP");
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " UNIMPLEMENTED");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED");
- } else {
- // Assume that this is an update of an existing PDP Group
- // ARGS: group=<groupId> <= Update an Existing Group
- loggingContext.setServiceName("AC:PAP.updateGroup");
- // get the request content into a String
- String json = null;
- // read the inputStream into a buffer (trick found online scans entire input looking for end-of-file)
- try {
- Scanner scanner = new Scanner(request.getInputStream());
- scanner.useDelimiter("\\A");
- json = scanner.hasNext() ? scanner.next() : "";
- scanner.close();
- } catch (IOException e) {
- LOGGER.error(e);
- }
- LOGGER.info("JSON request from AC: " + json);
- // convert Object sent as JSON into local object
- ObjectMapper mapper = new ObjectMapper();
- Object objectFromJSON = null;
- try {
- objectFromJSON = mapper.readValue(json, StdPDPGroup.class);
- } catch (Exception e) {
- LOGGER.error(e);
- }
- if (objectFromJSON == null || !(objectFromJSON instanceof StdPDPGroup) ||
- !((StdPDPGroup) objectFromJSON).getId().equals(group.getId())) {
- PolicyLogger
- .error(MessageCodes.ERROR_DATA_ISSUE + " Group update had bad input. id=" + group.getId() +
- " objectFromJSON=" + objectFromJSON);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
- "Bad input id for object:" + objectFromJSON);
- }
- // The Path on the PAP side is not carried on the RESTful interface with the AC
- // (because it is local to the PAP)
- // so we need to fill that in before submitting the group for update
- if (objectFromJSON != null) {
- ((StdPDPGroup) objectFromJSON).setDirectory(((StdPDPGroup) group).getDirectory());
- }
- try {
- if ("delete".equals(((StdPDPGroup) objectFromJSON).getOperation())) {
- acPutTransaction.updateGroup((StdPDPGroup) objectFromJSON, "XACMLPapServlet.doDelete");
- } else {
- acPutTransaction.updateGroup((StdPDPGroup) objectFromJSON, "XACMLPapServlet.doACPut");
- }
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " Error while updating group in the database: "
- + "group=" + group.getId());
- LOGGER.error(e);
- throw new PAPException(e.getMessage());
- }
-
- PushPolicyHandler pushPolicyHandler = PushPolicyHandler.getInstance();
- OnapPDPGroup updatedGroup = (StdPDPGroup) objectFromJSON;
- if (pushPolicyHandler.preSafetyCheck(updatedGroup, configHome)) {
- LOGGER.debug("Precheck Successful.");
- }
- try {
- papEngine.updateGroup((StdPDPGroup) objectFromJSON);
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- response.setStatus(HttpServletResponse.SC_NO_CONTENT);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("Group '" + group.getId() + "' updated");
- }
- loggingContext.metricStarted();
- acPutTransaction.commitTransaction();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPut commitTransaction");
- // tell the Admin Consoles there is a change
- loggingContext.metricStarted();
- notifyAC();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPut notifyAC");
- // Group changed, which might include changing the policies
- groupChanged(group, loggingContext);
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- }
- } catch (PAPException e) {
- LOGGER.debug(e);
- acPutTransaction.rollbackTransaction();
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " AC PUT exception");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
- }
- }
-
- /**
- * Requests from the Admin Console to delete/remove items
- *
- * @param request
- * @param response
- * @param groupId
- * @param loggingContext
- * @throws ServletException
- * @throws IOException
- */
- private void doACDelete(HttpServletRequest request, HttpServletResponse response, String groupId,
- ONAPLoggingContext loggingContext) throws IOException {
- PolicyDBDaoTransaction removePdpOrGroupTransaction = policyDBDao.getNewTransaction();
- try {
- // for all DELETE operations the group must exist before the operation can be done
- loggingContext.setServiceName("AC:PAP.delete");
- OnapPDPGroup group = papEngine.getGroup(groupId);
- if (group == null) {
- String message = "Unknown groupId '" + groupId + "'";
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_NOT_FOUND, "Unknown groupId '" + groupId + "'");
- return;
- }
- // determine the operation needed based on the parameters in the request
- if (request.getParameter("policy") != null) {
- // group=<groupId> policy=<policyId> [delete=<true|false>] <= delete policy file from
- // group
- loggingContext.setServiceName("AC:PAP.deletePolicy");
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " UNIMPLEMENTED");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED");
- } else if (request.getParameter("pdpId") != null) {
- // ARGS: group=<groupId> pdpId=<pdpId> <= delete PDP
- String pdpId = request.getParameter("pdpId");
- OnapPDP pdp = papEngine.getPDP(pdpId);
- try {
- removePdpOrGroupTransaction.removePdpFromGroup(pdp.getId(), "XACMLPapServlet.doACDelete");
- } catch (Exception e) {
- throw new PAPException(e);
- }
- try {
- papEngine.removePDP((OnapPDP) pdp);
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- // adjust the status of the group, which may have changed when we removed this PDP
- ((StdPDPGroup) group).resetStatus();
- response.setStatus(HttpServletResponse.SC_NO_CONTENT);
- loggingContext.metricStarted();
- notifyAC();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPut notifyAC");
- // update the PDP and tell it that it has NO Policies (which prevents it from serving PEP Requests)
- pdpChanged(pdp, loggingContext);
- loggingContext.metricStarted();
- removePdpOrGroupTransaction.commitTransaction();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPut commitTransaction");
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- } else if (request.getParameter("pipId") != null) {
- // group=<groupId> pipId=<pipEngineId> <= delete PIP config for given engine
- loggingContext.setServiceName("AC:PAP.deletePIPConfig");
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " UNIMPLEMENTED");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED");
- } else {
- // ARGS: group=<groupId> movePDPsToGroupId=<movePDPsToGroupId> <= delete a group and
- // move all its PDPs to the given group
- String moveToGroupId = request.getParameter("movePDPsToGroupId");
- OnapPDPGroup moveToGroup = null;
- if (moveToGroupId != null) {
- try {
- moveToGroup = papEngine.getGroup(moveToGroupId);
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- }
- // get list of PDPs in the group being deleted so we can notify them that they got changed
- Set<OnapPDP> movedPDPs = new HashSet<>();
- movedPDPs.addAll(group.getOnapPdps());
- // do the move/remove
- try {
- removePdpOrGroupTransaction.deleteGroup(group, moveToGroup, "XACMLPapServlet.doACDelete");
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.ERROR_UNKNOWN, e, "XACMLPapServlet",
- " Failed to delete PDP Group. Exception");
- throw new PAPException(e.getMessage());
- }
- try {
- papEngine.removeGroup(group, moveToGroup);
- } catch (PAPException e) {
- LOGGER.error(e);
- }
- response.setStatus(HttpServletResponse.SC_NO_CONTENT);
- loggingContext.metricStarted();
- notifyAC();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPut notifyAC");
- // notify any PDPs in the removed set that their config may have changed
- for (OnapPDP pdp : movedPDPs) {
- pdpChanged(pdp, loggingContext);
- }
- loggingContext.metricStarted();
- removePdpOrGroupTransaction.commitTransaction();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet doACPut commitTransaction");
- loggingContext.transactionEnded();
- auditLogger.info("Success");
- PolicyLogger.audit("Transaction Ended Successfully");
- }
- } catch (PAPException e) {
- removePdpOrGroupTransaction.rollbackTransaction();
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " AC DELETE exception");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
- }
- }
-
- /**
- * Heartbeat thread - periodically check on PDPs' status
- * <p>
- * Heartbeat with all known PDPs.
- * <p>
- * Implementation note:
- * <p>
- * The PDPs are contacted Sequentially, not in Parallel.
- * <p>
- * If we did this in parallel using multiple threads we would simultaneously use
- * - 1 thread and
- * - 1 connection
- * for EACH PDP.
- * This could become a resource problem since we already use multiple threads and connections for updating the PDPs
- * when user changes occur.
- * Using separate threads can also make it tricky dealing with timeouts on PDPs that are non-responsive.
- * <p>
- * The Sequential operation does a heartbeat request to each PDP one at a time.
- * This has the flaw that any PDPs that do not respond will hold up the entire heartbeat sequence until they
- * timeout.
- * If there are a lot of non-responsive PDPs and the timeout is large-ish (the default is 20 seconds)
- * it could take a long time to cycle through all of the PDPs.
- * That means that this may not notice a PDP being down in a predictable time.
- */
- private class Heartbeat implements Runnable {
- private PAPPolicyEngine papEngine;
- private Set<OnapPDP> pdps = new HashSet<>();
- private int heartbeatInterval;
- private int heartbeatTimeout;
-
- public volatile boolean isRunning = false;
-
- public synchronized boolean isRunning() {
- return this.isRunning;
- }
-
- public synchronized void terminate() {
- this.isRunning = false;
- }
-
- public Heartbeat(PAPPolicyEngine papEngine2) {
- papEngine = papEngine2;
- this.heartbeatInterval = Integer.parseInt(
- XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_HEARTBEAT_INTERVAL, "10000"));
- this.heartbeatTimeout = Integer.parseInt(
- XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_HEARTBEAT_TIMEOUT, "10000"));
- }
-
- @Override
- public void run() {
- // Set ourselves as running
- synchronized (this) {
- this.isRunning = true;
- }
- HashMap<String, URL> idToURLMap = new HashMap<>();
- try {
- while (this.isRunning()) {
- // Wait the given time
- Thread.sleep(heartbeatInterval);
- // get the list of PDPs (may have changed since last time)
- pdps.clear();
- synchronized (papEngine) {
- try {
- for (OnapPDPGroup g : papEngine.getOnapPDPGroups()) {
- for (OnapPDP p : g.getOnapPdps()) {
- pdps.add(p);
- }
- }
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet",
- "Heartbeat unable to read PDPs from PAPEngine");
- }
- }
- // Check for shutdown
- if (this.isRunning() == false) {
- LOGGER.info("isRunning is false, getting out of loop.");
- break;
- }
- // try to get the summary status from each PDP
- boolean changeSeen = false;
- for (OnapPDP pdp : pdps) {
- // Check for shutdown
- if (this.isRunning() == false) {
- LOGGER.info("isRunning is false, getting out of loop.");
- break;
- }
- // the id of the PDP is its url (though we add a query parameter)
- URL pdpURL = idToURLMap.get(pdp.getId());
- if (pdpURL == null) {
- // haven't seen this PDP before
- String fullURLString = null;
- try {
- // Check PDP ID
- if (CheckPDP.validateID(pdp.getId())) {
- fullURLString = pdp.getId() + "?type=hb";
- pdpURL = new URL(fullURLString);
- idToURLMap.put(pdp.getId(), pdpURL);
- }
- } catch (MalformedURLException e) {
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "XACMLPapServlet",
- " PDP id '" + fullURLString + "' is not a valid URL");
- continue;
- }
- }
- // Do a GET with type HeartBeat
- String newStatus = "";
- HttpURLConnection connection = null;
- try {
- // Open up the connection
- if (pdpURL != null) {
- connection = (HttpURLConnection) pdpURL.openConnection();
- // Setup our method and headers
- connection.setRequestMethod("GET");
- connection.setConnectTimeout(heartbeatTimeout);
- // Authentication
- String encoding = CheckPDP.getEncoding(pdp.getId());
- if (encoding != null) {
- connection.setRequestProperty("Authorization", "Basic " + encoding);
- }
- // Do the connect
- connection.connect();
- if (connection.getResponseCode() == 204) {
- newStatus = connection.getHeaderField(XACMLRestProperties.PROP_PDP_HTTP_HEADER_HB);
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("Heartbeat '" + pdp.getId() + "' status='" + newStatus + "'");
- }
- } else {
- // anything else is an unexpected result
- newStatus = PDPStatus.Status.UNKNOWN.toString();
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR +
- " Heartbeat connect response code " + connection.getResponseCode() + ": " +
- pdp.getId());
- }
- }
- } catch (UnknownHostException e) {
- newStatus = PDPStatus.Status.NO_SUCH_HOST.toString();
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet",
- " Heartbeat '" + pdp.getId() + "' NO_SUCH_HOST");
- } catch (SocketTimeoutException e) {
- newStatus = PDPStatus.Status.CANNOT_CONNECT.toString();
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet",
- " Heartbeat '" + pdp.getId() + "' connection timeout");
- } catch (ConnectException e) {
- newStatus = PDPStatus.Status.CANNOT_CONNECT.toString();
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet",
- " Heartbeat '" + pdp.getId() + "' cannot connect");
- } catch (Exception e) {
- newStatus = PDPStatus.Status.UNKNOWN.toString();
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet",
- "Heartbeat '" + pdp.getId() + "' connect exception");
- } finally {
- // cleanup the connection
- if (connection != null)
- connection.disconnect();
- }
- if (!pdp.getStatus().getStatus().toString().equals(newStatus)) {
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("previous status='" + pdp.getStatus().getStatus() + "' new Status='" +
- newStatus + "'");
- }
- try {
- setPDPSummaryStatus(pdp, newStatus);
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet",
- "Unable to set state for PDP '" + pdp.getId());
- }
- changeSeen = true;
- }
- }
- // Check for shutdown
- if (this.isRunning() == false) {
- LOGGER.info("isRunning is false, getting out of loop.");
- break;
- }
- // if any of the PDPs changed state, tell the ACs to update
- if (changeSeen) {
- notifyAC();
- }
- }
- } catch (InterruptedException e) {
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " Heartbeat interrupted. Shutting down");
- this.terminate();
- Thread.currentThread().interrupt();
- }
+ return;
}
}
/*
- * HELPER to change Group status when PDP status is changed
- * (Must NOT be called from a method that is synchronized on the papEngine or it may deadlock)
+ * HELPER to change Group status when PDP status is changed (Must NOT be called from a method that
+ * is synchronized on the papEngine or it may deadlock)
*/
- private void setPDPSummaryStatus(OnapPDP pdp, PDPStatus.Status newStatus) throws PAPException {
+ public void setPDPSummaryStatus(OnapPDP pdp, PDPStatus.Status newStatus) throws PAPException {
setPDPSummaryStatus(pdp, newStatus.toString());
}
- private void setPDPSummaryStatus(OnapPDP pdp, String newStatus) throws PAPException {
+ public void setPDPSummaryStatus(OnapPDP pdp, String newStatus) throws PAPException {
synchronized (papEngine) {
StdPDPStatus status = new StdPDPStatus();
status.setStatus(PDPStatus.Status.valueOf(newStatus));
((StdPDP) pdp).setStatus(status);
// now adjust the group
- StdPDPGroup group = (StdPDPGroup) papEngine.getPDPGroup((OnapPDP) pdp);
- // if the PDP was just deleted it may transiently exist but not be in a group
+ StdPDPGroup group = (StdPDPGroup) papEngine.getPDPGroup(pdp);
+ // if the PDP was just deleted it may transiently exist but not be
+ // in a group
if (group != null) {
group.resetStatus();
}
@@ -2639,8 +1475,8 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
}
/*
- * Callback methods telling this servlet to notify PDPs of changes made by the PAP StdEngine
- * in the PDP group directories
+ * Callback methods telling this servlet to notify PDPs of changes made by the PAP StdEngine in the
+ * PDP group directories
*/
@Override
public void changed() {
@@ -2675,24 +1511,25 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
public void groupChanged(OnapPDPGroup group) {
// all PDPs within one group need to be updated/sync'd
for (OnapPDP pdp : group.getOnapPdps()) {
- pdpChanged(pdp);
+ pdpChanged(pdp, getPdpDataByGroup(group));
}
}
public void groupChanged(OnapPDPGroup group, ONAPLoggingContext loggingContext) {
// all PDPs within one group need to be updated/sync'd
for (OnapPDP pdp : group.getOnapPdps()) {
- pdpChanged(pdp, loggingContext);
+ pdpChanged(pdp, loggingContext, getPdpDataByGroup(group));
}
}
@Override
public void pdpChanged(OnapPDP pdp) {
// kick off a thread to do an event notification for each PDP.
- // This needs to be on a separate thread so that PDPs that do not respond (down, non-existent, etc)
- // do not block the PSP response to the AC, which would freeze the GUI until all PDPs sequentially respond or
- // time-out.
- Thread t = new Thread(new UpdatePDPThread(pdp));
+ // This needs to be on a separate thread so that PDPs that do not
+ // respond (down, non-existent, etc)
+ // do not block the PSP response to the AC, which would freeze the GUI
+ // until all PDPs sequentially respond or time-out.
+ Thread t = new Thread(new UpdatePdpThread(pdp, getPdpDataByPdpId(pdp)));
if (CheckPDP.validateID(pdp.getId())) {
t.start();
}
@@ -2700,252 +1537,51 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
public void pdpChanged(OnapPDP pdp, ONAPLoggingContext loggingContext) {
// kick off a thread to do an event notification for each PDP.
- // This needs to be on a separate thread so that PDPs that do not respond (down, non-existent, etc)
- // do not block the PSP response to the AC, which would freeze the GUI until all PDPs sequentially respond or
- // time-out.
- Thread t = new Thread(new UpdatePDPThread(pdp, loggingContext));
+ // This needs to be on a separate thread so that PDPs that do not
+ // respond (down, non-existent, etc)
+ // do not block the PSP response to the AC, which would freeze the GUI
+ // until all PDPs sequentially respond or time-out.
+ Thread t = new Thread(new UpdatePdpThread(pdp, loggingContext, getPdpDataByPdpId(pdp)));
if (CheckPDP.validateID(pdp.getId())) {
t.start();
}
}
- private class UpdatePDPThread implements Runnable {
- private OnapPDP pdp;
- private String requestId;
- private ONAPLoggingContext loggingContext;
-
- public UpdatePDPThread(OnapPDP pdp) {
- this.pdp = pdp;
- }
-
- public UpdatePDPThread(OnapPDP pdp, ONAPLoggingContext loggingContext) {
- this.pdp = pdp;
- if ((loggingContext != null) && (loggingContext.getRequestID() != null ||
- Objects.equals(loggingContext.getRequestID(), ""))) {
- this.requestId = loggingContext.getRequestID();
- }
- this.loggingContext = loggingContext;
+ private void pdpChanged(OnapPDP pdp, List<Properties> pdpDataByGroup) {
+ Thread t = new Thread(new UpdatePdpThread(pdp, pdpDataByGroup));
+ if (CheckPDP.validateID(pdp.getId())) {
+ t.start();
}
+ }
- public void run() {
- // send the current configuration to one PDP
- HttpURLConnection connection = null;
- // get a new logging context for the thread
- try {
- if (this.loggingContext == null) {
- loggingContext = new ONAPLoggingContext(baseLoggingContext);
- }
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet",
- " Failed to send property file to " + pdp.getId());
- // Since this is a server-side error, it probably does not reflect a problem on the client,
- // so do not change the PDP status.
- return;
- }
- try {
- loggingContext.setServiceName("PAP:PDP.putConfig");
- // If a requestId was provided, use it, otherwise generate one; post to loggingContext to be used
- // later when calling PDP
- if ((requestId == null) || (Objects.equals(requestId, ""))) {
- UUID requestID = UUID.randomUUID();
- loggingContext.setRequestID(requestID.toString());
- PolicyLogger
- .info("requestID not provided in call to XACMLPapSrvlet (UpdatePDPThread) so we generated" +
- " one: " +
- loggingContext.getRequestID());
- } else {
- loggingContext.setRequestID(requestId);
- PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (UpdatePDPThread): " +
- loggingContext.getRequestID());
- }
- loggingContext.transactionStarted();
- // the Id of the PDP is its URL
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("creating url for id '" + pdp.getId() + "'");
- }
- //TODO - currently always send both policies and pips. Do we care enough to add code to allow
- // sending just one or the other?
- //TODO (need to change "cache=", implying getting some input saying which to change)
- URL url = new URL(pdp.getId() + "?cache=all");
- // Open up the connection
- connection = (HttpURLConnection) url.openConnection();
- // Setup our method and headers
- connection.setRequestMethod("PUT");
- // Authentication
- String encoding = CheckPDP.getEncoding(pdp.getId());
- if (encoding != null) {
- connection.setRequestProperty("Authorization", "Basic " + encoding);
- }
- connection.setRequestProperty("Content-Type", "text/x-java-properties");
- connection.setRequestProperty("X-ECOMP-RequestID", loggingContext.getRequestID());
- connection.setInstanceFollowRedirects(true);
- connection.setDoOutput(true);
- try (OutputStream os = connection.getOutputStream()) {
- OnapPDPGroup group = papEngine.getPDPGroup((OnapPDP) pdp);
- // if the PDP was just deleted, there is no group, but we want to send an update anyway
- if (group == null) {
- // create blank properties files
- Properties policyProperties = new Properties();
- policyProperties.put(XACMLProperties.PROP_ROOTPOLICIES, "");
- policyProperties.put(XACMLProperties.PROP_REFERENCEDPOLICIES, "");
- policyProperties.store(os, "");
- Properties pipProps = new Properties();
- pipProps.setProperty(XACMLProperties.PROP_PIP_ENGINES, "");
- pipProps.store(os, "");
- } else {
- // send properties from the current group
- group.getPolicyProperties().store(os, "");
- Properties policyLocations = new Properties();
- for (PDPPolicy policy : group.getPolicies()) {
- policyLocations
- .put(policy.getId() + ".url", XACMLPapServlet.papURL + "?id=" + policy.getId());
- }
- policyLocations.store(os, "");
- group.getPipConfigProperties().store(os, "");
- }
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet",
- " Failed to send property file to " + pdp.getId());
- // Since this is a server-side error, it probably does not reflect a problem on the client,
- // so do not change the PDP status.
- return;
- }
- // Do the connect
- loggingContext.metricStarted();
- connection.connect();
- loggingContext.metricEnded();
- PolicyLogger.metrics("XACMLPapServlet UpdatePDPThread connection connect");
- if (connection.getResponseCode() == 204) {
- LOGGER.info("Success. We are configured correctly.");
- loggingContext.transactionEnded();
- auditLogger.info("Success. PDP is configured correctly.");
- PolicyLogger.audit("Transaction Success. PDP is configured correctly.");
- setPDPSummaryStatus(pdp, PDPStatus.Status.UP_TO_DATE);
- } else if (connection.getResponseCode() == 200) {
- LOGGER.info("Success. PDP needs to update its configuration.");
- loggingContext.transactionEnded();
- auditLogger.info("Success. PDP needs to update its configuration.");
- PolicyLogger.audit("Transaction Success. PDP is configured correctly.");
- setPDPSummaryStatus(pdp, PDPStatus.Status.OUT_OF_SYNCH);
- } else {
- LOGGER.warn("Failed: " + connection.getResponseCode() + " message: " +
- connection.getResponseMessage());
- loggingContext.transactionEnded();
- auditLogger.warn("Failed: " + connection.getResponseCode() + " message: " +
- connection.getResponseMessage());
- PolicyLogger.audit("Transaction Failed: " + connection.getResponseCode() + " message: " +
- connection.getResponseMessage());
- setPDPSummaryStatus(pdp, PDPStatus.Status.UNKNOWN);
- }
- } catch (Exception e) {
- LOGGER.debug(e);
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet",
- " Unable to sync config with PDP '" + pdp.getId() + "'");
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed: Unable to sync config with PDP '" + pdp.getId() + "': " + e);
- try {
- setPDPSummaryStatus(pdp, PDPStatus.Status.UNKNOWN);
- } catch (PAPException e1) {
- LOGGER.debug(e1);
- PolicyLogger
- .audit("Transaction Failed: Unable to set status of PDP " + pdp.getId() + " to UNKNOWN: " +
- e);
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet",
- " Unable to set status of PDP '" + pdp.getId() + "' to UNKNOWN");
- }
- } finally {
- // cleanup the connection
- if (connection != null) {
- connection.disconnect();
- }
- // tell the AC to update it's status info
- notifyAC();
- }
+ private void pdpChanged(OnapPDP pdp, ONAPLoggingContext loggingContext, List<Properties> pdpDataByGroup) {
+ Thread t = new Thread(new UpdatePdpThread(pdp, loggingContext, pdpDataByGroup));
+ if (CheckPDP.validateID(pdp.getId())) {
+ t.start();
}
}
- /*
- * RESTful Interface from PAP to ACs notifying them of changes
- */
- private void notifyAC() {
- // kick off a thread to do one event notification for all registered ACs
- // This needs to be on a separate thread so that ACs can make calls back to PAP to get the updated Group data
- // as part of processing this message on their end.
- Thread t = new Thread(new NotifyACThread());
- t.start();
- }
-
- private class NotifyACThread implements Runnable {
- public void run() {
- List<String> disconnectedACs = new ArrayList<>();
- // There should be no Concurrent exception here because the list is a CopyOnWriteArrayList.
- // The "for each" loop uses the collection's iterator under the covers, so it should be correct.
- for (String acURL : adminConsoleURLStringList) {
- HttpURLConnection connection = null;
- try {
- acURL += "?PAPNotification=true";
- //TODO - Currently we just tell AC that "Something changed" without being specific. Do we want
- // to tell it which group/pdp changed?
- //TODO - If so, put correct parameters into the Query string here
- acURL += "&objectType=all" + "&action=update";
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("creating url for id '" + acURL + "'");
- }
- //TODO - currently always send both policies and pips. Do we care enough to add code to allow
- // sending just one or the other?
- //TODO (need to change "cache=", implying getting some input saying which to change)
- URL url = new URL(acURL);
- // Open up the connection
- connection = (HttpURLConnection) url.openConnection();
- // Setup our method and headers
- connection.setRequestMethod("PUT");
- connection.setRequestProperty("Content-Type", "text/x-java-properties");
- // Adding this in. It seems the HttpUrlConnection class does NOT
- // properly forward our headers for POST re-direction. It does so
- // for a GET re-direction.
- // So we need to handle this ourselves.
- //TODO - is this needed for a PUT? seems better to leave in for now?
- connection.setInstanceFollowRedirects(false);
- // Do not include any data in the PUT because this is just a
- // notification to the AC.
- // The AC will use GETs back to the PAP to get what it needs
- // to fill in the screens.
- // Do the connect
- connection.connect();
- if (connection.getResponseCode() == 204) {
- LOGGER.info("Success. We updated correctly.");
- } else {
- LOGGER.warn(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "Failed: " + connection.getResponseCode() +
- " message: " + connection.getResponseMessage());
- }
+ private List<Properties> getPdpDataByGroup(OnapPDPGroup group) {
+ DataToNotifyPdp dataToNotify = new DataToNotifyPdp();
+ return dataToNotify.setPolicyConfigProperties(group);
+ }
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet",
- " Unable to sync config AC '" + acURL + "'");
- disconnectedACs.add(acURL);
- } finally {
- // cleanup the connection
- if (connection != null)
- connection.disconnect();
- }
- }
- // remove any ACs that are no longer connected
- if (!disconnectedACs.isEmpty()) {
- adminConsoleURLStringList.removeAll(disconnectedACs);
- }
- }
+ private List<Properties> getPdpDataByPdpId(OnapPDP pdp) {
+ DataToNotifyPdp dataToNotify = new DataToNotifyPdp();
+ return dataToNotify.setPolicyConfigProperties(pdp, papEngine);
}
private void testService(ONAPLoggingContext loggingContext, HttpServletResponse response) throws IOException {
LOGGER.info("Test request received");
try {
im.evaluateSanity();
- //If we make it this far, all is well
+ // If we make it this far, all is well
String message = "GET:/pap/test called and PAP " + papResourceName + " is OK";
LOGGER.info(message);
loggingContext.transactionEnded();
PolicyLogger.audit("Transaction Failed - See Error.log");
response.setStatus(HttpServletResponse.SC_OK);
+ return;
} catch (ForwardProgressException | AdministrativeStateException | StandbyStatusException e) {
String submsg;
if (e instanceof ForwardProgressException) {
@@ -2956,15 +1592,17 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
submsg = " Standby Status is NOT PROVIDING SERVICE.";
}
- String message = "GET:/pap/test called and PAP " + papResourceName + submsg
- + " Exception Message: " + e.getMessage();
+ String message = "GET:/pap/test called and PAP " + papResourceName + submsg + " Exception Message: "
+ + e.getMessage();
LOGGER.info(message, e);
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message);
loggingContext.transactionEnded();
PolicyLogger.audit("Transaction Failed - See Error.log");
setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
+ return;
} catch (Exception e) {
- //A subsystem is not making progress, is locked, standby or is not responding
+ // A subsystem is not making progress, is locked, standby or is not
+ // responding
String eMsg = e.getMessage();
if (eMsg == null) {
eMsg = "No Exception Message";
@@ -2975,7 +1613,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message);
loggingContext.transactionEnded();
PolicyLogger.audit("Transaction Failed - See Error.log");
- //Get the specific list of subsystems that failed
+ // Get the specific list of subsystems that failed
String ssFailureList = null;
for (String failedSS : papDependencyGroupsFlatArray) {
if (eMsg.contains(failedSS)) {
@@ -2991,6 +1629,20 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
}
response.addHeader("X-ONAP-SubsystemFailure", ssFailureList);
setResponseError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
+ return;
+ }
+ }
+
+ private void setLoggingContext(ONAPLoggingContext loggingContext, String methodType, String serviceName) {
+ loggingContext.transactionStarted();
+ loggingContext.setServiceName(serviceName);
+ if (loggingContext.getRequestID() == null || "".equals(loggingContext.getRequestID())) {
+ UUID requestID = UUID.randomUUID();
+ loggingContext.setRequestID(requestID.toString());
+ PolicyLogger.info(
+ "requestID not provided in call to XACMLPapServlet ('" + methodType + "') so we generated one");
+ } else {
+ PolicyLogger.info("requestID was provided in call to XACMLPapServlet ('" + methodType + "')");
}
}
@@ -3000,17 +1652,13 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
private boolean authorizeRequest(HttpServletRequest request) {
String clientCredentials = request.getHeader(ENVIRONMENT_HEADER);
// Check if the Client is Authorized.
- if (clientCredentials != null && clientCredentials.equalsIgnoreCase(environment)) {
- return true;
- } else {
- return false;
- }
+ return clientCredentials != null && clientCredentials.equalsIgnoreCase(environment);
}
private static void loadWebapps() throws PAPException {
if (actionHome == null || configHome == null) {
Path webappsPath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS));
- //Sanity Check
+ // Sanity Check
if (webappsPath == null) {
PolicyLogger.error("Invalid Webapps Path Location property : " + XACMLRestProperties.PROP_PAP_WEBAPPS);
throw new PAPException(
@@ -3023,8 +1671,7 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
Files.createDirectories(webappsPathConfig);
} catch (IOException e) {
PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet",
- "Failed to create config directory: "
- + webappsPathConfig.toAbsolutePath().toString());
+ "Failed to create config directory: " + webappsPathConfig.toAbsolutePath().toString());
}
}
if (Files.notExists(webappsPathAction)) {
@@ -3117,11 +1764,11 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
}
public static String getPapDbPassword() {
- return papDbPassword;
+ return papDbPd;
}
public static void setPapDbPassword(String papDbPassword) {
- XACMLPapServlet.papDbPassword = papDbPassword;
+ XACMLPapServlet.papDbPd = papDbPassword;
}
public static String getMsOnapName() {
@@ -3139,4 +1786,12 @@ public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeList
public static void setMsPolicyName(String msPolicyName) {
XACMLPapServlet.msPolicyName = msPolicyName;
}
-} \ No newline at end of file
+
+ public ONAPLoggingContext getBaseLoggingContext() {
+ return baseLoggingContext;
+ }
+
+ public void setBaseLoggingContext(ONAPLoggingContext baseLoggingContext) {
+ this.baseLoggingContext = baseLoggingContext;
+ }
+}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicy.java
index 03fbe0763..3a18504d0 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicy.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicy.java
@@ -2,7 +2,7 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -20,9 +20,13 @@
package org.onap.policy.pap.xacml.rest.components;
+import com.att.research.xacml.api.XACML3;
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.std.IdentifierImpl;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
+import java.io.PrintWriter;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
@@ -36,9 +40,9 @@ import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
-import javax.persistence.EntityManager;
-import javax.persistence.Query;
+import javax.script.SimpleBindings;
import org.apache.commons.lang3.StringEscapeUtils;
+import org.apache.commons.lang3.StringUtils;
import org.onap.policy.common.logging.eelf.MessageCodes;
import org.onap.policy.common.logging.eelf.PolicyLogger;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
@@ -51,7 +55,6 @@ import org.onap.policy.controlloop.policy.guard.Guard;
import org.onap.policy.controlloop.policy.guard.GuardPolicy;
import org.onap.policy.controlloop.policy.guard.MatchParameters;
import org.onap.policy.controlloop.policy.guard.builder.ControlLoopGuardBuilder;
-import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
import org.onap.policy.rest.dao.CommonClassDao;
import org.onap.policy.rest.jpa.DecisionSettings;
@@ -60,9 +63,8 @@ import org.onap.policy.utils.PolicyUtils;
import org.onap.policy.xacml.api.XACMLErrorConstants;
import org.onap.policy.xacml.std.pip.engines.aaf.AAFEngine;
import org.onap.policy.xacml.util.XACMLPolicyScanner;
-import com.att.research.xacml.api.XACML3;
-import com.att.research.xacml.api.pap.PAPException;
-import com.att.research.xacml.std.IdentifierImpl;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType;
@@ -82,6 +84,8 @@ import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.VariableDefinitionType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.VariableReferenceType;
+
+@Component
public class DecisionPolicy extends Policy {
private static final Logger LOGGER = FlexLogger.getLogger(DecisionPolicy.class);
@@ -92,6 +96,7 @@ public class DecisionPolicy extends Policy {
public static final String GUARD_BL_YAML = "GUARD_BL_YAML";
public static final String GUARD_MIN_MAX = "GUARD_MIN_MAX";
public static final String RAINY_DAY = "Rainy_Day";
+ public static final String MS_MODEL = "MicroService_Model";
private static final String XACML_GUARD_TEMPLATE = "Decision_GuardPolicyTemplate.xml";
private static final String XACML_BLGUARD_TEMPLATE = "Decision_GuardBLPolicyTemplate.xml";
private static final String XACML_GUARD_MIN_MAX_TEMPLATE = "Decision_GuardMinMaxPolicyTemplate.xml";
@@ -107,13 +112,18 @@ public class DecisionPolicy extends Policy {
List<String> dynamicFieldTwoRuleAlgorithms = new LinkedList<>();
List<String> dataTypeList = new LinkedList<>();
- private CommonClassDao commonClassDao;
+ private static CommonClassDao commonClassDao;
public DecisionPolicy() {
super();
}
- public DecisionPolicy(PolicyRestAdapter policyAdapter, CommonClassDao commonClassDao) {
+ @Autowired
+ public DecisionPolicy(CommonClassDao commonClassDao) {
+ DecisionPolicy.commonClassDao = commonClassDao;
+ }
+
+ public DecisionPolicy(PolicyRestAdapter policyAdapter) {
this.policyAdapter = policyAdapter;
this.commonClassDao = commonClassDao;
}
@@ -447,19 +457,7 @@ public class DecisionPolicy extends Policy {
}
private DecisionSettings findDecisionSettingsBySettingId(String settingId) {
- DecisionSettings decisionSetting = null;
-
- EntityManager em = XACMLPapServlet.getEmf().createEntityManager();
- Query getDecisionSettings = em.createNamedQuery("DecisionSettings.findAll");
- List<?> decisionSettingsList = getDecisionSettings.getResultList();
-
- for (Object id : decisionSettingsList) {
- decisionSetting = (DecisionSettings) id;
- if (decisionSetting.getXacmlId().equals(settingId)) {
- break;
- }
- }
- return decisionSetting;
+ return (DecisionSettings) commonClassDao.getEntityItem(DecisionSettings.class, "xacmlId", settingId);
}
private void createRule(PolicyType decisionPolicy, boolean permitRule) {
@@ -875,7 +873,7 @@ public class DecisionPolicy extends Policy {
public String getFunctionDefinitionId(String key) {
FunctionDefinition object =
- (FunctionDefinition) commonClassDao.getDataById(FunctionDefinition.class, "shortname", key);
+ (FunctionDefinition) commonClassDao.getEntityItem(FunctionDefinition.class, "shortname", key);
if (object != null) {
return object.getXacmlid();
}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/FirewallConfigPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/FirewallConfigPolicy.java
index 6cadc77a1..db7bbd4be 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/FirewallConfigPolicy.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/FirewallConfigPolicy.java
@@ -2,14 +2,14 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017,2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,6 +20,11 @@
package org.onap.policy.pap.xacml.rest.components;
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.std.IdentifierImpl;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.github.fge.jackson.JsonLoader;
+import com.github.fge.jsonpatch.diff.JsonDiff;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
@@ -35,22 +40,19 @@ import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonObject;
import javax.json.JsonReader;
-import javax.persistence.EntityManager;
-import javax.persistence.Query;
-
+import javax.script.SimpleBindings;
import org.apache.commons.io.FilenameUtils;
import org.onap.policy.common.logging.eelf.MessageCodes;
import org.onap.policy.common.logging.eelf.PolicyLogger;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
-import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
+import org.onap.policy.rest.dao.CommonClassDao;
import org.onap.policy.rest.jpa.ActionList;
import org.onap.policy.rest.jpa.AddressGroup;
import org.onap.policy.rest.jpa.GroupServiceList;
@@ -61,13 +63,8 @@ import org.onap.policy.rest.jpa.ProtocolList;
import org.onap.policy.rest.jpa.ServiceList;
import org.onap.policy.rest.jpa.TermList;
import org.onap.policy.rest.jpa.UserInfo;
-
-import com.att.research.xacml.api.pap.PAPException;
-import com.att.research.xacml.std.IdentifierImpl;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.github.fge.jackson.JsonLoader;
-import com.github.fge.jsonpatch.diff.JsonDiff;
-
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType;
@@ -82,6 +79,7 @@ import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
+@Component
public class FirewallConfigPolicy extends Policy {
private static final Logger LOGGER = FlexLogger.getLogger(FirewallConfigPolicy.class);
@@ -90,6 +88,13 @@ public class FirewallConfigPolicy extends Policy {
super();
}
+ private static CommonClassDao commonClassDao;
+
+ @Autowired
+ public FirewallConfigPolicy(CommonClassDao commonClassDao) {
+ FirewallConfigPolicy.commonClassDao = commonClassDao;
+ }
+
public FirewallConfigPolicy(PolicyRestAdapter policyAdapter) {
this.policyAdapter = policyAdapter;
this.policyAdapter.setConfigType(policyAdapter.getConfigType());
@@ -98,11 +103,11 @@ public class FirewallConfigPolicy extends Policy {
// Saving the Configurations file at server location for config policy.
protected void saveConfigurations(String policyName, String jsonBody) {
String configurationName = policyName;
- if(configurationName.endsWith(".xml")){
+ if (configurationName.endsWith(".xml")) {
configurationName = configurationName.replace(".xml", "");
}
String fileName = CONFIG_HOME + File.separator + configurationName + ".json";
- try(BufferedWriter bw = new BufferedWriter(new FileWriter(fileName))){
+ try (BufferedWriter bw = new BufferedWriter(new FileWriter(fileName))) {
bw.write(jsonBody);
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Configuration is succesfully saved");
@@ -200,16 +205,15 @@ public class FirewallConfigPolicy extends Policy {
oldversion = oldversion - 1;
dbPolicyName = dbPolicyName + oldversion + ".xml";
}
- EntityManager em = XACMLPapServlet.getEmf().createEntityManager();
- Query createPolicyQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName");
- createPolicyQuery.setParameter("scope", scope);
- createPolicyQuery.setParameter("policyName", dbPolicyName);
- List<?> createPolicyQueryList = createPolicyQuery.getResultList();
- if(!createPolicyQueryList.isEmpty()){
+ String createPolicyQuery = "SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName";
+ SimpleBindings params = new SimpleBindings();
+ params.put("scope", scope);
+ params.put("policyName", dbPolicyName);
+ List<?> createPolicyQueryList = commonClassDao.getDataByQuery(createPolicyQuery, params);
+ if (!createPolicyQueryList.isEmpty()) {
PolicyEntity entitydata = (PolicyEntity) createPolicyQueryList.get(0);
policyAdapter.setPrevJsonBody(entitydata.getConfigurationData().getConfigBody());
}
- em.close();
if (policyAdapter.getData() != null) {
String jsonBody = policyAdapter.getJsonBody();
saveConfigurations(policyName, jsonBody);
@@ -252,7 +256,7 @@ public class FirewallConfigPolicy extends Policy {
target.getAnyOf().add(anyOf);
// Adding the target to the policy element
- configPolicy.setTarget((TargetType) target);
+ configPolicy.setTarget(target);
RuleType rule = new RuleType();
rule.setRuleId(policyAdapter.getRuleID());
@@ -1291,4 +1295,4 @@ public class FirewallConfigPolicy extends Policy {
return policyAdapter.getPolicyData();
}
-} \ No newline at end of file
+}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/HandleIncomingNotifications.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/HandleIncomingNotifications.java
new file mode 100644
index 000000000..fc08b643e
--- /dev/null
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/HandleIncomingNotifications.java
@@ -0,0 +1,593 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP-PAP-REST
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.pap.xacml.rest.components;
+
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.api.pap.PDPPolicy;
+import com.att.research.xacml.util.XACMLProperties;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import javax.persistence.PersistenceException;
+import org.apache.commons.io.FilenameUtils;
+import org.hibernate.Query;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.onap.policy.common.logging.eelf.MessageCodes;
+import org.onap.policy.common.logging.eelf.PolicyLogger;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
+import org.onap.policy.rest.XACMLRestProperties;
+import org.onap.policy.rest.dao.PolicyDBException;
+import org.onap.policy.rest.jpa.GroupEntity;
+import org.onap.policy.rest.jpa.PdpEntity;
+import org.onap.policy.rest.jpa.PolicyEntity;
+import org.onap.policy.xacml.api.pap.OnapPDP;
+import org.onap.policy.xacml.api.pap.OnapPDPGroup;
+import org.onap.policy.xacml.std.pap.StdPDPGroup;
+import org.onap.policy.xacml.std.pap.StdPDPPolicy;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class HandleIncomingNotifications {
+
+ private static final Logger logger = FlexLogger.getLogger(HandleIncomingNotifications.class);
+
+ private static final String POLICY_NOTIFICATION = "policy";
+ private static final String PDP_NOTIFICATION = "pdp";
+ private static final String GROUP_NOTIFICATION = "group";
+ public static final String JSON_CONFIG = "JSON";
+ public static final String XML_CONFIG = "XML";
+ public static final String PROPERTIES_CONFIG = "PROPERTIES";
+ public static final String OTHER_CONFIG = "OTHER";
+ public static final String AUDIT_USER = "audit";
+
+
+ private static SessionFactory sessionfactory;
+
+ @Autowired
+ public HandleIncomingNotifications(SessionFactory sessionfactory) {
+ HandleIncomingNotifications.sessionfactory = sessionfactory;
+ }
+
+ public HandleIncomingNotifications() {
+ // Default Constructor
+ }
+
+ public void handleIncomingHttpNotification(String url, String entityId, String entityType, String extraData,
+ XACMLPapServlet xacmlPapServlet) {
+ logger.info("DBDao url: " + url + " has reported an update on " + entityType + " entity " + entityId);
+ PolicyDBDaoTransaction transaction = PolicyDBDao.getPolicyDBDaoInstance().getNewTransaction();
+ // although its named retries, this is the total number of tries
+ int retries;
+ try {
+ retries = Integer
+ .parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_INCOMINGNOTIFICATION_TRIES));
+ } catch (Exception e) {
+ logger.error("xacml.rest.pap.incomingnotification.tries property not set, using a default of 3." + e);
+ retries = 3;
+ }
+ // if someone sets it to some dumb value, we need to make sure it will
+ // try at least once
+ if (retries < 1) {
+ retries = 1;
+ }
+ int pauseBetweenRetries = 1000;
+ switch (entityType) {
+
+ case POLICY_NOTIFICATION:
+ for (int i = 0; i < retries; i++) {
+ try {
+ handleIncomingPolicyChange(entityId);
+ break;
+ } catch (Exception e) {
+ logger.debug(e);
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught exception on handleIncomingPolicyChange(" + url + ", " + entityId + ", "
+ + extraData + ")");
+ }
+ try {
+ Thread.sleep(pauseBetweenRetries);
+ } catch (InterruptedException ie) {
+ Thread.currentThread().interrupt();
+ break;
+ }
+ }
+ break;
+ case PDP_NOTIFICATION:
+ for (int i = 0; i < retries; i++) {
+ try {
+ handleIncomingPdpChange(entityId, transaction);
+ break;
+ } catch (Exception e) {
+ logger.debug(e);
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught exception on handleIncomingPdpChange(" + url + ", " + entityId + ", "
+ + transaction + ")");
+ }
+ try {
+ Thread.sleep(pauseBetweenRetries);
+ } catch (InterruptedException ie) {
+ Thread.currentThread().interrupt();
+ break;
+ }
+ }
+ break;
+ case GROUP_NOTIFICATION:
+ for (int i = 0; i < retries; i++) {
+ try {
+ handleIncomingGroupChange(entityId, extraData, transaction);
+ break;
+ } catch (Exception e) {
+ logger.debug(e);
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught exception on handleIncomingGroupChange(" + url + ", " + entityId + ", "
+ + extraData + ", " + transaction + ", " + xacmlPapServlet + ")");
+ }
+ try {
+ Thread.sleep(pauseBetweenRetries);
+ } catch (InterruptedException ie) {
+ Thread.currentThread().interrupt();
+ break;
+ }
+ }
+ break;
+ }
+ // no changes should be being made in this function, we still need to
+ // close
+ transaction.rollbackTransaction();
+ }
+
+ private void handleIncomingGroupChange(String groupId, String extraData, PolicyDBDaoTransaction transaction)
+ throws PAPException, PolicyDBException {
+ GroupEntity groupRecord = null;
+ long groupIdLong = -1;
+ try {
+ groupIdLong = Long.parseLong(groupId);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException("groupId " + groupId + " cannot be parsed into a long");
+ }
+ try {
+ groupRecord = transaction.getGroup(groupIdLong);
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to get pdp group record with transaction.getGroup(" + groupIdLong + ");");
+ throw new PAPException("Could not get local group " + groupIdLong);
+ }
+ if (groupRecord == null) {
+ throw new PersistenceException("The group record returned is null");
+ }
+ // compare to local fs
+ // does group folder exist
+ OnapPDPGroup localGroup = null;
+ try {
+ localGroup = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(groupRecord.getGroupId());
+ } catch (Exception e) {
+ logger.warn("Caught PAPException trying to get local pdp group with papEngine.getGroup(" + groupId + ");",
+ e);
+ }
+ if (localGroup == null && extraData != null) {
+ // here we can try to load an old group id from the extraData
+ try {
+ localGroup = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(extraData);
+ } catch (Exception e) {
+ logger.warn(
+ "Caught PAPException trying to get local pdp group with papEngine.getGroup(" + extraData + ");",
+ e);
+ }
+ }
+ if (localGroup != null && groupRecord.isDeleted()) {
+ OnapPDPGroup newLocalGroup = null;
+ if (extraData != null) {
+ try {
+ newLocalGroup = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(extraData);
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to get new pdp group with papEngine.getGroup(" + extraData
+ + ");");
+ }
+ }
+ try {
+ PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().removeGroup(localGroup, newLocalGroup);
+ } catch (NullPointerException | PAPException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to get remove pdp group with papEngine.removeGroup(" + localGroup
+ + ", " + newLocalGroup + ");");
+ throw new PAPException("Could not remove group " + groupId);
+ }
+ } else if (localGroup == null) {
+ // creating a new group
+ try {
+ PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().newGroup(groupRecord.getgroupName(),
+ groupRecord.getDescription());
+ } catch (NullPointerException | PAPException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to create pdp group with papEngine.newGroup(groupRecord.getgroupName(), groupRecord.getDescription());");
+ throw new PAPException("Could not create group " + groupRecord);
+ }
+ try {
+ localGroup = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(groupRecord.getGroupId());
+ } catch (PAPException e1) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to get pdp group we just created with papEngine.getGroup(groupRecord.getGroupId());\nAny PDPs or policies in the new group may not have been added");
+ return;
+ }
+ // add possible pdps to group
+ List<?> pdpsInGroup = transaction.getPdpsInGroup(Long.parseLong(groupRecord.getGroupId()));
+ for (Object pdpO : pdpsInGroup) {
+ PdpEntity pdp = (PdpEntity) pdpO;
+ try {
+ PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().newPDP(pdp.getPdpId(), localGroup,
+ pdp.getPdpName(), pdp.getDescription(), pdp.getJmxPort());
+ } catch (NullPointerException | PAPException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to get create pdp with papEngine.newPDP(pdp.getPdpId(), localGroup, pdp.getPdpName(), pdp.getDescription(), pdp.getJmxPort());");
+ throw new PAPException("Could not create pdp " + pdp);
+ }
+ }
+ // add possible policies to group (file system only, apparently)
+ } else {
+ if (!(localGroup instanceof StdPDPGroup)) {
+ throw new PAPException("group is not a StdPDPGroup");
+ }
+ // clone the object
+ // because it will be comparing the new group to its own version
+ StdPDPGroup localGroupClone = new StdPDPGroup(localGroup.getId(), localGroup.isDefaultGroup(),
+ localGroup.getName(), localGroup.getDescription(), ((StdPDPGroup) localGroup).getDirectory());
+ localGroupClone.setOnapPdps(localGroup.getOnapPdps());
+ localGroupClone.setPipConfigs(localGroup.getPipConfigs());
+ localGroupClone.setStatus(localGroup.getStatus());
+ // we are updating a group or adding a policy or changing default
+ // set default if it should be
+ if (!localGroupClone.isDefaultGroup() && groupRecord.isDefaultGroup()) {
+ try {
+ PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().setDefaultGroup(localGroup);
+ return;
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to set default group with papEngine.SetDefaultGroup("
+ + localGroupClone + ");");
+ throw new PAPException("Could not set default group to " + localGroupClone);
+ }
+ }
+ boolean needToUpdate = false;
+ if (updateGroupPoliciesInFileSystem(localGroupClone, localGroup, groupRecord, transaction)) {
+ needToUpdate = true;
+ }
+ if (!PolicyDBDao.stringEquals(localGroupClone.getId(), groupRecord.getGroupId())
+ || !PolicyDBDao.stringEquals(localGroupClone.getName(), groupRecord.getgroupName())) {
+ // changing ids
+ // we do not want to change the id, the papEngine will do this
+ // for us, it needs to know the old id
+ localGroupClone.setName(groupRecord.getgroupName());
+ needToUpdate = true;
+ }
+ if (!PolicyDBDao.stringEquals(localGroupClone.getDescription(), groupRecord.getDescription())) {
+ localGroupClone.setDescription(groupRecord.getDescription());
+ needToUpdate = true;
+ }
+ if (needToUpdate) {
+ try {
+ PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().updateGroup(localGroupClone);
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to update group with papEngine.updateGroup(" + localGroupClone
+ + ");");
+ throw new PAPException("Could not update group " + localGroupClone);
+ }
+ }
+ }
+ }
+
+ // this will also handle removes, since incoming pdpGroup has no policies
+ // internally, we are just going to add them all in from the db
+ private boolean updateGroupPoliciesInFileSystem(OnapPDPGroup pdpGroup, OnapPDPGroup oldPdpGroup,
+ GroupEntity groupRecord, PolicyDBDaoTransaction transaction) throws PAPException, PolicyDBException {
+ if (!(pdpGroup instanceof StdPDPGroup)) {
+ throw new PAPException("group is not a StdPDPGroup");
+ }
+ StdPDPGroup group = (StdPDPGroup) pdpGroup;
+ // this must always be true since we don't explicitly know when a delete
+ // is occuring
+ boolean didUpdate = true;
+ HashMap<String, PDPPolicy> currentPolicySet = new HashMap<>(oldPdpGroup.getPolicies().size());
+ HashSet<PDPPolicy> newPolicySet = new HashSet<>();
+ for (PDPPolicy pdpPolicy : oldPdpGroup.getPolicies()) {
+ currentPolicySet.put(pdpPolicy.getId(), pdpPolicy);
+ }
+ for (PolicyEntity policy : groupRecord.getPolicies()) {
+ String pdpPolicyName =
+ PolicyDBDao.getPolicyDBDaoInstance().getPdpPolicyName(policy.getPolicyName(), policy.getScope());
+ if (group.getPolicy(pdpPolicyName) == null) {
+ didUpdate = true;
+ if (currentPolicySet.containsKey(pdpPolicyName)) {
+ newPolicySet.add(currentPolicySet.get(pdpPolicyName));
+ } else {
+ logger.info(
+ "PolicyDBDao: Adding the new policy to the PDP group after notification: " + pdpPolicyName);
+ InputStream policyStream = new ByteArrayInputStream(policy.getPolicyData().getBytes());
+ group.copyPolicyToFile(pdpPolicyName, policyStream);
+ ((StdPDPPolicy) (group.getPolicy(pdpPolicyName))).setName(PolicyDBDao.getPolicyDBDaoInstance()
+ .removeExtensionAndVersionFromPolicyName(pdpPolicyName));
+ try {
+ policyStream.close();
+ } catch (IOException e) {
+ didUpdate = false;
+ PolicyLogger.error(e.getMessage() + e);
+ }
+ }
+ }
+ }
+ logger.info("PolicyDBDao: Adding updated policies to group after notification.");
+ if (didUpdate) {
+ newPolicySet.addAll(group.getPolicies());
+ group.setPolicies(newPolicySet);
+ }
+ return didUpdate;
+ }
+
+ private void handleIncomingPdpChange(String pdpId, PolicyDBDaoTransaction transaction) throws PAPException {
+ // get pdp
+ long pdpIdLong = -1;
+ try {
+ pdpIdLong = Long.parseLong(pdpId);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException("pdpId " + pdpId + " cannot be parsed into a long");
+ }
+ PdpEntity pdpRecord = null;
+ try {
+ pdpRecord = transaction.getPdp(pdpIdLong);
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to get pdp record with transaction.getPdp(" + pdpIdLong + ");");
+ throw new PAPException("Could not get local pdp " + pdpIdLong);
+ }
+ if (pdpRecord == null) {
+ throw new PersistenceException("The pdpRecord returned is null");
+ }
+ OnapPDP localPdp = null;
+ try {
+ localPdp = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getPDP(pdpRecord.getPdpId());
+ } catch (PAPException e) {
+ logger.warn("Caught PAPException trying to get local pdp with papEngine.getPDP(" + pdpId + ");", e);
+ }
+ if (localPdp != null && pdpRecord.isDeleted()) {
+ try {
+ PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().removePDP(localPdp);
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to get remove pdp with papEngine.removePDP(" + localPdp + ");");
+ throw new PAPException("Could not remove pdp " + pdpId);
+ }
+ } else if (localPdp == null) {
+ // add new pdp
+ // get group
+ OnapPDPGroup localGroup = null;
+ try {
+ localGroup =
+ PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(pdpRecord.getGroup().getGroupId());
+ } catch (PAPException e1) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to get local group to add pdp to with papEngine.getGroup(pdpRecord.getGroup().getGroupId());");
+ throw new PAPException("Could not get local group");
+ }
+ try {
+ PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().newPDP(pdpRecord.getPdpId(), localGroup,
+ pdpRecord.getPdpName(), pdpRecord.getDescription(), pdpRecord.getJmxPort());
+ } catch (NullPointerException | PAPException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to create pdp with papEngine.newPDP(" + pdpRecord.getPdpId() + ", "
+ + localGroup + ", " + pdpRecord.getPdpName() + ", " + pdpRecord.getDescription() + ", "
+ + pdpRecord.getJmxPort() + ");");
+ throw new PAPException("Could not create pdp " + pdpRecord);
+ }
+ } else {
+ boolean needToUpdate = false;
+ if (!PolicyDBDao.stringEquals(localPdp.getId(), pdpRecord.getPdpId())
+ || !PolicyDBDao.stringEquals(localPdp.getName(), pdpRecord.getPdpName())) {
+ // again, we don't want to change the id, the papEngine will do
+ // this
+ localPdp.setName(pdpRecord.getPdpName());
+ needToUpdate = true;
+ }
+ if (!PolicyDBDao.stringEquals(localPdp.getDescription(), pdpRecord.getDescription())) {
+ localPdp.setDescription(pdpRecord.getDescription());
+ needToUpdate = true;
+ }
+ String localPdpGroupId = null;
+ try {
+ localPdpGroupId = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getPDPGroup(localPdp).getId();
+ } catch (PAPException e) {
+ // could be null or something, just warn at this point
+ logger.warn(
+ "Caught PAPException trying to get id of local group that pdp is in with localPdpGroupId = papEngine.getPDPGroup(localPdp).getId();",
+ e);
+ }
+ if (!PolicyDBDao.stringEquals(localPdpGroupId, pdpRecord.getGroup().getGroupId())) {
+ OnapPDPGroup newPdpGroup = null;
+ try {
+ newPdpGroup = PolicyDBDao.getPolicyDBDaoInstance().getPapEngine()
+ .getGroup(pdpRecord.getGroup().getGroupId());
+ } catch (PAPException e) {
+ // ok, now we have an issue. Time to stop things
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to get id of local group to move pdp to with papEngine.getGroup(pdpRecord.getGroup().getGroupId());");
+ throw new PAPException("Could not get local group");
+ }
+ try {
+ PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().movePDP(localPdp, newPdpGroup);
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to move pdp with papEngine.movePDP(localPdp, newPdpGroup);");
+ throw new PAPException("Could not move pdp " + localPdp);
+ }
+ }
+ if (localPdp.getJmxPort() != pdpRecord.getJmxPort()) {
+ localPdp.setJmxPort(pdpRecord.getJmxPort());
+ needToUpdate = true;
+ }
+ if (needToUpdate) {
+ try {
+ PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().updatePDP(localPdp);
+ } catch (PAPException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PAPException trying to update pdp with papEngine.updatePdp(" + localPdp + ");");
+ throw new PAPException("Could not update pdp " + localPdp);
+ }
+ }
+ }
+ // compare to local situation
+ // call command to update
+ }
+
+ private void handleIncomingPolicyChange(String policyId) {
+ String policyName = null;
+ Session session = sessionfactory.openSession();
+ Query getPolicyEntityQuery = session.getNamedQuery("PolicyEntity.FindById");
+ getPolicyEntityQuery.setParameter("id", Long.valueOf(policyId));
+
+ @SuppressWarnings("unchecked")
+ List<PolicyEntity> policies = getPolicyEntityQuery.list();
+ PolicyEntity policy = null;
+ if (!policies.isEmpty()) {
+ policy = policies.get(0);
+ }
+ String action = "unknown action";
+ try {
+ if (policy != null) {
+ policyName = policy.getPolicyName();
+ logger.info("Deleting old Policy Config File for " + policy.getPolicyName());
+ action = "delete";
+ Path subFile = null;
+
+ if (policy.getConfigurationData() != null) {
+ subFile =
+ getPolicySubFile(policy.getConfigurationData().getConfigurationName(), PolicyDBDao.CONFIG);
+ } else if (policy.getActionBodyEntity() != null) {
+ subFile = getPolicySubFile(policy.getActionBodyEntity().getActionBodyName(), PolicyDBDao.ACTION);
+ }
+
+ if (subFile != null) {
+ Files.deleteIfExists(subFile);
+ }
+ if (policy.getConfigurationData() != null) {
+ writePolicySubFile(policy, PolicyDBDao.CONFIG);
+ } else if (policy.getActionBodyEntity() != null) {
+ writePolicySubFile(policy, action);
+ }
+ }
+ } catch (IOException e1) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, PolicyDBDao.POLICYDBDAO_VAR,
+ "Error occurred while performing [" + action + "] of Policy File: " + policyName);
+ } finally {
+ session.close();
+ }
+ }
+
+ private boolean writePolicySubFile(PolicyEntity policy, String policyType) {
+ logger.info("writePolicySubFile with policyName[" + policy.getPolicyName() + "] and policyType[" + policyType
+ + "]");
+ String type = null;
+ String subTypeName = null;
+ String subTypeBody = null;
+ if (PolicyDBDao.CONFIG.equalsIgnoreCase(policyType)) {
+ type = PolicyDBDao.CONFIG;
+ subTypeName = FilenameUtils.removeExtension(policy.getConfigurationData().getConfigurationName());
+ subTypeBody = policy.getConfigurationData().getConfigBody();
+
+ String configType = policy.getConfigurationData().getConfigType();
+
+ if (configType != null) {
+ if (configType.equals(JSON_CONFIG)) {
+ subTypeName = subTypeName + ".json";
+ }
+ if (configType.equals(XML_CONFIG)) {
+ subTypeName = subTypeName + ".xml";
+ }
+ if (configType.equals(PROPERTIES_CONFIG)) {
+ subTypeName = subTypeName + ".properties";
+ }
+ if (configType.equals(OTHER_CONFIG)) {
+ subTypeName = subTypeName + ".txt";
+ }
+ }
+ } else if (PolicyDBDao.ACTION.equalsIgnoreCase(policyType)) {
+ type = PolicyDBDao.ACTION;
+ subTypeName = policy.getActionBodyEntity().getActionBodyName();
+ subTypeBody = policy.getActionBodyEntity().getActionBody();
+ }
+ Path filePath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS).toString(), type);
+
+ if (subTypeBody == null) {
+ subTypeBody = "";
+ }
+ boolean success = false;
+ try {
+ Files.deleteIfExists(Paths.get(filePath.toString(), subTypeName));
+ File file = Paths.get(filePath.toString(), subTypeName).toFile();
+ boolean value = file.createNewFile();
+ logger.debug("New file created successfully" + value);
+ try (FileWriter fileWriter = new FileWriter(file, false)) {
+ // false to overwrite
+ fileWriter.write(subTypeBody);
+ fileWriter.close();
+ success = true;
+ }
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Exception occured while creating Configuration File for Policy : " + policy.getPolicyName());
+ }
+ return success;
+ }
+
+ Path getPolicySubFile(String inputFileName, String subFileType) {
+ String filename = inputFileName;
+ logger.info("getPolicySubFile(" + filename + ", " + subFileType + ")");
+ Path filePath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS), subFileType);
+ File file = null;
+
+ filename = FilenameUtils.removeExtension(filename);
+
+ for (File tmpFile : filePath.toFile().listFiles()) {
+ if (FilenameUtils.removeExtension(tmpFile.getName()).equals(filename)) {
+ file = tmpFile;
+ }
+ }
+
+ Path finalPath = null;
+ if (file != null) {
+ finalPath = Paths.get(file.getAbsolutePath());
+ }
+
+ logger.info("end of getPolicySubFile: " + finalPath);
+ return finalPath;
+ }
+}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/NotifyOtherPaps.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/NotifyOtherPaps.java
new file mode 100644
index 000000000..cd02c2bfe
--- /dev/null
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/NotifyOtherPaps.java
@@ -0,0 +1,225 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP-PAP-REST
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.pap.xacml.rest.components;
+
+import com.att.research.xacml.util.XACMLProperties;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.ProtocolException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.UUID;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.rest.XACMLRestProperties;
+import org.onap.policy.rest.jpa.PolicyDBDaoEntity;
+import org.onap.policy.utils.CryptoUtils;
+
+public class NotifyOtherPaps {
+
+ private static final Logger LOGGER = FlexLogger.getLogger(NotifyOtherPaps.class);
+ private List<PolicyDBDaoEntity> failedPaps = null;
+
+ public void notifyOthers(long entityId, String entityType) {
+ notifyOthers(entityId, entityType, null);
+ }
+
+ /**
+ * Notify others.
+ *
+ * @param entityId the entity id
+ * @param entityType the entity type
+ * @param newGroupId the new group id
+ */
+ public void notifyOthers(long entityId, String entityType, String newGroupId) {
+ LOGGER.debug("notifyOthers(long entityId, String entityType, long newGroupId) as notifyOthers(" + entityId + ","
+ + entityType + "," + newGroupId + ") called");
+ failedPaps = new ArrayList<>();
+
+ List<?> otherServers = PolicyDBDao.getPolicyDBDaoInstance().getOtherServers();
+ // Notify other paps
+ startNotifyThreads(otherServers, entityId, entityType, newGroupId);
+ // Retry for failed paps
+ if (!failedPaps.isEmpty()) {
+ startNotifyThreads(failedPaps, entityId, entityType, newGroupId);
+ }
+ }
+
+ private void startNotifyThreads(List<?> otherServers, long entityId, String entityType, String newGroupId) {
+ LinkedList<Thread> notifyThreads = new LinkedList<>();
+ // we're going to run notifications in parallel threads to speed things
+ // up
+ for (Object obj : otherServers) {
+ Thread newNotifyThread = new Thread(new NotifyOtherThread(obj, entityId, entityType, newGroupId));
+ newNotifyThread.start();
+ notifyThreads.add(newNotifyThread);
+ }
+ // we want to wait for all notifications to complete or timeout before
+ // we unlock the interface and allow more changes
+ for (Thread t : notifyThreads) {
+ try {
+ t.join();
+ } catch (Exception e) {
+ LOGGER.warn("Could not join a notifcation thread" + e);
+ }
+ }
+ }
+
+ private class NotifyOtherThread implements Runnable {
+ public NotifyOtherThread(Object obj, long entityId, String entityType, String newGroupId) {
+ this.obj = obj;
+ this.entityId = entityId;
+ this.entityType = entityType;
+ this.newGroupId = newGroupId;
+ }
+
+ private Object obj;
+ private long entityId;
+ private String entityType;
+ private String newGroupId;
+
+ @Override
+ public void run() {
+ PolicyDBDao dao = new PolicyDBDao();
+ PolicyDBDaoEntity dbdEntity = (PolicyDBDaoEntity) obj;
+ String otherPap = dbdEntity.getPolicyDBDaoUrl();
+ String username = dbdEntity.getUsername();
+ String txt;
+ try {
+ txt = new String(CryptoUtils.decryptTxt(dbdEntity.getPassword()), StandardCharsets.UTF_8);
+ } catch (Exception e) {
+ LOGGER.debug(e);
+ // if we can't decrypt, might as well try it anyway
+ txt = dbdEntity.getPassword();
+ }
+
+ HttpURLConnection connection = null;
+ UUID requestId = UUID.randomUUID();
+ URL url;
+ String papUrl;
+ try {
+ String[] papUrlUserPass = dao.getPapUrlUserPass();
+ if (papUrlUserPass == null) {
+ papUrl = "undefined";
+ } else {
+ papUrl = papUrlUserPass[0];
+ }
+ LOGGER.debug("We are going to try to notify " + otherPap);
+ // is this our own url?
+ String ourUrl = otherPap;
+ try {
+ ourUrl = dao.splitPapUrlUserPass(otherPap)[0];
+ } catch (Exception e) {
+ ourUrl = otherPap;
+ LOGGER.debug(e);
+ }
+ if (otherPap == null) {
+ otherPap = "undefined";
+ }
+ if (papUrl.equals(ourUrl)) {
+ LOGGER.debug(otherPap + " is our url, skipping notify");
+ return;
+ }
+ if (newGroupId == null) {
+ url = new URL(otherPap + "?policydbdaourl=" + papUrl + "&entityid=" + entityId + "&entitytype="
+ + entityType);
+ } else {
+ url = new URL(otherPap + "?policydbdaourl=" + papUrl + "&entityid=" + entityId + "&entitytype="
+ + entityType + "&extradata=" + newGroupId);
+ }
+ } catch (MalformedURLException e) {
+ LOGGER.warn("Caught MalformedURLException on: new URL()", e);
+ return;
+ }
+ //
+ // Open up the connection
+ //
+ LOGGER.info("PolicyDBDao: NotifyOtherThread: notifying other PAPs of an update");
+ LOGGER.info("Connecting with url: " + url);
+ try {
+ connection = (HttpURLConnection) url.openConnection();
+ } catch (Exception e) {
+ LOGGER.warn("Caught exception on: url.openConnection()", e);
+ return;
+ }
+ //
+ // Setup our method and headers
+ //
+ try {
+ connection.setRequestMethod("PUT");
+ } catch (ProtocolException e) {
+ // why would this error ever occur?
+ LOGGER.warn("Caught ProtocolException on connection.setRequestMethod(\"PUT\");", e);
+ return;
+ }
+ Base64.Encoder encoder = Base64.getEncoder();
+ String encoding = encoder.encodeToString((username + ":" + txt).getBytes(StandardCharsets.UTF_8));
+ connection.setRequestProperty("Authorization", "Basic " + encoding);
+ connection.setRequestProperty("Accept", "text/x-java-properties");
+ connection.setRequestProperty("Content-Type", "text/x-java-properties");
+ connection.setRequestProperty("requestID", requestId.toString());
+ int readTimeout;
+ try {
+ readTimeout =
+ Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_NOTIFY_TIMEOUT));
+ } catch (Exception e) {
+ LOGGER.error("xacml.rest.pap.notify.timeoutms property not set, using a default.", e);
+ readTimeout = 10000;
+ }
+ connection.setReadTimeout(readTimeout);
+ connection.setConnectTimeout(readTimeout);
+ connection.setUseCaches(false);
+ //
+ // Adding this in. It seems the HttpUrlConnection class does NOT
+ // properly forward our headers for POST re-direction. It does so
+ // for a GET re-direction.
+ //
+ // So we need to handle this ourselves.
+ //
+ connection.setInstanceFollowRedirects(false);
+ connection.setDoOutput(true);
+ connection.setDoInput(true);
+ try {
+ connection.connect();
+ } catch (Exception e) {
+ LOGGER.warn("Caught exception on: connection.connect()", e);
+ return;
+ }
+ try {
+ if (connection.getResponseCode() == 200) {
+ LOGGER.info("PolicyDBDao: NotifyOtherThread received response 200 from pap server on notify");
+ } else {
+ LOGGER.warn("PolicyDBDao: NotifyOtherThread connection response code not 200, received: "
+ + connection.getResponseCode());
+ failedPaps.add(dbdEntity);
+ }
+ } catch (Exception e) {
+ LOGGER.warn("Caught Exception on: connection.getResponseCode() ", e);
+ }
+
+ connection.disconnect();
+ }
+ }
+}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDao.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDao.java
index c9c49720d..ba8057102 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDao.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDao.java
@@ -21,51 +21,33 @@
package org.onap.policy.pap.xacml.rest.components;
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.api.pap.PDPPolicy;
+import com.att.research.xacml.util.XACMLProperties;
import java.io.ByteArrayInputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.FileWriter;
-import java.io.IOException;
import java.io.InputStream;
-import java.io.StringReader;
-import java.net.HttpURLConnection;
-import java.net.MalformedURLException;
-import java.net.ProtocolException;
import java.net.URI;
-import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
-import java.nio.file.InvalidPathException;
import java.nio.file.Path;
import java.nio.file.Paths;
-import java.util.Base64;
-import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
-import java.util.Map;
import java.util.Set;
-import java.util.UUID;
-import javax.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
-import javax.persistence.LockModeType;
import javax.persistence.PersistenceException;
-import javax.persistence.Query;
-import javax.persistence.RollbackException;
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.xpath.XPath;
-import javax.xml.xpath.XPathFactory;
import org.apache.commons.io.FilenameUtils;
-import org.apache.commons.io.IOUtils;
+import org.hibernate.Criteria;
+import org.hibernate.LockMode;
+import org.hibernate.Query;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.criterion.Restrictions;
import org.onap.policy.common.logging.eelf.MessageCodes;
import org.onap.policy.common.logging.eelf.PolicyLogger;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
-import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
import org.onap.policy.rest.XACMLRestProperties;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
import org.onap.policy.rest.dao.PolicyDBException;
@@ -77,83 +59,70 @@ import org.onap.policy.rest.jpa.PdpEntity;
import org.onap.policy.rest.jpa.PolicyDBDaoEntity;
import org.onap.policy.rest.jpa.PolicyEntity;
import org.onap.policy.utils.CryptoUtils;
+import org.onap.policy.xacml.api.XACMLErrorConstants;
import org.onap.policy.xacml.api.pap.OnapPDP;
import org.onap.policy.xacml.api.pap.OnapPDPGroup;
import org.onap.policy.xacml.api.pap.PAPPolicyEngine;
import org.onap.policy.xacml.std.pap.StdPDPGroup;
import org.onap.policy.xacml.std.pap.StdPDPPolicy;
-import org.onap.policy.xacml.util.XACMLPolicyWriter;
-import org.w3c.dom.Document;
-import org.xml.sax.InputSource;
-import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicySetType;
-import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
-import com.att.research.xacml.api.pap.PAPException;
-import com.att.research.xacml.api.pap.PDP;
-import com.att.research.xacml.api.pap.PDPPolicy;
-import com.att.research.xacml.util.XACMLProperties;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+@Component
public class PolicyDBDao {
private static final Logger logger = FlexLogger.getLogger(PolicyDBDao.class);
private List<?> otherServers;
- private EntityManagerFactory emf;
+
+ public List<?> getOtherServers() {
+ return otherServers;
+ }
+
+ public void setOtherServers(List<?> otherServers) {
+ this.otherServers = otherServers;
+ }
+
private static PolicyDBDao currentInstance = null;
private PAPPolicyEngine papEngine;
- private static final String JSON_CONFIG = "JSON";
- private static final String XML_CONFIG = "XML";
- private static final String PROPERTIES_CONFIG = "PROPERTIES";
- private static final String OTHER_CONFIG = "OTHER";
-
- // Declared to static variables which were repeating multiple times across the PolicyDBDao
- public static final String config = "Config";
- public static final String action = "Action";
- private static final String groupIdVar = "groupId";
- private static final String deletedVar = "deleted";
- private static final String groupEntitySelectQuery =
+ public PAPPolicyEngine getPapEngine() {
+ return papEngine;
+ }
+
+ public static final String JSON_CONFIG = "JSON";
+ public static final String XML_CONFIG = "XML";
+ public static final String PROPERTIES_CONFIG = "PROPERTIES";
+ public static final String OTHER_CONFIG = "OTHER";
+ public static final String AUDIT_USER = "audit";
+
+ public static final String CONFIG = "Config";
+ public static final String ACTION = "Action";
+ public static final String GROUP_ID = "groupId";
+ public static final String DELETED = "deleted";
+ public static final String GROUPENTITY_SELECT =
"SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted";
- private static final String pdpEntitySelectQuery =
+ public static final String PDPENTITY_SELECT =
"SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted";
- private static final String groupCannotBeFound = "The group could not be found with id ";
- private static final String foundInDBNotDeleted = " were found in the database that are not deleted";
- private static final String moreThanOnePDP = "Somehow, more than one pdp with the same id ";
- private static final String deletedStatusFound = " and deleted status were found in the database";
- private static final String duplicateGroupId = "Somehow, more than one group with the same id ";
- private static final String pdpIdVariable = "pdpId";
- private static final String queryFailedToCheckExisting = "Query failed trying to check for existing group";
- private static final String queryFailedToGetGroup = "Query failed trying to get group ";
- public static final String scope = "scope";
- private static final String policyDBDaoVar = "PolicyDBDao";
- private static final String duplicatePolicyId = "Somehow, more than one policy with the id ";
- private static final String foundInDB = " were found in the database";
- private static final String TIMESTAMP = "\n TimeStamp = ";
- private static final String CAUGHTEXCEPTIONONNOTIFY = "Caught Exception on notifyOthers(";
-
- private static boolean isJunit = false;
+ public static final String GROUP_NOT_FOUND = "The group could not be found with id ";
+ public static final String FOUND_IN_DB_NOT_DEL = " were found in the database that are not deleted";
+ public static final String MORE_THAN_ONE_PDP = "Somehow, more than one pdp with the same id ";
+ public static final String DELETED_STATUS_FOUND = " and deleted status were found in the database";
+ public static final String DUPLICATE_GROUPID = "Somehow, more than one group with the same id ";
+ public static final String PDP_ID = "pdpId";
+ public static final String QUERY_FAILED_FOR_GROUP = "Query failed trying to check for existing group";
+ public static final String QUERY_FAILED_GET_GROUP = "Query failed trying to get group ";
+ public static final String SCOPE = "scope";
+ public static final String POLICYDBDAO_VAR = "PolicyDBDao";
+ public static final String DUP_POLICYID = "Somehow, more than one policy with the id ";
+ public static final String FOUND_IN_DB = " were found in the database";
+
+
+ public static boolean isJunit = false;
public static void setJunit(boolean isJunit) {
PolicyDBDao.isJunit = isJunit;
}
- /**
- * Get an instance of a PolicyDBDao. It creates one if it does not exist. Only one instance is allowed to be created
- * per server.
- *
- * @param emf The EntityFactoryManager to be used for database connections
- * @return The new instance of PolicyDBDao or throw exception if the given emf is null.
- * @throws IllegalStateException if a PolicyDBDao has already been constructed. Call getPolicyDBDaoInstance() to get
- * this.
- */
- public static PolicyDBDao getPolicyDBDaoInstance(EntityManagerFactory emf) {
- logger.debug("getPolicyDBDaoInstance(EntityManagerFactory emf) as getPolicyDBDaoInstance(" + emf + ") called");
- if (currentInstance == null) {
- if (emf != null) {
- currentInstance = new PolicyDBDao(emf);
- return currentInstance;
- }
- throw new IllegalStateException("The EntityManagerFactory is Null");
- }
- return currentInstance;
- }
+ private static SessionFactory sessionfactory;
/**
* Gets the current instance of PolicyDBDao.
@@ -166,19 +135,26 @@ public class PolicyDBDao {
logger.debug("getPolicyDBDaoInstance() as getPolicyDBDaoInstance() called");
if (currentInstance != null) {
return currentInstance;
+ } else {
+ currentInstance = new PolicyDBDao("init");
}
- throw new IllegalStateException(
- "The PolicyDBDao.currentInstance is Null. Use getPolicyDBDao(EntityManagerFactory emf)");
+ return currentInstance;
}
public void setPapEngine(PAPPolicyEngine papEngine2) {
this.papEngine = papEngine2;
}
- private PolicyDBDao(EntityManagerFactory emf) {
- logger.debug("PolicyDBDao(EntityManagerFactory emf) as PolicyDBDao(" + emf + ") called");
- this.emf = emf;
+ @Autowired
+ public PolicyDBDao(SessionFactory sessionFactory) {
+ PolicyDBDao.sessionfactory = sessionFactory;
+ }
+
+ public PolicyDBDao() {
+ // Default Constructor
+ }
+ public PolicyDBDao(String init) {
// not needed in this release
if (!register()) {
PolicyLogger
@@ -196,29 +172,21 @@ public class PolicyDBDao {
// not static because we are going to be using the instance's emf
// waitTime in ms to wait for lock, or -1 to wait forever (no)
- private void startTransactionSynced(EntityManager entityMgr, int waitTime) {
- logger.debug("\n\nstartTransactionSynced(EntityManager entityMgr,int waitTime) as "
- + "\n startTransactionSynced(" + entityMgr + "," + waitTime + ") called\n\n");
+ @SuppressWarnings("deprecation")
+ public void startTransactionSynced(Session session, int waitTime) throws InterruptedException {
+ logger.debug("\n\nstartTransactionSynced(Hibernate Session,int waitTime) as " + "\n startTransactionSynced("
+ + session + "," + waitTime + ") called\n\n");
DatabaseLockEntity lock = null;
-
- entityMgr.setProperty("javax.persistence.query.timeout", waitTime);
- entityMgr.getTransaction().begin();
-
- if (logger.isDebugEnabled()) {
- Map<String, Object> properties = entityMgr.getProperties();
- logger.debug(
- "\n\nstartTransactionSynced():" + "\n entityManager.getProperties() = " + properties + "\n\n");
- }
+ session.beginTransaction();
try {
if (logger.isDebugEnabled()) {
logger.debug("\n\nstartTransactionSynced():" + "\n ATTEMPT to get the DB lock" + "\n\n");
}
- lock = entityMgr.find(DatabaseLockEntity.class, 1, LockModeType.PESSIMISTIC_WRITE);
+ lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1, LockMode.PESSIMISTIC_WRITE);
if (logger.isDebugEnabled()) {
logger.debug("\n\nstartTransactionSynced():" + "\n GOT the DB lock" + "\n\n");
}
} catch (Exception e) {
- System.out.println("Could not get lock entity");
logger.error("Exception Occured" + e);
}
if (lock == null) {
@@ -236,40 +204,34 @@ public class PolicyDBDao {
private List<?> getRemotePolicyDBDaoList() {
logger.debug("getRemotePolicyDBDaoList() as getRemotePolicyDBDaoList() called");
List<?> policyDBDaoEntityList = new LinkedList<>();
- EntityManager em = emf.createEntityManager();
- startTransactionSynced(em, 1000);
+ Session session = sessionfactory.openSession();
try {
- Query getPolicyDBDaoEntityQuery = em.createNamedQuery("PolicyDBDaoEntity.findAll");
- policyDBDaoEntityList = getPolicyDBDaoEntityQuery.getResultList();
-
+ Criteria cr = session.createCriteria(PolicyDBDaoEntity.class);
+ policyDBDaoEntityList = cr.list();
} catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, POLICYDBDAO_VAR,
"Exception querying for other registered PolicyDBDaos");
logger.warn("List of remote PolicyDBDaos will be empty", e);
- }
- try {
- em.getTransaction().commit();
- } catch (Exception e) {
- logger.warn("List of remote PolicyDBDaos will be empty", e);
+ } finally {
try {
- em.getTransaction().rollback();
- } catch (Exception e2) {
- logger.debug("List of remote PolicyDBDaos will be empty", e2);
+ session.close();
+ } catch (Exception e) {
+ logger.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e);
}
}
- em.close();
return policyDBDaoEntityList;
}
public PolicyDBDaoTransaction getNewTransaction() {
logger.debug("getNewTransaction() as getNewTransaction() called");
- return new PolicyDBDaoTransactionInstance();
+ return new PolicyDbDaoTransactionInstance("init");
}
/*
- * Because the normal transactions are not used in audits, we can use the same transaction mechanism to get a
- * transaction and obtain the emlock and the DB lock. We just need to provide different transaction timeout values
- * in ms because the audit will run longer than normal transactions.
+ * Because the normal transactions are not used in audits, we can use the same transaction
+ * mechanism to get a transaction and obtain the emlock and the DB lock. We just need to provide
+ * different transaction timeout values in ms because the audit will run longer than normal
+ * transactions.
*/
public PolicyDBDaoTransaction getNewAuditTransaction() {
logger.debug("getNewAuditTransaction() as getNewAuditTransaction() called");
@@ -277,17 +239,16 @@ public class PolicyDBDao {
int auditWaitMs = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT));
// Use the (extended) audit timeout time in ms
int auditTimeoutMs = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_AUDIT_TIMEOUT));
- return new PolicyDBDaoTransactionInstance(auditTimeoutMs, auditWaitMs);
+ return new PolicyDbDaoTransactionInstance(auditTimeoutMs, auditWaitMs);
}
-
/**
* Checks if two strings are equal. Null strings ARE allowed.
*
* @param one A String or null to compare
* @param two A String or null to compare
*/
- private static boolean stringEquals(String one, String two) {
+ public static boolean stringEquals(String one, String two) {
logger.debug("stringEquals(String one, String two) as stringEquals(" + one + ", " + two + ") called");
if (one == null && two == null) {
return true;
@@ -299,11 +260,12 @@ public class PolicyDBDao {
}
/**
- * Returns the url of this local pap server, removing the username and password, if they are present
+ * Returns the url of this local pap server, removing the username and password, if they are
+ * present
*
* @return The url of this local pap server
*/
- private String[] getPapUrlUserPass() {
+ public String[] getPapUrlUserPass() {
logger.debug("getPapUrl() as getPapUrl() called");
String url = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_URL);
if (url == null) {
@@ -312,7 +274,7 @@ public class PolicyDBDao {
return splitPapUrlUserPass(url);
}
- private String[] splitPapUrlUserPass(String url) {
+ public String[] splitPapUrlUserPass(String url) {
String[] urlUserPass = new String[3];
String[] commaSplit = url.split(",");
urlUserPass[0] = commaSplit[0];
@@ -332,7 +294,8 @@ public class PolicyDBDao {
urlUserPass[2] = passwordPropertyValue;
}
}
- // if there is no comma, for some reason there is no username and password, so don't try to cut them off
+ // if there is no comma, for some reason there is no user name and
+ // password, so don't try to cut them off
return urlUserPass;
}
@@ -348,65 +311,69 @@ public class PolicyDBDao {
if (url == null || url.length < 3) {
return false;
}
- EntityManager em = emf.createEntityManager();
+ Session session = sessionfactory.openSession();
try {
- startTransactionSynced(em, 1000);
- } catch (IllegalStateException e) {
+ startTransactionSynced(session, 1000);
+ } catch (InterruptedException | IllegalStateException e) {
logger.debug("\nPolicyDBDao.register() caught an IllegalStateException: \n" + e + "\n");
DatabaseLockEntity lock;
- lock = em.find(DatabaseLockEntity.class, 1);
+ lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
if (lock == null) {
lock = new DatabaseLockEntity();
- em.persist(lock);
lock.setKey(1);
try {
- em.flush();
- em.getTransaction().commit();
- em.close();
+ session.persist(lock);
+ session.flush();
+ session.getTransaction().commit();
+ session.close();
} catch (Exception e2) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, policyDBDaoVar,
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, POLICYDBDAO_VAR,
"COULD NOT CREATE DATABASELOCK ROW. WILL TRY ONE MORE TIME");
}
- em = emf.createEntityManager();
+ session = sessionfactory.openSession();
try {
- startTransactionSynced(em, 1000);
+ startTransactionSynced(session, 1000);
} catch (Exception e3) {
String msg = "DATABASE LOCKING NOT WORKING. CONCURRENCY CONTROL NOT WORKING";
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e3, policyDBDaoVar, msg);
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e3, POLICYDBDAO_VAR, msg);
throw new IllegalStateException("msg" + "\n" + e3);
}
}
}
logger.debug("\nPolicyDBDao.register. Database locking and concurrency control is initialized\n");
- PolicyDBDaoEntity foundPolicyDBDaoEntity = em.find(PolicyDBDaoEntity.class, url[0]);
- Query getPolicyDBDaoEntityQuery =
- em.createQuery("SELECT e FROM PolicyDBDaoEntity e WHERE e.policyDBDaoUrl=:url");
- getPolicyDBDaoEntityQuery.setParameter("url", url[0]);
+ PolicyDBDaoEntity foundPolicyDBDaoEntity = null;
+ Criteria cr = session.createCriteria(PolicyDBDaoEntity.class);
+ cr.add(Restrictions.eq("policyDBDaoUrl", url[0]));
+ List<?> data = cr.list();
+ if (!data.isEmpty()) {
+ foundPolicyDBDaoEntity = (PolicyDBDaoEntity) data.get(0);
+ }
+
// encrypt the password
String txt = null;
try {
txt = CryptoUtils.encryptTxt(url[2].getBytes(StandardCharsets.UTF_8));
} catch (Exception e) {
logger.debug(e);
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Could not encrypt PAP password");
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, POLICYDBDAO_VAR, "Could not encrypt PAP password");
}
if (foundPolicyDBDaoEntity == null) {
PolicyDBDaoEntity newPolicyDBDaoEntity = new PolicyDBDaoEntity();
- em.persist(newPolicyDBDaoEntity);
newPolicyDBDaoEntity.setPolicyDBDaoUrl(url[0]);
newPolicyDBDaoEntity.setDescription("PAP server at " + url[0]);
newPolicyDBDaoEntity.setUsername(url[1]);
newPolicyDBDaoEntity.setPassword(txt);
try {
- em.getTransaction().commit();
+ session.persist(newPolicyDBDaoEntity);
+ session.getTransaction().commit();
} catch (Exception e) {
logger.debug(e);
try {
- em.getTransaction().rollback();
+ session.getTransaction().rollback();
} catch (Exception e2) {
logger.debug(e2);
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, policyDBDaoVar,
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, POLICYDBDAO_VAR,
"Could not add new PolicyDBDao to the database");
}
}
@@ -420,453 +387,28 @@ public class PolicyDBDao {
}
foundPolicyDBDaoEntity.preUpdate();
try {
- em.getTransaction().commit();
+ session.getTransaction().commit();
} catch (Exception e) {
logger.debug(e);
try {
- em.getTransaction().rollback();
+ session.getTransaction().rollback();
} catch (Exception e2) {
logger.debug(e2);
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, policyDBDaoVar,
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, POLICYDBDAO_VAR,
"Could not update PolicyDBDao in the database");
}
}
}
- em.close();
+ session.close();
logger.debug("\nPolicyDBDao.register(). Success!!\n");
return true;
}
- private class NotifyOtherThread implements Runnable {
- public NotifyOtherThread(Object obj, long entityId, String entityType, String newGroupId) {
- this.obj = obj;
- this.entityId = entityId;
- this.entityType = entityType;
- this.newGroupId = newGroupId;
- }
-
- private Object obj;
- private long entityId;
- private String entityType;
- private String newGroupId;
-
- @Override
- public void run() {
- // naming of 'o' is for backwards compatibility with the rest of the function
- PolicyDBDaoEntity dbdEntity = (PolicyDBDaoEntity) obj;
- String o = dbdEntity.getPolicyDBDaoUrl();
- String username = dbdEntity.getUsername();
- String txt;
- try {
- txt = new String(CryptoUtils.decryptTxt(dbdEntity.getPassword()), StandardCharsets.UTF_8);
- } catch (Exception e) {
- logger.debug(e);
- // if we can't decrypt, might as well try it anyway
- txt = dbdEntity.getPassword();
- }
- Base64.Encoder encoder = Base64.getEncoder();
- String encoding = encoder.encodeToString((username + ":" + txt).getBytes(StandardCharsets.UTF_8));
- HttpURLConnection connection = null;
- UUID requestID = UUID.randomUUID();
- URL url;
- String papUrl;
- try {
- String[] papUrlUserPass = getPapUrlUserPass();
- if (papUrlUserPass == null) {
- papUrl = "undefined";
- } else {
- papUrl = papUrlUserPass[0];
- }
- logger.debug("We are going to try to notify " + o);
- // is this our own url?
- String ourUrl = o;
- try {
- ourUrl = splitPapUrlUserPass((String) o)[0];
- } catch (Exception e) {
- logger.debug(e);
- }
- if (o == null) {
- o = "undefined";
- }
- if (papUrl.equals(ourUrl)) {
- logger.debug(o + " is our url, skipping notify");
- return;
- }
- if (newGroupId == null) {
- url = new URL(
- o + "?policydbdaourl=" + papUrl + "&entityid=" + entityId + "&entitytype=" + entityType);
- } else {
- url = new URL(o + "?policydbdaourl=" + papUrl + "&entityid=" + entityId + "&entitytype="
- + entityType + "&extradata=" + newGroupId);
- }
- } catch (MalformedURLException e) {
- logger.warn("Caught MalformedURLException on: new URL()", e);
- return;
- }
- //
- // Open up the connection
- //
- logger.info("PolicyDBDao: NotifyOtherThread: notifying other PAPs of an update");
- logger.info("Connecting with url: " + url);
- try {
- connection = (HttpURLConnection) url.openConnection();
- } catch (Exception e) {
- logger.warn("Caught exception on: url.openConnection()", e);
- return;
- }
- //
- // Setup our method and headers
- //
- try {
- connection.setRequestMethod("PUT");
- } catch (ProtocolException e) {
- // why would this error ever occur?
- logger.warn("Caught ProtocolException on connection.setRequestMethod(\"PUT\");", e);
- return;
- }
- connection.setRequestProperty("Authorization", "Basic " + encoding);
- connection.setRequestProperty("Accept", "text/x-java-properties");
- connection.setRequestProperty("Content-Type", "text/x-java-properties");
- connection.setRequestProperty("requestID", requestID.toString());
- int readTimeout;
- try {
- readTimeout =
- Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_NOTIFY_TIMEOUT));
- } catch (Exception e) {
- logger.error("xacml.rest.pap.notify.timeoutms property not set, using a default.", e);
- readTimeout = 10000;
- }
- connection.setReadTimeout(readTimeout);
- connection.setConnectTimeout(readTimeout);
- connection.setUseCaches(false);
- //
- // Adding this in. It seems the HttpUrlConnection class does NOT
- // properly forward our headers for POST re-direction. It does so
- // for a GET re-direction.
- //
- // So we need to handle this ourselves.
- //
- connection.setInstanceFollowRedirects(false);
- connection.setDoOutput(true);
- connection.setDoInput(true);
- try {
- connection.connect();
- } catch (Exception e) {
- logger.warn("Caught exception on: connection.connect()", e);
- return;
- }
- try {
- if (connection.getResponseCode() == 200) {
- logger.info("PolicyDBDao: NotifyOtherThread received response 200 from pap server on notify");
- } else {
- logger.warn("PolicyDBDao: NotifyOtherThread connection response code not 200, received: "
- + connection.getResponseCode());
- }
- } catch (Exception e) {
- logger.warn("Caught Exception on: connection.getResponseCode() ", e);
- }
-
- connection.disconnect();
- }
- }
-
- private static String evaluateXPath(String expression, String xml) {
- InputSource source = new InputSource(new StringReader(xml));
-
- DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
- String description = "";
- try {
- DocumentBuilder db = dbf.newDocumentBuilder();
- Document document = db.parse(source);
-
- XPathFactory xpathFactory = XPathFactory.newInstance();
- XPath xpath = xpathFactory.newXPath();
-
- description = xpath.evaluate(expression, document);
- } catch (Exception e) {
- logger.error("Exception Occured while evaluating path" + e);
- }
- return description;
- }
-
- private static final String POLICY_NOTIFICATION = "policy";
- private static final String PDP_NOTIFICATION = "pdp";
- private static final String GROUP_NOTIFICATION = "group";
-
- public void handleIncomingHttpNotification(String url, String entityId, String entityType, String extraData,
- XACMLPapServlet xacmlPapServlet) {
- logger.info("DBDao url: " + url + " has reported an update on " + entityType + " entity " + entityId);
- PolicyDBDaoTransaction transaction = this.getNewTransaction();
- // although its named retries, this is the total number of tries
- int retries;
- try {
- retries = Integer
- .parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_INCOMINGNOTIFICATION_TRIES));
- } catch (Exception e) {
- logger.error("xacml.rest.pap.incomingnotification.tries property not set, using a default of 3." + e);
- retries = 3;
- }
- // if someone sets it to some dumb value, we need to make sure it will try at least once
- if (retries < 1) {
- retries = 1;
- }
- int pauseBetweenRetries = 1000;
- switch (entityType) {
-
- case POLICY_NOTIFICATION:
- for (int i = 0; i < retries; i++) {
- try {
- handleIncomingPolicyChange(entityId);
- break;
- } catch (Exception e) {
- logger.debug(e);
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught exception on handleIncomingPolicyChange(" + url + ", " + entityId + ", "
- + extraData + ")");
- }
- try {
- Thread.sleep(pauseBetweenRetries);
- } catch (InterruptedException ie) {
- Thread.currentThread().interrupt();
- break;
- }
- }
- break;
- case PDP_NOTIFICATION:
- for (int i = 0; i < retries; i++) {
- try {
- handleIncomingPdpChange(entityId, transaction);
- break;
- } catch (Exception e) {
- logger.debug(e);
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught exception on handleIncomingPdpChange(" + url + ", " + entityId + ", "
- + transaction + ")");
- }
- try {
- Thread.sleep(pauseBetweenRetries);
- } catch (InterruptedException ie) {
- Thread.currentThread().interrupt();
- break;
- }
- }
- break;
- case GROUP_NOTIFICATION:
- for (int i = 0; i < retries; i++) {
- try {
- handleIncomingGroupChange(entityId, extraData, transaction);
- break;
- } catch (Exception e) {
- logger.debug(e);
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught exception on handleIncomingGroupChange(" + url + ", " + entityId + ", "
- + extraData + ", " + transaction + ", " + xacmlPapServlet + ")");
- }
- try {
- Thread.sleep(pauseBetweenRetries);
- } catch (InterruptedException ie) {
- Thread.currentThread().interrupt();
- break;
- }
- }
- break;
- }
- // no changes should be being made in this function, we still need to close
- transaction.rollbackTransaction();
- }
-
- private void handleIncomingGroupChange(String groupId, String extraData, PolicyDBDaoTransaction transaction)
- throws PAPException, PolicyDBException {
- GroupEntity groupRecord = null;
- long groupIdLong = -1;
- try {
- groupIdLong = Long.parseLong(groupId);
- } catch (NumberFormatException e) {
- throw new IllegalArgumentException("groupId " + groupId + " cannot be parsed into a long");
- }
- try {
- groupRecord = transaction.getGroup(groupIdLong);
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to get pdp group record with transaction.getGroup(" + groupIdLong + ");");
- throw new PAPException("Could not get local group " + groupIdLong);
- }
- if (groupRecord == null) {
- throw new PersistenceException("The group record returned is null");
- }
- // compare to local fs
- // does group folder exist
- OnapPDPGroup localGroup = null;
- try {
- localGroup = papEngine.getGroup(groupRecord.getGroupId());
- } catch (Exception e) {
- logger.warn("Caught PAPException trying to get local pdp group with papEngine.getGroup(" + groupId + ");",
- e);
- }
- if (localGroup == null && extraData != null) {
- // here we can try to load an old group id from the extraData
- try {
- localGroup = papEngine.getGroup(extraData);
- } catch (Exception e) {
- logger.warn(
- "Caught PAPException trying to get local pdp group with papEngine.getGroup(" + extraData + ");",
- e);
- }
- }
- if (localGroup != null && groupRecord.isDeleted()) {
- OnapPDPGroup newLocalGroup = null;
- if (extraData != null) {
- try {
- newLocalGroup = papEngine.getGroup(extraData);
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to get new pdp group with papEngine.getGroup(" + extraData
- + ");");
- }
- }
- try {
- papEngine.removeGroup(localGroup, newLocalGroup);
- } catch (NullPointerException | PAPException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to get remove pdp group with papEngine.removeGroup(" + localGroup
- + ", " + newLocalGroup + ");");
- throw new PAPException("Could not remove group " + groupId);
- }
- } else if (localGroup == null) {
- // creating a new group
- try {
- papEngine.newGroup(groupRecord.getgroupName(), groupRecord.getDescription());
- } catch (NullPointerException | PAPException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to create pdp group with papEngine.newGroup(groupRecord"
- + ".getgroupName(), groupRecord.getDescription());");
- throw new PAPException("Could not create group " + groupRecord);
- }
- try {
- localGroup = papEngine.getGroup(groupRecord.getGroupId());
- } catch (PAPException e1) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, policyDBDaoVar,
- "Caught PAPException trying to get pdp group we just created with papEngine.getGroup"
- + "(groupRecord.getGroupId());\nAny PDPs or policies in the new group may not have been added");
- return;
- }
- // add possible pdps to group
- List<?> pdpsInGroup = transaction.getPdpsInGroup(Long.parseLong(groupRecord.getGroupId()));
- for (Object pdpO : pdpsInGroup) {
- PdpEntity pdp = (PdpEntity) pdpO;
- try {
- papEngine.newPDP(pdp.getPdpId(), localGroup, pdp.getPdpName(), pdp.getDescription(),
- pdp.getJmxPort());
- } catch (NullPointerException | PAPException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to get create pdp with papEngine.newPDP(pdp.getPdpId(), "
- + "localGroup, pdp.getPdpName(), pdp.getDescription(), pdp.getJmxPort());");
- throw new PAPException("Could not create pdp " + pdp);
- }
- }
- // add possible policies to group (filesystem only, apparently)
- } else {
- if (!(localGroup instanceof StdPDPGroup)) {
- throw new PAPException("group is not a StdPDPGroup");
- }
- // clone the object
- // because it will be comparing the new group to its own version
- StdPDPGroup localGroupClone = new StdPDPGroup(localGroup.getId(), localGroup.isDefaultGroup(),
- localGroup.getName(), localGroup.getDescription(), ((StdPDPGroup) localGroup).getDirectory());
- localGroupClone.setOnapPdps(localGroup.getOnapPdps());
- localGroupClone.setPipConfigs(localGroup.getPipConfigs());
- localGroupClone.setStatus(localGroup.getStatus());
- // we are updating a group or adding a policy or changing default
- // set default if it should be
- if (!localGroupClone.isDefaultGroup() && groupRecord.isDefaultGroup()) {
- try {
- papEngine.setDefaultGroup(localGroup);
- return;
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to set default group with papEngine.SetDefaultGroup("
- + localGroupClone + ");");
- throw new PAPException("Could not set default group to " + localGroupClone);
- }
- }
- boolean needToUpdate = false;
- if (updateGroupPoliciesInFileSystem(localGroupClone, localGroup, groupRecord)) {
- needToUpdate = true;
- }
- if (!stringEquals(localGroupClone.getId(), groupRecord.getGroupId())
- || !stringEquals(localGroupClone.getName(), groupRecord.getgroupName())) {
- // changing ids
- // we do not want to change the id, the papEngine will do this for us, it needs to know the old id
- localGroupClone.setName(groupRecord.getgroupName());
- needToUpdate = true;
- }
- if (!stringEquals(localGroupClone.getDescription(), groupRecord.getDescription())) {
- localGroupClone.setDescription(groupRecord.getDescription());
- needToUpdate = true;
- }
- if (needToUpdate) {
- try {
- papEngine.updateGroup(localGroupClone);
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to update group with papEngine.updateGroup(" + localGroupClone
- + ");");
- throw new PAPException("Could not update group " + localGroupClone);
- }
- }
- }
- }
-
- // this will also handle removes, since incoming pdpGroup has no policies internally, we are just going to add
- // them all in from the db
- private boolean updateGroupPoliciesInFileSystem(OnapPDPGroup pdpGroup, OnapPDPGroup oldPdpGroup,
- GroupEntity groupRecord) throws PAPException, PolicyDBException {
- if (!(pdpGroup instanceof StdPDPGroup)) {
- throw new PAPException("group is not a StdPDPGroup");
- }
- StdPDPGroup group = (StdPDPGroup) pdpGroup;
- // this must always be true since we don't explicitly know when a delete is occuring
- boolean didUpdate = true;
- HashMap<String, PDPPolicy> currentPolicySet = new HashMap<>(oldPdpGroup.getPolicies().size());
- HashSet<PDPPolicy> newPolicySet = new HashSet<>();
- for (PDPPolicy pdpPolicy : oldPdpGroup.getPolicies()) {
- currentPolicySet.put(pdpPolicy.getId(), pdpPolicy);
- }
- for (PolicyEntity policy : groupRecord.getPolicies()) {
- String pdpPolicyName = getPdpPolicyName(policy.getPolicyName(), policy.getScope());
- if (group.getPolicy(pdpPolicyName) == null) {
- didUpdate = true;
- if (currentPolicySet.containsKey(pdpPolicyName)) {
- newPolicySet.add(currentPolicySet.get(pdpPolicyName));
- } else {
- logger.info(
- "PolicyDBDao: Adding the new policy to the PDP group after notification: " + pdpPolicyName);
- InputStream policyStream = new ByteArrayInputStream(policy.getPolicyData().getBytes());
- group.copyPolicyToFile(pdpPolicyName, policyStream);
- ((StdPDPPolicy) (group.getPolicy(pdpPolicyName)))
- .setName(removeExtensionAndVersionFromPolicyName(pdpPolicyName));
- try {
- policyStream.close();
- } catch (IOException e) {
- didUpdate = false;
- PolicyLogger.error(e.getMessage() + e);
- }
- }
- }
- }
- logger.info("PolicyDBDao: Adding updated policies to group after notification.");
- if (didUpdate) {
- newPolicySet.addAll(group.getPolicies());
- group.setPolicies(newPolicySet);
- }
- return didUpdate;
- }
-
/*
- * This method is called during all pushPolicy transactions and makes sure the file system group is in sync with the
- * database groupentity
+ * This method is called during all pushPolicy transactions and makes sure the file system group
+ * is in sync with the database groupentity
*/
- private StdPDPGroup synchronizeGroupPoliciesInFileSystem(StdPDPGroup pdpGroup, GroupEntity groupentity)
+ public StdPDPGroup synchronizeGroupPoliciesInFileSystem(StdPDPGroup pdpGroup, GroupEntity groupentity)
throws PAPException, PolicyDBException {
HashMap<String, PDPPolicy> currentPolicyMap = new HashMap<>();
@@ -895,6 +437,7 @@ public class PolicyDBDao {
newPolicy = new StdPDPPolicy(pdpPolicyId, true,
removeExtensionAndVersionFromPolicyName(pdpPolicyId), location);
newPolicySet.add(newPolicy);
+ logger.info("Adding new policy to PDPGroup - " + newPolicy.getId() + ", Location - " + location);
} catch (Exception e) {
logger.debug(e);
PolicyLogger
@@ -911,8 +454,8 @@ public class PolicyDBDao {
} catch (Exception e) {
logger.debug(e);
PolicyLogger
- .error("PolicyDBDao: Exception occurred while attempting to delete the old version of the"
- + " policy file from the group. " + e.getMessage());
+ .error("PolicyDBDao: Exception occurred while attempting to delete the old version of the policy file from the group. "
+ + e.getMessage());
}
}
}
@@ -923,7 +466,7 @@ public class PolicyDBDao {
return pdpGroup;
}
- private String removeExtensionAndVersionFromPolicyName(String originalPolicyName) throws PolicyDBException {
+ public String removeExtensionAndVersionFromPolicyName(String originalPolicyName) throws PolicyDBException {
return getPolicyNameAndVersionFromPolicyFileName(originalPolicyName)[0];
}
@@ -933,7 +476,7 @@ public class PolicyDBDao {
* @param originalPolicyName: a policy file name ex: Config_policy.2.xml
* @return An array [0]: The policy name, [1]: the policy version, as a string
*/
- private String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName) throws PolicyDBException {
+ public String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName) throws PolicyDBException {
String policyName = originalPolicyName;
String[] nameAndVersion = new String[2];
try {
@@ -958,160 +501,7 @@ public class PolicyDBDao {
return nameAndVersion;
}
- private void handleIncomingPdpChange(String pdpId, PolicyDBDaoTransaction transaction) throws PAPException {
- // get pdp
- long pdpIdLong = -1;
- try {
- pdpIdLong = Long.parseLong(pdpId);
- } catch (NumberFormatException e) {
- throw new IllegalArgumentException("pdpId " + pdpId + " cannot be parsed into a long");
- }
- PdpEntity pdpRecord = null;
- try {
- pdpRecord = transaction.getPdp(pdpIdLong);
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to get pdp record with transaction.getPdp(" + pdpIdLong + ");");
- throw new PAPException("Could not get local pdp " + pdpIdLong);
- }
- if (pdpRecord == null) {
- throw new PersistenceException("The pdpRecord returned is null");
- }
- PDP localPdp = null;
- try {
- localPdp = papEngine.getPDP(pdpRecord.getPdpId());
- } catch (PAPException e) {
- logger.warn("Caught PAPException trying to get local pdp with papEngine.getPDP(" + pdpId + ");", e);
- }
- if (localPdp != null && pdpRecord.isDeleted()) {
- try {
- papEngine.removePDP((OnapPDP) localPdp);
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to get remove pdp with papEngine.removePDP(" + localPdp + ");");
- throw new PAPException("Could not remove pdp " + pdpId);
- }
- } else if (localPdp == null) {
- // add new pdp
- // get group
- OnapPDPGroup localGroup = null;
- try {
- localGroup = papEngine.getGroup(pdpRecord.getGroup().getGroupId());
- } catch (PAPException e1) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, policyDBDaoVar,
- "Caught PAPException trying to get local group to add pdp to with papEngine.getGroup"
- + "(pdpRecord.getGroup().getGroupId());");
- throw new PAPException("Could not get local group");
- }
- try {
- papEngine.newPDP(pdpRecord.getPdpId(), localGroup, pdpRecord.getPdpName(), pdpRecord.getDescription(),
- pdpRecord.getJmxPort());
- } catch (NullPointerException | PAPException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to create pdp with papEngine.newPDP(" + pdpRecord.getPdpId() + ", "
- + localGroup + ", " + pdpRecord.getPdpName() + ", " + pdpRecord.getDescription() + ", "
- + pdpRecord.getJmxPort() + ");");
- throw new PAPException("Could not create pdp " + pdpRecord);
- }
- } else {
- boolean needToUpdate = false;
- if (!stringEquals(localPdp.getId(), pdpRecord.getPdpId())
- || !stringEquals(localPdp.getName(), pdpRecord.getPdpName())) {
- // again, we don't want to change the id, the papEngine will do this
- localPdp.setName(pdpRecord.getPdpName());
- needToUpdate = true;
- }
- if (!stringEquals(localPdp.getDescription(), pdpRecord.getDescription())) {
- localPdp.setDescription(pdpRecord.getDescription());
- needToUpdate = true;
- }
- String localPdpGroupId = null;
- try {
- localPdpGroupId = papEngine.getPDPGroup((OnapPDP) localPdp).getId();
- } catch (PAPException e) {
- // could be null or something, just warn at this point
- logger.warn("Caught PAPException trying to get id of local group that pdp is in with localPdpGroupId = "
- + "papEngine.getPDPGroup(localPdp).getId();", e);
- }
- if (!stringEquals(localPdpGroupId, pdpRecord.getGroup().getGroupId())) {
- OnapPDPGroup newPdpGroup = null;
- try {
- newPdpGroup = papEngine.getGroup(pdpRecord.getGroup().getGroupId());
- } catch (PAPException e) {
- // ok, now we have an issue. Time to stop things
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to get id of local group to move pdp to with papEngine"
- + ".getGroup(pdpRecord.getGroup().getGroupId());");
- throw new PAPException("Could not get local group");
- }
- try {
- papEngine.movePDP((OnapPDP) localPdp, newPdpGroup);
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to move pdp with papEngine.movePDP(localPdp, newPdpGroup);");
- throw new PAPException("Could not move pdp " + localPdp);
- }
- }
- if (((PdpEntity) localPdp).getJmxPort() != pdpRecord.getJmxPort()) {
- ((PdpEntity) localPdp).setJmxPort(pdpRecord.getJmxPort());
- needToUpdate = true;
- }
- if (needToUpdate) {
- try {
- papEngine.updatePDP((OnapPDP) localPdp);
- } catch (PAPException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PAPException trying to update pdp with papEngine.updatePdp(" + localPdp + ");");
- throw new PAPException("Could not update pdp " + localPdp);
- }
- }
- }
- // compare to local situation
- // call command to update
- }
-
- private void handleIncomingPolicyChange(String policyId) {
- String policyName = null;
- EntityManager em = emf.createEntityManager();
- Query getPolicyEntityQuery = em.createNamedQuery("PolicyEntity.FindById");
- getPolicyEntityQuery.setParameter("id", Long.valueOf(policyId));
-
- @SuppressWarnings("unchecked")
- List<PolicyEntity> policies = getPolicyEntityQuery.getResultList();
- PolicyEntity policy = null;
- if (!policies.isEmpty()) {
- policy = policies.get(0);
- }
- String action = "unknown action";
- try {
- if (policy != null) {
- policyName = policy.getPolicyName();
- logger.info("Deleting old Policy Config File for " + policy.getPolicyName());
- action = "delete";
- Path subFile = null;
-
- if (policy.getConfigurationData() != null) {
- subFile = getPolicySubFile(policy.getConfigurationData().getConfigurationName(), config);
- } else if (policy.getActionBodyEntity() != null) {
- subFile = getPolicySubFile(policy.getActionBodyEntity().getActionBodyName(), action);
- }
-
- if (subFile != null) {
- Files.deleteIfExists(subFile);
- }
- if (policy.getConfigurationData() != null) {
- writePolicySubFile(policy, config);
- } else if (policy.getActionBodyEntity() != null) {
- writePolicySubFile(policy, action);
- }
- }
- } catch (IOException e1) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, policyDBDaoVar,
- "Error occurred while performing [" + action + "] of Policy File: " + policyName);
- }
- }
-
- private String getPdpPolicyName(String name, String scope) {
+ public String getPdpPolicyName(String name, String scope) {
String finalName = "";
finalName += scope;
finalName += ".";
@@ -1124,109 +514,29 @@ public class PolicyDBDao {
return fileName.substring(0, fileName.lastIndexOf('.'));
}
- private Path getPolicySubFile(String inputFileName, String subFileType) {
- String filename = inputFileName;
- logger.info("getPolicySubFile(" + filename + ", " + subFileType + ")");
- Path filePath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS), subFileType);
- File file = null;
-
- filename = FilenameUtils.removeExtension(filename);
-
- for (File tmpFile : filePath.toFile().listFiles()) {
- if (FilenameUtils.removeExtension(tmpFile.getName()).equals(filename)) {
- file = tmpFile;
- }
- }
-
- Path finalPath = null;
- if (file != null) {
- finalPath = Paths.get(file.getAbsolutePath());
- }
-
- logger.info("end of getPolicySubFile: " + finalPath);
- return finalPath;
- }
-
- private boolean writePolicySubFile(PolicyEntity policy, String policyType) {
- logger.info("writePolicySubFile with policyName[" + policy.getPolicyName() + "] and policyType[" + policyType
- + "]");
- String type = null;
- String subTypeName = null;
- String subTypeBody = null;
- if (config.equalsIgnoreCase(policyType)) {
- type = config;
- subTypeName = FilenameUtils.removeExtension(policy.getConfigurationData().getConfigurationName());
- subTypeBody = policy.getConfigurationData().getConfigBody();
-
- String configType = policy.getConfigurationData().getConfigType();
-
- if (configType != null) {
- if (configType.equals(JSON_CONFIG)) {
- subTypeName = subTypeName + ".json";
- }
- if (configType.equals(XML_CONFIG)) {
- subTypeName = subTypeName + ".xml";
- }
- if (configType.equals(PROPERTIES_CONFIG)) {
- subTypeName = subTypeName + ".properties";
- }
- if (configType.equals(OTHER_CONFIG)) {
- subTypeName = subTypeName + ".txt";
- }
- }
- } else if (action.equalsIgnoreCase(policyType)) {
- type = action;
- subTypeName = policy.getActionBodyEntity().getActionBodyName();
- subTypeBody = policy.getActionBodyEntity().getActionBody();
- }
- Path filePath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS).toString(), type);
-
- if (subTypeBody == null) {
- subTypeBody = "";
- }
- boolean success = false;
- try {
- Files.deleteIfExists(Paths.get(filePath.toString(), subTypeName));
- File file = Paths.get(filePath.toString(), subTypeName).toFile();
- boolean value = file.createNewFile();
- logger.debug("New file created successfully" + value);
- try (FileWriter fileWriter = new FileWriter(file, false)) {
- // false to overwrite
- fileWriter.write(subTypeBody);
- fileWriter.close();
- success = true;
- }
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Exception occured while creating Configuration File for Policy : " + policy.getPolicyName());
- }
- return success;
- }
-
public void auditLocalDatabase(PAPPolicyEngine papEngine2) {
logger.debug("PolicyDBDao.auditLocalDatabase() is called");
try {
deleteAllGroupTables();
auditGroups(papEngine2);
} catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "auditLocalDatabase() error");
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, POLICYDBDAO_VAR, "auditLocalDatabase() error");
logger.error("Exception Occured" + e);
}
}
-
public StdPDPGroup auditLocalFileSystem(StdPDPGroup group) {
logger.info("Starting Local File System group audit");
- EntityManager em = emf.createEntityManager();
- em.getTransaction().begin();
+ Session session = sessionfactory.openSession();
+ session.getTransaction().begin();
StdPDPGroup updatedGroup = null;
try {
- Query groupQuery = em.createQuery(groupEntitySelectQuery);
- groupQuery.setParameter(groupIdVar, group.getId());
- groupQuery.setParameter(deletedVar, false);
- List<?> groupQueryList = groupQuery.getResultList();
+ Query groupQuery = session.createQuery(GROUPENTITY_SELECT);
+ groupQuery.setParameter(GROUP_ID, group.getId());
+ groupQuery.setParameter(DELETED, false);
+ List<?> groupQueryList = groupQuery.list();
if (groupQueryList != null && !groupQueryList.isEmpty()) {
GroupEntity dbgroup = (GroupEntity) groupQueryList.get(0);
updatedGroup = synchronizeGroupPoliciesInFileSystem(group, dbgroup);
@@ -1236,39 +546,91 @@ public class PolicyDBDao {
logger.error(e);
} catch (Exception e) {
logger.error(e);
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, POLICYDBDAO_VAR,
"Caught Exception trying to check if group exists groupQuery.getResultList()");
throw new PersistenceException("Query failed trying to check if group " + group.getId() + " exists");
}
- em.getTransaction().commit();
- em.close();
+ session.getTransaction().commit();
+ session.close();
return updatedGroup;
+ }
+
+ /*
+ * This method is called at startup to recreate config data from DB to the file system.
+ *
+ */
+ public void synchronizeConfigDataInFileSystem() {
+ logger.info("Starting Local File System Config data Sync");
+ // sync both web apps Config and Action
+ syncConfigData(ConfigurationDataEntity.class, CONFIG);
+ syncConfigData(ActionBodyEntity.class, ACTION);
+ }
+
+ private <T> void syncConfigData(Class<T> cl, String type) {
+ Session session = sessionfactory.openSession();
+ try {
+ final Criteria configDataQuery = session.createCriteria(cl.getName());
+ @SuppressWarnings("unchecked")
+ final List<T> configDataResult = configDataQuery.list();
+ Path webappsPath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS), type);
+
+ for (final T configData : configDataResult) {
+ String configName = null;
+ byte[] configBody;
+ try {
+ if (CONFIG.equalsIgnoreCase(type)) {
+ configName = ((ConfigurationDataEntity) configData).getConfigurationName();
+ configBody = (((ConfigurationDataEntity) configData).getConfigBody() != null)
+ ? ((ConfigurationDataEntity) configData).getConfigBody()
+ .getBytes(StandardCharsets.UTF_8)
+ : "".getBytes();
+ } else {
+ configName = ((ActionBodyEntity) configData).getActionBodyName();
+ configBody = (((ActionBodyEntity) configData).getActionBody() != null)
+ ? ((ActionBodyEntity) configData).getActionBody().getBytes(StandardCharsets.UTF_8)
+ : "".getBytes();
+ }
+ Path filePath = Paths.get(webappsPath.toString(), configName);
+ if (!filePath.toFile().exists()) {
+ Files.write(filePath, configBody);
+ logger.info("Created Config File from DB - " + filePath.toString());
+ }
+ } catch (Exception e) {
+ // log and keep going
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, POLICYDBDAO_VAR,
+ "Exception occured while creating Configuration File - " + configName);
+ }
+ }
+ } catch (final Exception exception) {
+ logger.error("Unable to synchronizeConfigDataInFileSystem", exception);
+ }
+ session.close();
}
public void deleteAllGroupTables() {
logger.debug("PolicyDBDao.deleteAllGroupTables() called");
- EntityManager em = emf.createEntityManager();
- em.getTransaction().begin();
+ Session session = sessionfactory.openSession();
+ session.getTransaction().begin();
- Query deletePdpEntityEntityTableUpdate = em.createNamedQuery("PdpEntity.deleteAll");
+ Query deletePdpEntityEntityTableUpdate = session.getNamedQuery("PdpEntity.deleteAll");
deletePdpEntityEntityTableUpdate.executeUpdate();
- Query deleteGroupEntityTableUpdate = em.createNamedQuery("GroupEntity.deleteAll");
+ Query deleteGroupEntityTableUpdate = session.getNamedQuery("GroupEntity.deleteAll");
deleteGroupEntityTableUpdate.executeUpdate();
- em.getTransaction().commit();
- em.close();
+ session.getTransaction().commit();
+ session.close();
}
@SuppressWarnings("unchecked")
public void auditGroups(PAPPolicyEngine papEngine2) {
logger.debug("PolicyDBDao.auditGroups() called");
- EntityManager em = emf.createEntityManager();
- em.getTransaction().begin();
+ Session session = sessionfactory.openSession();
+ session.getTransaction().begin();
final String AUDIT_STR = "Audit";
try {
@@ -1277,25 +639,24 @@ public class PolicyDBDao {
for (OnapPDPGroup grp : groups) {
try {
GroupEntity groupEntity = new GroupEntity();
- em.persist(groupEntity);
groupEntity.setGroupName(grp.getName());
groupEntity.setDescription(grp.getDescription());
groupEntity.setDefaultGroup(grp.isDefaultGroup());
groupEntity.setCreatedBy(AUDIT_STR);
groupEntity.setGroupId(createNewPDPGroupId(grp.getId()));
groupEntity.setModifiedBy(AUDIT_STR);
+ session.persist(groupEntity);
Set<OnapPDP> pdps = grp.getOnapPdps();
for (OnapPDP pdp : pdps) {
PdpEntity pdpEntity = new PdpEntity();
- em.persist(pdpEntity);
pdpEntity.setGroup(groupEntity);
pdpEntity.setJmxPort(pdp.getJmxPort());
pdpEntity.setPdpId(pdp.getId());
pdpEntity.setPdpName(pdp.getName());
pdpEntity.setModifiedBy(AUDIT_STR);
pdpEntity.setCreatedBy(AUDIT_STR);
-
+ session.persist(pdpEntity);
}
Set<PDPPolicy> policies = grp.getPolicies();
@@ -1308,11 +669,11 @@ public class PolicyDBDao {
"Invalid input - policyID must contain name, scope and version");
}
List<PolicyEntity> policyEntityList;
- Query getPolicyEntitiesQuery = em.createNamedQuery("PolicyEntity.findByNameAndScope");
+ Query getPolicyEntitiesQuery = session.getNamedQuery("PolicyEntity.findByNameAndScope");
getPolicyEntitiesQuery.setParameter("name", stringArray[0]);
- getPolicyEntitiesQuery.setParameter(scope, stringArray[1]);
+ getPolicyEntitiesQuery.setParameter(SCOPE, stringArray[1]);
- policyEntityList = getPolicyEntitiesQuery.getResultList();
+ policyEntityList = getPolicyEntitiesQuery.list();
PolicyEntity policyEntity = null;
if (!policyEntityList.isEmpty()) {
policyEntity = policyEntityList.get(0);
@@ -1321,28 +682,28 @@ public class PolicyDBDao {
groupEntity.addPolicyToGroup(policyEntity);
}
} catch (Exception e2) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, policyDBDaoVar,
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, POLICYDBDAO_VAR,
"Exception auditGroups inner catch");
}
}
} catch (Exception e1) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, policyDBDaoVar,
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, POLICYDBDAO_VAR,
"Exception auditGroups middle catch");
}
}
} catch (Exception e) {
- em.getTransaction().rollback();
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Exception auditGroups outer catch");
- em.close();
+ session.getTransaction().rollback();
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, POLICYDBDAO_VAR, "Exception auditGroups outer catch");
+ session.close();
return;
}
- em.getTransaction().commit();
- em.close();
+ session.getTransaction().commit();
+ session.close();
}
- private String getConfigFile(String filename, PolicyRestAdapter policy) {
+ public String getConfigFile(String filename, PolicyRestAdapter policy) {
if (policy == null) {
return getConfigFile(filename, (String) null);
}
@@ -1352,7 +713,7 @@ public class PolicyDBDao {
// copied from ConfigPolicy.java and modified
// Here we are adding the extension for the configurations file based on the
// config type selection for saving.
- private String getConfigFile(String inputFilename, String configType) {
+ public String getConfigFile(String inputFilename, String configType) {
String filename = inputFilename;
logger.debug("getConfigFile(String filename, String scope, String configType) as getConfigFile(" + filename
+ ", " + configType + ") called");
@@ -1376,7 +737,7 @@ public class PolicyDBDao {
return filename;
}
- private String[] getNameScopeAndVersionFromPdpPolicy(String fileName) {
+ public String[] getNameScopeAndVersionFromPdpPolicy(String fileName) {
String[] splitByDots = fileName.split("\\.");
if (splitByDots.length < 3) {
return null;
@@ -1401,7 +762,8 @@ public class PolicyDBDao {
public static String createNewPDPGroupId(String name) {
String id = name;
- // replace "bad" characters with sequences that will be ok for file names and properties keys.
+ // replace "bad" characters with sequences that will be ok for file
+ // names and properties keys.
id = id.replace(" ", "_sp_");
id = id.replace("\t", "_tab_");
id = id.replace("\\", "_bksl_");
@@ -1435,1429 +797,6 @@ public class PolicyDBDao {
return false;
}
-
- private class PolicyDBDaoTransactionInstance implements PolicyDBDaoTransaction {
- private EntityManager em;
- private final Object emLock = new Object();
- long policyId;
- long groupId;
- long pdpId;
- String newGroupId;
- private boolean operationRun = false;
- private final Thread transactionTimer;
-
- private PolicyDBDaoTransactionInstance() {
- // call the constructor with arguments
- this(Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)),
- Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT)));
- }
-
- // timeout is how long the transaction can sit before rolling back
- // wait time is how long to wait for the transaction to start before throwing an exception
- private PolicyDBDaoTransactionInstance(int transactionTimeout, int transactionWaitTime) {
- if (logger.isDebugEnabled()) {
- logger.debug("\n\nPolicyDBDaoTransactionInstance() as PolicyDBDaoTransactionInstance() called:"
- + "\n transactionTimeout = " + transactionTimeout + "\n transactionWaitTime = "
- + transactionWaitTime + "\n\n");
- }
- this.em = emf.createEntityManager();
- policyId = -1;
- groupId = -1;
- pdpId = -1;
- newGroupId = null;
- synchronized (emLock) {
- try {
- startTransactionSynced(this.em, transactionWaitTime);
- } catch (Exception e) {
- logger.debug(e);
- throw new PersistenceException(
- "Could not lock transaction within " + transactionWaitTime + " milliseconds");
- }
- }
- class TransactionTimer implements Runnable {
-
- private int sleepTime;
-
- public TransactionTimer(int timeout) {
- this.sleepTime = timeout;
- }
-
- @Override
- public void run() {
- if (logger.isDebugEnabled()) {
- Date date = new java.util.Date();
- logger.debug("\n\nTransactionTimer.run() - SLEEPING: " + "\n sleepTime (ms) = " + sleepTime
- + TIMESTAMP + date.getTime() + "\n\n");
- }
- try {
- Thread.sleep(sleepTime);
- } catch (InterruptedException e) {
- // probably, the transaction was completed, the last thing we want to do is roll back
- if (logger.isDebugEnabled()) {
- Date date = new java.util.Date();
- logger.debug("\n\nTransactionTimer.run() - WAKE Interrupt: " + TIMESTAMP
- + date.getTime() + "\n\n");
- }
- Thread.currentThread().interrupt();
- return;
- }
- if (logger.isDebugEnabled()) {
- Date date = new java.util.Date();
- logger.debug("\n\nTransactionTimer.run() - WAKE Timeout: " + TIMESTAMP
- + date.getTime() + "\n\n");
- }
- rollbackTransaction();
- }
-
- }
-
- transactionTimer = new Thread(new TransactionTimer(transactionTimeout), "transactionTimerThread");
- transactionTimer.start();
-
-
- }
-
- private void checkBeforeOperationRun() {
- checkBeforeOperationRun(false);
- }
-
- private void checkBeforeOperationRun(boolean justCheckOpen) {
- if (!isTransactionOpen()) {
- PolicyLogger.error("There is no transaction currently open");
- throw new IllegalStateException("There is no transaction currently open");
- }
- if (operationRun && !justCheckOpen) {
- PolicyLogger.error(
- "An operation has already been performed and the current transaction should be " + "committed");
- throw new IllegalStateException(
- "An operation has already been performed and the current transaction should be committed");
- }
- operationRun = true;
- }
-
- @Override
- public void commitTransaction() {
- synchronized (emLock) {
- logger.debug("commitTransaction() as commitTransaction() called");
- if (!isTransactionOpen()) {
- logger.warn("There is no open transaction to commit");
- try {
- em.close();
- } catch (Exception e) {
- logger.error("Exception Occured" + e);
- }
- return;
- }
- try {
- em.getTransaction().commit();
- } catch (RollbackException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught RollbackException on em.getTransaction().commit()");
- throw new PersistenceException("The commit failed. Message:\n" + e.getMessage());
- }
- em.close();
- // need to revisit
- if (policyId >= 0) {
- if (newGroupId != null) {
- try {
- notifyOthers(policyId, POLICY_NOTIFICATION, newGroupId);
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- CAUGHTEXCEPTIONONNOTIFY + policyId + "," + POLICY_NOTIFICATION + ","
- + newGroupId + ")");
- }
- } else {
- try {
- notifyOthers(policyId, POLICY_NOTIFICATION);
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- CAUGHTEXCEPTIONONNOTIFY + policyId + "," + POLICY_NOTIFICATION + ")");
- }
- }
- }
- if (groupId >= 0) {
- // we don't want commit to fail just because this does
- if (newGroupId != null) {
- try {
- notifyOthers(groupId, GROUP_NOTIFICATION, newGroupId);
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- CAUGHTEXCEPTIONONNOTIFY + groupId + "," + GROUP_NOTIFICATION + ","
- + newGroupId + ")");
- }
- } else {
- try {
- notifyOthers(groupId, GROUP_NOTIFICATION);
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- CAUGHTEXCEPTIONONNOTIFY + groupId + "," + GROUP_NOTIFICATION + ")");
- }
- }
- }
- if (pdpId >= 0) {
- // we don't want commit to fail just because this does
- try {
- notifyOthers(pdpId, PDP_NOTIFICATION);
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- CAUGHTEXCEPTIONONNOTIFY + pdpId + "," + PDP_NOTIFICATION + ")");
- }
- }
- }
- if (transactionTimer != null) {
- transactionTimer.interrupt();
- }
- }
-
- @Override
- public void rollbackTransaction() {
- logger.debug("rollbackTransaction() as rollbackTransaction() called");
- synchronized (emLock) {
- if (isTransactionOpen()) {
-
- try {
- em.getTransaction().rollback();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Could not rollback transaction");
- }
- try {
- em.close();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Could not close EntityManager");
- }
-
- } else {
- try {
- em.close();
- } catch (Exception e) {
- logger.warn("Could not close already closed transaction", e);
- }
- }
-
- }
- if (transactionTimer != null) {
- transactionTimer.interrupt();
- }
- }
-
- private void createPolicy(PolicyRestAdapter policy, String username, String policyScope, String inputPolicyName,
- String policyDataString) {
- String policyName = inputPolicyName;
- logger.debug(
- "createPolicy(PolicyRestAdapter policy, String username, String policyScope, String policyName, "
- + "String policyDataString) as createPolicy(" + policy + ", " + username + ", "
- + policyScope + ", " + policyName + ", " + policyDataString + ") called");
- synchronized (emLock) {
- checkBeforeOperationRun();
- String configName = policyName;
- if (policyName.contains("Config_")) {
- policyName = policyName.replace(".Config_", ":Config_");
- } else if (policyName.contains("Action_")) {
- policyName = policyName.replace(".Action_", ":Action_");
- } else if (policyName.contains("Decision_")) {
- policyName = policyName.replace(".Decision_", ":Decision_");
- }
- policyName = policyName.split(":")[1];
- Query createPolicyQuery = em
- .createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName");
- createPolicyQuery.setParameter(scope, policyScope);
- createPolicyQuery.setParameter("policyName", policyName);
- List<?> createPolicyQueryList = createPolicyQuery.getResultList();
- PolicyEntity newPolicyEntity;
- boolean update;
- if (createPolicyQueryList.isEmpty()) {
- newPolicyEntity = new PolicyEntity();
- update = false;
- } else if (createPolicyQueryList.size() > 1) {
- PolicyLogger
- .error("Somehow, more than one policy with the same scope, name, and deleted status were "
- + "found in the database");
- throw new PersistenceException(
- "Somehow, more than one policy with the same scope, name, and deleted status were found "
- + "in the database");
- } else {
- newPolicyEntity = (PolicyEntity) createPolicyQueryList.get(0);
- update = true;
- }
-
- ActionBodyEntity newActionBodyEntity = null;
- if (policy.getPolicyType().equals(action)) {
- boolean abupdate = false;
- if (newPolicyEntity.getActionBodyEntity() == null) {
- newActionBodyEntity = new ActionBodyEntity();
- } else {
- newActionBodyEntity = em.find(ActionBodyEntity.class,
- newPolicyEntity.getActionBodyEntity().getActionBodyId());
- abupdate = true;
- }
-
- if (newActionBodyEntity != null) {
- if (!abupdate) {
- em.persist(newActionBodyEntity);
- }
- // build the file path
- // trim the .xml off the end
- String policyNameClean = FilenameUtils.removeExtension(configName);
- String actionBodyName = policyNameClean + ".json";
-
- // get the action body
- String actionBodyString = policy.getActionBody();
- if (actionBodyString == null) {
- actionBodyString = "{}";
- }
- newActionBodyEntity.setActionBody(actionBodyString);
- newActionBodyEntity.setActionBodyName(actionBodyName);
- newActionBodyEntity.setModifiedBy("PolicyDBDao.createPolicy()");
- newActionBodyEntity.setDeleted(false);
- if (!abupdate) {
- newActionBodyEntity.setCreatedBy("PolicyDBDao.createPolicy()");
- }
- if (logger.isDebugEnabled()) {
- logger.debug("\nPolicyDBDao.createPolicy" + "\n newActionBodyEntity.getActionBody() = "
- + newActionBodyEntity.getActionBody()
- + "\n newActionBodyEntity.getActionBodyName() = "
- + newActionBodyEntity.getActionBodyName()
- + "\n newActionBodyEntity.getModifiedBy() = "
- + newActionBodyEntity.getModifiedBy() + "\n newActionBodyEntity.getCreatedBy() = "
- + newActionBodyEntity.getCreatedBy() + "\n newActionBodyEntity.isDeleted() = "
- + newActionBodyEntity.isDeleted() + "\n FLUSHING to DB");
- }
- // push the actionBodyEntity to the DB
- em.flush();
- } else {
- // newActionBodyEntity == null
- // We have a actionBody in the policy but we found no actionBody in the DB
- String msg = "\n\nPolicyDBDao.createPolicy - Incoming Action policy had an "
- + "actionBody, but it could not be found in the DB for update." + "\n policyScope = "
- + policyScope + "\n policyName = " + policyName + "\n\n";
- PolicyLogger
- .error("PolicyDBDao.createPolicy - Incoming Action policy had an actionBody, but it "
- + "could not be found in the DB for update: policyName = " + policyName);
- throw new IllegalArgumentException(msg);
- }
- }
-
- ConfigurationDataEntity newConfigurationDataEntity;
- if (policy.getPolicyType().equals(config)) {
- boolean configUpdate;
- if (newPolicyEntity.getConfigurationData() == null) {
- newConfigurationDataEntity = new ConfigurationDataEntity();
- configUpdate = false;
- } else {
- newConfigurationDataEntity = em.find(ConfigurationDataEntity.class,
- newPolicyEntity.getConfigurationData().getConfigurationDataId());
- configUpdate = true;
- }
-
- if (newConfigurationDataEntity != null) {
- if (!configUpdate) {
- em.persist(newConfigurationDataEntity);
- }
- if (!stringEquals(newConfigurationDataEntity.getConfigurationName(),
- getConfigFile(configName, policy))) {
- newConfigurationDataEntity.setConfigurationName(getConfigFile(configName, policy));
- }
- if (newConfigurationDataEntity.getConfigType() == null
- || !newConfigurationDataEntity.getConfigType().equals(policy.getConfigType())) {
- newConfigurationDataEntity.setConfigType(policy.getConfigType());
- }
- if (!configUpdate) {
- newConfigurationDataEntity.setCreatedBy(username);
- }
- if (newConfigurationDataEntity.getModifiedBy() == null
- || !newConfigurationDataEntity.getModifiedBy().equals(username)) {
- newConfigurationDataEntity.setModifiedBy(username);
- }
- if (newConfigurationDataEntity.getDescription() == null
- || !"".equals(newConfigurationDataEntity.getDescription())) {
- newConfigurationDataEntity.setDescription("");
- }
- if (newConfigurationDataEntity.getConfigBody() == null
- || newConfigurationDataEntity.getConfigBody().isEmpty()
- || (!newConfigurationDataEntity.getConfigBody().equals(policy.getConfigBodyData()))) {
- // hopefully one of these won't be null
- if (policy.getConfigBodyData() == null || policy.getConfigBodyData().isEmpty()) {
- newConfigurationDataEntity.setConfigBody(policy.getJsonBody());
- } else {
- newConfigurationDataEntity.setConfigBody(policy.getConfigBodyData());
- }
- }
- if (newConfigurationDataEntity.isDeleted()) {
- newConfigurationDataEntity.setDeleted(false);
- }
-
- em.flush();
- } else {
- // We have a configurationData body in the policy but we found no configurationData body in
- // the DB
- String msg = "\n\nPolicyDBDao.createPolicy - Incoming Config policy had a "
- + "configurationData body, but it could not be found in the DB for update."
- + "\n policyScope = " + policyScope + "\n policyName = " + policyName + "\n\n";
- PolicyLogger.error("PolicyDBDao.createPolicy - Incoming Config policy had a configurationData "
- + "body, but it could not be found in the DB for update: policyName = " + policyName);
- throw new IllegalArgumentException(msg);
- }
-
- } else {
- newConfigurationDataEntity = null;
- }
- if (!update) {
- em.persist(newPolicyEntity);
- }
-
- policyId = newPolicyEntity.getPolicyId();
-
- if (!stringEquals(newPolicyEntity.getPolicyName(), policyName)) {
- newPolicyEntity.setPolicyName(policyName);
- }
- if (!stringEquals(newPolicyEntity.getCreatedBy(), username)) {
- newPolicyEntity.setCreatedBy(username);
- }
- if (!stringEquals(newPolicyEntity.getDescription(), policy.getPolicyDescription())) {
- newPolicyEntity.setDescription(policy.getPolicyDescription());
- }
- if (!stringEquals(newPolicyEntity.getModifiedBy(), username)) {
- newPolicyEntity.setModifiedBy(username);
- }
- if (!stringEquals(newPolicyEntity.getPolicyData(), policyDataString)) {
- newPolicyEntity.setPolicyData(policyDataString);
- }
- if (!stringEquals(newPolicyEntity.getScope(), policyScope)) {
- newPolicyEntity.setScope(policyScope);
- }
- if (newPolicyEntity.isDeleted() == true) {
- newPolicyEntity.setDeleted(false);
- }
- newPolicyEntity.setConfigurationData(newConfigurationDataEntity);
- newPolicyEntity.setActionBodyEntity(newActionBodyEntity);
-
- em.flush();
- this.policyId = newPolicyEntity.getPolicyId();
- }
- }
-
- @SuppressWarnings("unused")
- public PolicyEntity getPolicy(int policyID) {
- return getPolicy(policyID, null, null);
- }
-
- public PolicyEntity getPolicy(String policyName, String scope) {
- return getPolicy(-1, policyName, scope);
- }
-
- private PolicyEntity getPolicy(int policyID, String policyName, String scope) {
- logger.debug("getPolicy(int policyId, String policyName) as getPolicy(" + policyID + "," + policyName
- + ") called");
- if (policyID < 0 && isNullOrEmpty(policyName, scope)) {
- throw new IllegalArgumentException(
- "policyID must be at least 0 or policyName must be not null or blank");
- }
-
- synchronized (emLock) {
- checkBeforeOperationRun(true);
- // check if group exists
- String policyId;
- Query policyQuery;
- if (!isNullOrEmpty(policyName, scope)) {
- policyId = policyName;
- policyQuery =
- em.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
- policyQuery.setParameter("name", policyId);
- policyQuery.setParameter("scope", scope);
- } else {
- policyId = String.valueOf(policyID);
- policyQuery = em.createNamedQuery("PolicyEntity.FindById");
- policyQuery.setParameter("id", policyId);
- }
- List<?> policyQueryList;
- try {
- policyQueryList = policyQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to get policy with policyQuery.getResultList()");
- throw new PersistenceException("Query failed trying to get policy " + policyId);
- }
- if (policyQueryList.isEmpty()) {
- PolicyLogger.error("Policy does not exist with id " + policyId);
- throw new PersistenceException("Group policy is being added to does not exist with id " + policyId);
- } else if (policyQueryList.size() > 1) {
- PolicyLogger.error(duplicatePolicyId + policyId + foundInDB);
- throw new PersistenceException(duplicatePolicyId + policyId + foundInDB);
- }
- return (PolicyEntity) policyQueryList.get(0);
- }
- }
-
- @Override
- public GroupEntity getGroup(long groupKey) {
- logger.debug("getGroup(int groupKey) as getGroup(" + groupKey + ") called");
- if (groupKey < 0) {
- throw new IllegalArgumentException("groupKey must be at least 0");
- }
- synchronized (emLock) {
- checkBeforeOperationRun(true);
- // check if group exists
- Query groupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupKey=:groupKey");
- groupQuery.setParameter("groupKey", groupKey);
- List<?> groupQueryList;
- try {
- groupQueryList = groupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to get group with groupQuery.getResultList()");
- throw new PersistenceException(queryFailedToGetGroup + groupKey);
- }
- if (groupQueryList.isEmpty()) {
- PolicyLogger.error("Group does not exist with groupKey " + groupKey);
- throw new PersistenceException("Group does not exist with groupKey " + groupKey);
- } else if (groupQueryList.size() > 1) {
- PolicyLogger.error("Somehow, more than one group with the groupKey " + groupKey + foundInDB);
- throw new PersistenceException(
- "Somehow, more than one group with the groupKey " + groupKey + foundInDB);
- }
- return (GroupEntity) groupQueryList.get(0);
- }
- }
-
- @Override
- public GroupEntity getGroup(String groupId) {
- logger.debug("getGroup(String groupId) as getGroup(" + groupId + ") called");
- if (isNullOrEmpty(groupId)) {
- throw new IllegalArgumentException("groupId must not be null or empty");
- }
- synchronized (emLock) {
- checkBeforeOperationRun(true);
- // check if group exists
- Query groupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId");
- groupQuery.setParameter(groupIdVar, groupId);
- List<?> groupQueryList;
- try {
- groupQueryList = groupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to get group with groupQuery.getResultList()");
- throw new PersistenceException(queryFailedToGetGroup + groupId);
- }
- if (groupQueryList.isEmpty()) {
- PolicyLogger.error("Group does not exist with id " + groupId);
- throw new PersistenceException("Group does not exist with id " + groupId);
- } else if (groupQueryList.size() > 1) {
- PolicyLogger.error(duplicateGroupId + groupId + foundInDB);
- throw new PersistenceException(duplicateGroupId + groupId + foundInDB);
- }
- return (GroupEntity) groupQueryList.get(0);
- }
- }
-
- @Override
- public List<?> getPdpsInGroup(long groupKey) {
- logger.debug("getPdpsInGroup(int groupKey) as getPdpsInGroup(" + groupKey + ") called");
- if (groupKey < 0) {
- throw new IllegalArgumentException("groupId must not be < 0");
- }
- synchronized (emLock) {
- checkBeforeOperationRun(true);
- Query pdpsQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.groupEntity=:group");
- pdpsQuery.setParameter("group", getGroup(groupKey));
- return pdpsQuery.getResultList();
- }
- }
-
- @Override
- public PdpEntity getPdp(long pdpKey) {
- logger.debug("getPdp(int pdpKey) as getPdp(" + pdpKey + ") called");
- if (pdpKey < 0) {
- throw new IllegalArgumentException("pdpKey must be at least 0");
- }
- synchronized (emLock) {
- checkBeforeOperationRun(true);
- // check if group exists
- Query pdpQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpKey=:pdpKey");
- pdpQuery.setParameter("pdpKey", pdpKey);
- List<?> pdpQueryList;
- try {
- pdpQueryList = pdpQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to get pdp with pdpQuery.getResultList()");
- throw new PersistenceException("Query failed trying to get pdp " + pdpKey);
- }
- if (pdpQueryList.isEmpty()) {
- PolicyLogger.error("Pdp does not exist with pdpKey " + pdpKey);
- throw new PersistenceException("Pdp does not exist with pdpKey " + pdpKey);
- } else if (pdpQueryList.size() > 1) {
- PolicyLogger.error("Somehow, more than one pdp with the pdpKey " + pdpKey + foundInDB);
- throw new PersistenceException("Somehow, more than one pdp with the pdpKey " + pdpKey + foundInDB);
- }
- return (PdpEntity) pdpQueryList.get(0);
- }
- }
-
- @Override
- public boolean isTransactionOpen() {
- logger.debug("isTransactionOpen() as isTransactionOpen() called");
- synchronized (emLock) {
- return em.isOpen() && em.getTransaction().isActive();
- }
- }
-
- private String processConfigPath(String inputConfigPath) {
- String configPath = inputConfigPath;
- String webappsPath = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS);
- if (webappsPath == null) {
- logger.error("Webapps property does not exist");
- throw new IllegalArgumentException("Webapps property does not exist");
- }
- configPath = configPath.replace("$URL", webappsPath);
- // make sure the correct slashes are in
- try {
- configPath = Paths.get(configPath).toString();
- } catch (InvalidPathException e) {
- logger.error("Invalid config path: " + configPath, e);
- throw new IllegalArgumentException("Invalid config path: " + configPath);
- }
- return configPath;
- }
-
- private String readConfigFile(String configPath) {
- String configDataString = null;
- try (InputStream configContentStream = new FileInputStream(configPath);) {
- configDataString = IOUtils.toString(configContentStream);
- } catch (FileNotFoundException e) {
- logger.error("Caught FileNotFoundException on new FileInputStream(" + configPath + ")", e);
- throw new IllegalArgumentException("The config file path does not exist");
- } catch (IOException e2) {
- logger.error("Caught IOException on newIOUtils.toString(configContentStream)", e2);
- throw new IllegalArgumentException("The config file path cannot be read");
- }
- if (configDataString == null) {
- throw new IllegalArgumentException("The config file path cannot be read");
- }
- return configDataString;
- }
-
- @Override
- public void createPolicy(Policy policy, String username) {
-
- try {
- logger.debug("createPolicy(PolicyRestAdapter policy, String username) as createPolicy(" + policy + ","
- + username + ") called");
- String policyScope = policy.policyAdapter.getDomainDir().replace(File.separator, ".");
- // Does not need to be XACMLPolicyWriterWithPapNotify since it is already in the PAP
- // and this transaction is intercepted up stream.
-
- String policyDataString = getPolicyDataString(policy);
- if (isJunit) {
- // Using parentPath object to set policy data.
- policyDataString = policy.policyAdapter.getParentPath();
- }
- String configPath = "";
- if (policy.policyAdapter.getPolicyType().equalsIgnoreCase(config)) {
- configPath = evaluateXPath(
- "/Policy/Rule/AdviceExpressions/AdviceExpression[contains(@AdviceId,'ID')"
- + "]/AttributeAssignmentExpression[@AttributeId='URLID']/AttributeValue/text()",
- policyDataString);
- } else if (policy.policyAdapter.getPolicyType().equalsIgnoreCase(action)) {
- configPath = evaluateXPath(
- "/Policy/Rule/ObligationExpressions/ObligationExpression[contains(@ObligationId, "
- + policy.policyAdapter.getActionAttribute()
- + ")]/AttributeAssignmentExpression[@AttributeId='body']/AttributeValue/text()",
- policyDataString);
- }
-
- String prefix = null;
- if (policy.policyAdapter.getPolicyType().equalsIgnoreCase(config)) {
-
- prefix = configPath.substring(
- configPath.indexOf(policyScope + ".") + policyScope.concat(".").length(),
- configPath.lastIndexOf(policy.policyAdapter.getPolicyName()));
- if (isNullOrEmpty(policy.policyAdapter.getConfigBodyData())) {
- policy.policyAdapter.setConfigBodyData(getConfigData(configPath));
- }
- } else if (action.equalsIgnoreCase(policy.policyAdapter.getPolicyType())) {
- prefix = "Action_";
- } else if ("Decision".equalsIgnoreCase(policy.policyAdapter.getPolicyType())) {
- prefix = "Decision_";
- }
-
- if (!(policy.policyAdapter.getData() instanceof PolicyType)
- && !(policy.policyAdapter.getData() instanceof PolicySetType)) {
- PolicyLogger.error("The data field is not an instance of PolicyType or PolicySetType");
- throw new IllegalArgumentException(
- "The data field is not an instance of PolicyType or PolicySetType");
- }
- String finalName = policyScope + "." + prefix + policy.policyAdapter.getPolicyName() + "."
- + policy.policyAdapter.getHighestVersion() + ".xml";
- if (policy.policyAdapter.getConfigType() == null || "".equals(policy.policyAdapter.getConfigType())) {
- // get the config file extension
- String ext = "";
- if (configPath != null && !"".equalsIgnoreCase(configPath)) {
- ext = configPath.substring(configPath.lastIndexOf('.'), configPath.length());;
- }
-
- if (ext.contains("txt")) {
- policy.policyAdapter.setConfigType(OTHER_CONFIG);
- } else if (ext.contains("json")) {
- policy.policyAdapter.setConfigType(JSON_CONFIG);
- } else if (ext.contains("xml")) {
- policy.policyAdapter.setConfigType(XML_CONFIG);
- } else if (ext.contains("properties")) {
- policy.policyAdapter.setConfigType(PROPERTIES_CONFIG);
- } else {
- if (policy.policyAdapter.getPolicyType().equalsIgnoreCase(action)) {
- policy.policyAdapter.setConfigType(JSON_CONFIG);
- }
- }
- }
- createPolicy(policy.policyAdapter, username, policyScope, finalName, policyDataString);
- } catch (Exception e) {
- logger.error("Could not create policy for " + policy, e);
- throw e;
- }
- }
-
- private String getConfigData(String configPath) {
- String configData = "";
- try {
- configData = getConfigPath(configPath);
- } catch (Exception e) {
- logger.error("Could not read config body data for " + configPath, e);
- }
- return configData;
- }
-
- private String getConfigPath(String configPath) {
- try {
- String newConfigPath = processConfigPath(configPath);
- return readConfigFile(newConfigPath);
- } catch (IllegalArgumentException e2) {
- logger.error("Could not process config path: " + configPath, e2);
- }
- return "";
- }
-
-
- /**
- * @param policy input policy Object.
- * @return read the stream and return policy xml data.
- */
- private String getPolicyDataString(Policy policy) {
- try (InputStream policyXmlStream =
- XACMLPolicyWriter.getXmlAsInputStream(policy.getCorrectPolicyDataObject())) {
- return IOUtils.toString(policyXmlStream);
- } catch (IOException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught IOException on reading Policy Data.");
- throw new IllegalArgumentException("Cannot parse the policy xml from the PolicyRestAdapter.");
- }
- }
-
- @Override
- public void close() {
- synchronized (emLock) {
- if (em.isOpen()) {
- if (em.getTransaction().isActive()) {
- em.getTransaction().rollback();
- }
- em.close();
- }
- if (transactionTimer != null) {
- transactionTimer.interrupt();
- }
- }
- }
-
- @Override
- public void createGroup(String groupId, String groupName, String inputGroupDescription, String username) {
- String groupDescription = inputGroupDescription;
- logger.debug("deletePolicy(String policyToDeletes) as createGroup(" + groupId + ", " + groupName + ", "
- + groupDescription + ") called");
- if (isNullOrEmpty(groupId, groupName, username)) {
- throw new IllegalArgumentException("groupId, groupName, and username must not be null or empty");
- }
- if (groupDescription == null) {
- groupDescription = "";
- }
-
- synchronized (emLock) {
- checkBeforeOperationRun();
- Query checkGroupQuery = em.createQuery(groupEntitySelectQuery);
- checkGroupQuery.setParameter(groupIdVar, groupId);
- checkGroupQuery.setParameter(deletedVar, false);
- List<?> checkGroupQueryList;
- try {
- checkGroupQueryList = checkGroupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on checkGroupQuery.getResultList()");
- throw new PersistenceException(queryFailedToCheckExisting);
- }
- if (!checkGroupQueryList.isEmpty()) {
- PolicyLogger.error("The group being added already exists with id " + groupId);
- throw new PersistenceException("The group being added already exists with id " + groupId);
- }
- GroupEntity newGroup = new GroupEntity();
- em.persist(newGroup);
- newGroup.setCreatedBy(username);
- newGroup.setModifiedBy(username);
- newGroup.setGroupName(groupName);
- newGroup.setGroupId(groupId);
- newGroup.setDescription(groupDescription);
-
- em.flush();
- this.groupId = newGroup.getGroupKey();
- }
- }
-
- @Override
- public void updateGroup(OnapPDPGroup group, String username) {
- logger.info(
- "PolicyDBDao: updateGroup(PDPGroup group) as updateGroup(" + group + "," + username + ") called");
- if (group == null) {
- throw new IllegalArgumentException("PDPGroup group must not be null");
- }
- if (isNullOrEmpty(group.getId(), username)) {
- throw new IllegalArgumentException("group.getId() and username must not be null or empty");
- }
-
- synchronized (emLock) {
- checkBeforeOperationRun();
- Query getGroupQuery = em.createQuery(groupEntitySelectQuery);
- getGroupQuery.setParameter(groupIdVar, group.getId());
- getGroupQuery.setParameter(deletedVar, false);
- List<?> getGroupQueryList;
- try {
- getGroupQueryList = getGroupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on getGroupQuery.getResultList()");
- throw new PersistenceException(queryFailedToGetGroup + group.getId() + " for editing");
- }
- if (getGroupQueryList.isEmpty()) {
- PolicyLogger.error("The group cannot be found to update with id " + group.getId());
- throw new PersistenceException("The group cannot be found to update with id " + group.getId());
- } else if (getGroupQueryList.size() > 1) {
- PolicyLogger.error(duplicateGroupId + group.getId() + deletedStatusFound);
- throw new PersistenceException(duplicateGroupId + group.getId() + deletedStatusFound);
- }
- GroupEntity groupToUpdateInDB = (GroupEntity) getGroupQueryList.get(0);
- if (!stringEquals(groupToUpdateInDB.getModifiedBy(), username)) {
- groupToUpdateInDB.setModifiedBy(username);
- }
- if (group.getDescription() != null
- && !stringEquals(group.getDescription(), groupToUpdateInDB.getDescription())) {
- groupToUpdateInDB.setDescription(group.getDescription());
- }
- // let's find out what policies have been deleted
- StdPDPGroup oldGroup = null;
- try {
- oldGroup = (StdPDPGroup) papEngine.getGroup(group.getId());
- } catch (PAPException e1) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, policyDBDaoVar,
- "We cannot get the group from the papEngine to delete policies");
- }
- if (oldGroup == null) {
- PolicyLogger.error("We cannot get the group from the papEngine to delete policies");
- } else {
- Set<String> newPolicySet = new HashSet<>(group.getPolicies().size());
- // a multiple of n runtime is faster than n^2, so I am using a hashset to do the comparison
- for (PDPPolicy pol : group.getPolicies()) {
- newPolicySet.add(pol.getId());
- }
- for (PDPPolicy pol : oldGroup.getPolicies()) {
- // should be fast since getPolicies uses a HashSet in StdPDPGroup
- if (!newPolicySet.contains(pol.getId())) {
- String[] scopeAndName = getNameScopeAndVersionFromPdpPolicy(pol.getId());
- deletePolicyInScope(username, groupToUpdateInDB, pol, scopeAndName);
- }
- }
- }
-
- if (group.getName() != null && !stringEquals(group.getName(), groupToUpdateInDB.getgroupName())) {
- // we need to check if the new id exists in the database
- String newGroupId = createNewPDPGroupId(group.getName());
- Query checkGroupQuery = em.createQuery(groupEntitySelectQuery);
- checkGroupQuery.setParameter(groupIdVar, newGroupId);
- checkGroupQuery.setParameter(deletedVar, false);
- List<?> checkGroupQueryList;
- try {
- checkGroupQueryList = checkGroupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on checkGroupQuery.getResultList()");
- throw new PersistenceException(queryFailedToCheckExisting);
- }
- if (!checkGroupQueryList.isEmpty()) {
- PolicyLogger.error("The new group name already exists, group id " + newGroupId);
- throw new PersistenceException("The new group name already exists, group id " + newGroupId);
- }
- groupToUpdateInDB.setGroupId(newGroupId);
- groupToUpdateInDB.setGroupName(group.getName());
- this.newGroupId = group.getId();
- }
- em.flush();
- this.groupId = groupToUpdateInDB.getGroupKey();
- }
- }
-
- private void deletePolicyInScope(String username, GroupEntity groupToUpdateInDB, PDPPolicy pol,
- String[] scopeAndName) {
- PolicyEntity policyToDelete;
- if (scopeAndName == null) {
- return;
- }
- try {
- policyToDelete = getPolicy(scopeAndName[0], scopeAndName[1]);
- if ("XACMLPapServlet.doDelete".equals(username)) {
- Iterator<PolicyEntity> dbPolicyIt = groupToUpdateInDB.getPolicies().iterator();
- String policyName = getPolicyNameAndVersionFromPolicyFileName(policyToDelete.getPolicyName())[0];
-
- logger.info("PolicyDBDao: delete policy from GroupEntity");
- deletePolicyFromGroupEntity(groupToUpdateInDB, policyToDelete, dbPolicyIt, policyName);
- }
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Could not get policy to remove: " + pol.getId());
- throw new PersistenceException("Could not get policy to remove: " + pol.getId());
- }
- }
-
- private void deletePolicyFromGroupEntity(GroupEntity groupToUpdateInDB, PolicyEntity policyToDelete,
- Iterator<PolicyEntity> dbPolicyIt, String policyName) {
- try {
- while (dbPolicyIt.hasNext()) {
- PolicyEntity dbpolicy = dbPolicyIt.next();
- if (policyToDelete.getScope().equals(dbpolicy.getScope())
- && getPolicyNameAndVersionFromPolicyFileName(dbpolicy.getPolicyName())[0]
- .equals(policyName)) {
- dbPolicyIt.remove();
-
- logger.info("PolicyDBDao: deleting policy from the existing group:\n " + "policyName is "
- + policyToDelete.getScope() + "." + policyToDelete.getPolicyName() + "\n" + "group is "
- + groupToUpdateInDB.getGroupId());
- }
- }
- } catch (Exception e) {
- logger.debug(e);
- PolicyLogger.error("Could not delete policy with name: " + policyToDelete.getScope() + "."
- + policyToDelete.getPolicyName() + "\n ID: " + policyToDelete.getPolicyId());
- }
- }
-
- @Override
- public void addPdpToGroup(String pdpID, String groupID, String pdpName, String pdpDescription, int pdpJmxPort,
- String username) {
- logger.debug("addPdpToGroup(String pdpID, String groupID, String pdpName, String pdpDescription, int "
- + "pdpJmxPort, String username) as addPdpToGroup(" + pdpID + ", " + groupID + ", " + pdpName + ", "
- + pdpDescription + ", " + pdpJmxPort + ", " + username + ") called");
- if (isNullOrEmpty(pdpID, groupID, pdpName, username)) {
- throw new IllegalArgumentException("pdpID, groupID, pdpName, and username must not be null or empty");
- }
- synchronized (emLock) {
- checkBeforeOperationRun();
- Query checkGroupQuery = em.createQuery(groupEntitySelectQuery);
- checkGroupQuery.setParameter(groupIdVar, groupID);
- checkGroupQuery.setParameter(deletedVar, false);
- List<?> checkGroupQueryList;
- try {
- checkGroupQueryList = checkGroupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to check for existing group on checkGroupQuery.getResultList()");
- throw new PersistenceException(queryFailedToCheckExisting);
- }
- if (checkGroupQueryList.size() != 1) {
- PolicyLogger.error("The group does not exist");
- throw new PersistenceException("The group does not exist");
- }
- Query checkDuplicateQuery = em.createQuery(pdpEntitySelectQuery);
- checkDuplicateQuery.setParameter(pdpIdVariable, pdpID);
- checkDuplicateQuery.setParameter(deletedVar, false);
- List<?> checkDuplicateList;
- try {
- checkDuplicateList = checkDuplicateQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to check for duplicate PDP " + pdpID
- + " on checkDuplicateQuery.getResultList()");
- throw new PersistenceException("Query failed trying to check for duplicate PDP " + pdpID);
- }
- PdpEntity newPdp;
- if (!checkDuplicateList.isEmpty()) {
- logger.warn("PDP already exists with id " + pdpID);
- newPdp = (PdpEntity) checkDuplicateList.get(0);
- } else {
- newPdp = new PdpEntity();
- em.persist(newPdp);
- }
-
- newPdp.setCreatedBy(username);
- newPdp.setDeleted(false);
- newPdp.setDescription(pdpDescription);
- newPdp.setGroup((GroupEntity) checkGroupQueryList.get(0));
- newPdp.setJmxPort(pdpJmxPort);
- newPdp.setModifiedBy(username);
- newPdp.setPdpId(pdpID);
- newPdp.setPdpName(pdpName);
-
- em.flush();
- this.pdpId = newPdp.getPdpKey();
- }
- }
-
-
- @Override
- public void updatePdp(OnapPDP pdp, String username) {
- logger.debug("updatePdp(PDP pdp, String username) as updatePdp(" + pdp + "," + username + ") called");
- if (pdp == null) {
- throw new IllegalArgumentException("PDP pdp must not be null");
- }
- if (isNullOrEmpty(pdp.getId(), username)) {
- throw new IllegalArgumentException("pdp.getId() and username must not be null or empty");
- }
-
- synchronized (emLock) {
- checkBeforeOperationRun();
- Query getPdpQuery = em.createQuery(pdpEntitySelectQuery);
- getPdpQuery.setParameter(pdpIdVariable, pdp.getId());
- getPdpQuery.setParameter(deletedVar, false);
- List<?> getPdpQueryList;
- try {
- getPdpQueryList = getPdpQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on getPdpQuery.getResultList()");
- throw new PersistenceException("Query failed trying to get PDP " + pdp.getId());
- }
- if (getPdpQueryList.isEmpty()) {
- PolicyLogger.error("The pdp cannot be found to update with id " + pdp.getId());
- throw new PersistenceException("The pdp cannot be found to update with id " + pdp.getId());
- } else if (getPdpQueryList.size() > 1) {
- PolicyLogger.error(moreThanOnePDP + pdp.getId() + deletedStatusFound);
- throw new PersistenceException(moreThanOnePDP + pdp.getId() + deletedStatusFound);
- }
- PdpEntity pdpToUpdate = (PdpEntity) getPdpQueryList.get(0);
- if (!stringEquals(pdpToUpdate.getModifiedBy(), username)) {
- pdpToUpdate.setModifiedBy(username);
- }
- if (pdp.getDescription() != null && !stringEquals(pdp.getDescription(), pdpToUpdate.getDescription())) {
- pdpToUpdate.setDescription(pdp.getDescription());
- }
- if (pdp.getName() != null && !stringEquals(pdp.getName(), pdpToUpdate.getPdpName())) {
- pdpToUpdate.setPdpName(pdp.getName());
- }
- if (pdp.getJmxPort() != null && !pdp.getJmxPort().equals(pdpToUpdate.getJmxPort())) {
- pdpToUpdate.setJmxPort(pdp.getJmxPort());
- }
-
- em.flush();
- this.pdpId = pdpToUpdate.getPdpKey();
- }
- }
-
- @Override
- public void movePdp(OnapPDP pdp, OnapPDPGroup group, String username) {
- logger.debug("movePdp(PDP pdp, PDPGroup group, String username) as movePdp(" + pdp + "," + group + ","
- + username + ") called");
- if (pdp == null || group == null) {
- throw new IllegalArgumentException("PDP pdp and PDPGroup group must not be null");
- }
- if (isNullOrEmpty(username, pdp.getId(), group.getId())) {
- throw new IllegalArgumentException(
- "pdp.getId(), group.getId(), and username must not be null or empty");
- }
-
- synchronized (emLock) {
- checkBeforeOperationRun();
- // check if pdp exists
- Query getPdpQuery = em.createQuery(pdpEntitySelectQuery);
- getPdpQuery.setParameter(pdpIdVariable, pdp.getId());
- getPdpQuery.setParameter(deletedVar, false);
- List<?> getPdpQueryList;
- try {
- getPdpQueryList = getPdpQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on getPdpQuery.getResultList()");
- throw new PersistenceException("Query failed trying to get pdp to move with id " + pdp.getId());
- }
- if (getPdpQueryList.isEmpty()) {
- PolicyLogger.error("The pdp cannot be found to move with id " + pdp.getId());
- throw new PersistenceException("The pdp cannot be found to move with id " + pdp.getId());
- } else if (getPdpQueryList.size() > 1) {
- PolicyLogger.error(moreThanOnePDP + pdp.getId() + deletedStatusFound);
- throw new PersistenceException(moreThanOnePDP + pdp.getId() + deletedStatusFound);
- }
-
- // check if new group exists
- Query checkGroupQuery = em.createQuery(groupEntitySelectQuery);
- checkGroupQuery.setParameter(groupIdVar, group.getId());
- checkGroupQuery.setParameter(deletedVar, false);
- List<?> checkGroupQueryList;
- try {
- checkGroupQueryList = checkGroupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to get group on checkGroupQuery.getResultList()");
- throw new PersistenceException("Query failed trying to get new group " + group.getId());
- }
- if (checkGroupQueryList.size() != 1) {
- PolicyLogger.error("The group " + group.getId() + " does not exist");
- throw new PersistenceException("The group " + group.getId() + " does not exist");
- }
- GroupEntity groupToMoveInto = (GroupEntity) checkGroupQueryList.get(0);
- PdpEntity pdpToUpdate = (PdpEntity) getPdpQueryList.get(0);
- pdpToUpdate.setGroup(groupToMoveInto);
- if (!stringEquals(pdpToUpdate.getModifiedBy(), username)) {
- pdpToUpdate.setModifiedBy(username);
- }
-
- em.flush();
- this.pdpId = pdpToUpdate.getPdpKey();
- }
- }
-
- @Override
- public void changeDefaultGroup(OnapPDPGroup group, String username) {
- logger.debug("changeDefaultGroup(PDPGroup group, String username) as changeDefaultGroup(" + group + ","
- + username + ") called");
- if (group == null) {
- throw new IllegalArgumentException("PDPGroup group must not be null");
- }
- if (isNullOrEmpty(group.getId(), username)) {
- throw new IllegalArgumentException("group.getId() and username must not be null or empty");
- }
-
- synchronized (emLock) {
- checkBeforeOperationRun();
- Query getGroupQuery = em.createQuery(groupEntitySelectQuery);
- getGroupQuery.setParameter(groupIdVar, group.getId());
- getGroupQuery.setParameter(deletedVar, false);
- List<?> getGroupQueryList;
- try {
- getGroupQueryList = getGroupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on getGroupQuery.getResultList()");
- throw new PersistenceException(queryFailedToGetGroup + group.getId());
- }
- if (getGroupQueryList.isEmpty()) {
- PolicyLogger.error("The group cannot be found to set default with id " + group.getId());
- throw new PersistenceException("The group cannot be found to set default with id " + group.getId());
- } else if (getGroupQueryList.size() > 1) {
- PolicyLogger.error(duplicateGroupId + group.getId() + deletedStatusFound);
- throw new PersistenceException(duplicateGroupId + group.getId() + deletedStatusFound);
- }
- GroupEntity newDefaultGroup = (GroupEntity) getGroupQueryList.get(0);
- newDefaultGroup.setDefaultGroup(true);
- if (!stringEquals(newDefaultGroup.getModifiedBy(), username)) {
- newDefaultGroup.setModifiedBy(username);
- }
-
- em.flush();
- this.groupId = newDefaultGroup.getGroupKey();
- Query setAllGroupsNotDefault = em.createQuery(
- "UPDATE GroupEntity g SET g.defaultGroup=:defaultGroup WHERE g.deleted=:deleted AND g"
- + ".groupKey<>:groupKey");
- // not going to set modified by for all groups
- setAllGroupsNotDefault.setParameter("defaultGroup", false);
- setAllGroupsNotDefault.setParameter(deletedVar, false);
- setAllGroupsNotDefault.setParameter("groupKey", newDefaultGroup.getGroupKey());
- try {
- logger.info("set " + setAllGroupsNotDefault.executeUpdate() + " groups as not default");
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on setAllGroupsNotDefault.executeUpdate()");
- throw new PersistenceException("Could not set all other groups default to false");
- }
- em.flush();
- }
- }
-
-
- @Override
- public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username)
- throws PolicyDBException {
- logger.debug("deleteGroup(PDPGroup group, PDPGroup moveToGroup, String username) as deleteGroup(" + group
- + ", " + moveToGroup + "," + username + ") called");
- if (group == null) {
- throw new IllegalArgumentException("PDPGroup group cannot be null");
- }
- if (isNullOrEmpty(username, group.getId())) {
- throw new IllegalArgumentException("group.getId() and and username must not be null or empty");
- }
-
- if (group.isDefaultGroup()) {
- PolicyLogger
- .error("The default group " + group.getId() + " was attempted to be deleted. It cannot be.");
- throw new PolicyDBException("You cannot delete the default group.");
- }
- synchronized (emLock) {
- checkBeforeOperationRun();
- Query deleteGroupQuery = em.createQuery(groupEntitySelectQuery);
- deleteGroupQuery.setParameter(groupIdVar, group.getId());
- deleteGroupQuery.setParameter(deletedVar, false);
- List<?> deleteGroupQueryList;
- try {
- deleteGroupQueryList = deleteGroupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to check if group exists deleteGroupQuery.getResultList()");
- throw new PersistenceException("Query failed trying to check if group exists");
- }
- if (deleteGroupQueryList.isEmpty()) {
- logger.warn(groupCannotBeFound + group.getId());
- return;
- } else if (deleteGroupQueryList.size() > 1) {
- PolicyLogger.error(duplicateGroupId + group.getId() + foundInDBNotDeleted);
- throw new PersistenceException(duplicateGroupId + group.getId() + foundInDBNotDeleted);
- }
-
- Query pdpsInGroupQuery =
- em.createQuery("SELECT p FROM PdpEntity p WHERE p.groupEntity=:group and p.deleted=:deleted");
- pdpsInGroupQuery.setParameter("group", ((GroupEntity) deleteGroupQueryList.get(0)));
- pdpsInGroupQuery.setParameter(deletedVar, false);
- List<?> pdpsInGroupList;
- try {
- pdpsInGroupList = pdpsInGroupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to get PDPs in group on pdpsInGroupQuery.getResultList()");
- throw new PersistenceException("Query failed trying to get PDPs in group");
- }
- if (!pdpsInGroupList.isEmpty()) {
- if (moveToGroup != null) {
- Query checkMoveToGroupQuery = em.createQuery(
- "SELECT o FROM GroupEntity o WHERE o.groupId=:groupId AND o.deleted=:deleted");
- checkMoveToGroupQuery.setParameter(groupIdVar, moveToGroup.getId());
- checkMoveToGroupQuery.setParameter(deletedVar, false);
- List<?> checkMoveToGroupList;
- try {
- checkMoveToGroupList = checkMoveToGroupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to check if group exists checkMoveToGroupQuery"
- + ".getResultList()");
- throw new PersistenceException("Query failed trying to check if group exists");
- }
- if (checkMoveToGroupList.isEmpty()) {
- PolicyLogger.error(groupCannotBeFound + moveToGroup.getId());
- throw new PersistenceException(groupCannotBeFound + moveToGroup.getId());
- } else if (checkMoveToGroupList.size() > 1) {
- PolicyLogger.error(duplicateGroupId + moveToGroup.getId() + foundInDBNotDeleted);
- throw new PersistenceException(
- duplicateGroupId + moveToGroup.getId() + foundInDBNotDeleted);
- } else {
- GroupEntity newGroup = (GroupEntity) checkMoveToGroupList.get(0);
- for (Object pdpObject : pdpsInGroupList) {
- PdpEntity pdp = (PdpEntity) pdpObject;
- pdp.setGroup(newGroup);
- if (!stringEquals(pdp.getModifiedBy(), username)) {
- pdp.setModifiedBy(username);
- }
- try {
- em.flush();
- this.newGroupId = newGroup.getGroupId();
- } catch (PersistenceException e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught PersistenceException trying to set pdp group to null on em.flush"
- + "()");
- throw new PersistenceException("Query failed trying to set pdp group to ");
- }
- }
- }
- } else {
- PolicyLogger.error("Group " + group.getId()
- + " is trying to be delted with PDPs. No group was provided to move them to");
- throw new PolicyDBException("Group has PDPs. Must provide a group for them to move to");
- }
- }
-
- // delete group here
- GroupEntity groupToDelete = (GroupEntity) deleteGroupQueryList.get(0);
- groupToDelete.setDeleted(true);
- if (!stringEquals(groupToDelete.getModifiedBy(), username)) {
- groupToDelete.setModifiedBy(username);
- }
- em.flush();
- this.groupId = groupToDelete.getGroupKey();
- }
- }
-
- @Override
- public StdPDPGroup addPolicyToGroup(String groupID, String policyID, String username) throws PolicyDBException {
- logger.info("PolicyDBDao: addPolicyToGroup(String groupID, String policyID, String username) as "
- + "addPolicyToGroup(" + groupID + ", " + policyID + "," + username + ") called");
- if (isNullOrEmpty(groupID, policyID, username)) {
- throw new IllegalArgumentException("groupID, policyID, and username must not be null or empty");
- }
- synchronized (emLock) {
- checkBeforeOperationRun();
- // check if group exists
- Query groupQuery = em.createQuery(groupEntitySelectQuery);
- groupQuery.setParameter(groupIdVar, groupID);
- groupQuery.setParameter(deletedVar, false);
- List<?> groupQueryList;
- try {
- groupQueryList = groupQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to check if group exists groupQuery.getResultList()");
- throw new PersistenceException("Query failed trying to check if group " + groupID + " exists");
- }
- if (groupQueryList.isEmpty()) {
- PolicyLogger.error("Group policy is being added to does not exist with id " + groupID);
- throw new PersistenceException("Group policy is being added to does not exist with id " + groupID);
- } else if (groupQueryList.size() > 1) {
- PolicyLogger.error(duplicateGroupId + groupID + foundInDBNotDeleted);
- throw new PersistenceException(duplicateGroupId + groupID + foundInDBNotDeleted);
- }
-
- // we need to convert the form of the policy id that is used groups into the form that is used
- // for the database. (com.Config_mypol.1.xml) to (Config_mypol.xml)
- String[] policyNameScopeAndVersion = getNameScopeAndVersionFromPdpPolicy(policyID);
- if (policyNameScopeAndVersion == null) {
- throw new IllegalArgumentException("Invalid input - policyID must contain name, scope and version");
- }
- Query policyQuery = em.createQuery(
- "SELECT p FROM PolicyEntity p WHERE p.policyName=:policyName AND p.scope=:scope AND p"
- + ".deleted=:deleted");
- policyQuery.setParameter("policyName", policyNameScopeAndVersion[0]);
- policyQuery.setParameter(scope, policyNameScopeAndVersion[1]);
- policyQuery.setParameter(deletedVar, false);
- List<?> policyQueryList;
- try {
- policyQueryList = policyQuery.getResultList();
- } catch (Exception e) {
- logger.debug(e);
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to check if policy exists policyQuery.getResultList()");
- throw new PersistenceException(
- "Query failed trying to check if policy " + policyNameScopeAndVersion[0] + " exists");
- }
- if (policyQueryList.isEmpty()) {
- PolicyLogger.error("Policy being added to the group does not exist with policy id "
- + policyNameScopeAndVersion[0]);
- throw new PersistenceException("Policy being added to the group does not exist with policy id "
- + policyNameScopeAndVersion[0]);
- } else if (policyQueryList.size() > 1) {
- PolicyLogger.error(duplicatePolicyId + policyNameScopeAndVersion[0] + foundInDBNotDeleted);
- throw new PersistenceException(
- duplicateGroupId + policyNameScopeAndVersion[0] + foundInDBNotDeleted);
- }
- logger.info("PolicyDBDao: Getting group and policy from database");
- GroupEntity group = (GroupEntity) groupQueryList.get(0);
- PolicyEntity policy = (PolicyEntity) policyQueryList.get(0);
- Iterator<PolicyEntity> policyIt = group.getPolicies().iterator();
- String policyName = getPolicyNameAndVersionFromPolicyFileName(policy.getPolicyName())[0];
-
- logger.info("PolicyDBDao: policyName retrieved is " + policyName);
- try {
- while (policyIt.hasNext()) {
- PolicyEntity pol = policyIt.next();
- if (policy.getScope().equals(pol.getScope())
- && getPolicyNameAndVersionFromPolicyFileName(pol.getPolicyName())[0]
- .equals(policyName)) {
- policyIt.remove();
- }
- }
- } catch (Exception e) {
- logger.debug(e);
- PolicyLogger.error("Could not delete old versions for policy " + policy.getPolicyName() + ", ID: "
- + policy.getPolicyId());
- }
- group.addPolicyToGroup(policy);
- em.flush();
-
- // After adding policy to the db group we need to make sure the filesytem group is in sync with the db
- // group
- try {
- StdPDPGroup pdpGroup = (StdPDPGroup) papEngine.getGroup(group.getGroupId());
- return synchronizeGroupPoliciesInFileSystem(pdpGroup, group);
- } catch (PAPException e) {
- logger.debug(e);
- PolicyLogger
- .error("PolicyDBDao: Could not synchronize the filesystem group with the database group. "
- + e.getMessage());
- }
- return null;
- }
- }
-
- // this means delete pdp not just remove from group
- @Override
- public void removePdpFromGroup(String pdpID, String username) {
- logger.debug("removePdpFromGroup(String pdpID, String username) as removePdpFromGroup(" + pdpID + ","
- + username + ") called");
- if (isNullOrEmpty(pdpID, username)) {
- throw new IllegalArgumentException("pdpID and username must not be null or empty");
- }
- synchronized (emLock) {
- checkBeforeOperationRun();
- Query pdpQuery = em.createQuery(pdpEntitySelectQuery);
- pdpQuery.setParameter(pdpIdVariable, pdpID);
- pdpQuery.setParameter(deletedVar, false);
- List<?> pdpList;
- try {
- pdpList = pdpQuery.getResultList();
- } catch (Exception e) {
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception trying to check if pdp exists pdpQuery.getResultList()");
- throw new PersistenceException("Query failed trying to check if pdp " + pdpID + " exists");
- }
- if (pdpList.size() > 1) {
- PolicyLogger.error("Somehow, more than one pdp with the id " + pdpID + foundInDBNotDeleted);
- throw new PersistenceException(
- "Somehow, more than one pdp with the id " + pdpID + foundInDBNotDeleted);
- } else if (pdpList.isEmpty()) {
- PolicyLogger.error("Pdp being removed does not exist with id " + pdpID);
- return;
- }
- PdpEntity pdp = (PdpEntity) pdpList.get(0);
- pdp.setGroup(null);
- if (!stringEquals(pdp.getModifiedBy(), username)) {
- pdp.setModifiedBy(username);
- }
- pdp.setDeleted(true);
-
- em.flush();
- this.pdpId = pdp.getPdpKey();
- }
- }
-
- private void notifyOthers(long entityId, String entityType) {
- notifyOthers(entityId, entityType, null);
- }
-
- private void notifyOthers(long entityId, String entityType, String newGroupId) {
- logger.debug("notifyOthers(long entityId, String entityType, long newGroupId) as notifyOthers(" + entityId
- + "," + entityType + "," + newGroupId + ") called");
- LinkedList<Thread> notifyThreads = new LinkedList<>();
-
- // we're going to run notifications in parallel threads to speed things up
- for (Object obj : otherServers) {
- Thread newNotifyThread = new Thread(new NotifyOtherThread(obj, entityId, entityType, newGroupId));
- newNotifyThread.start();
- notifyThreads.add(newNotifyThread);
- }
- // we want to wait for all notifications to complete or timeout before we unlock the interface and allow
- // more changes
- for (Thread t : notifyThreads) {
- try {
- t.join();
- } catch (Exception e) {
- logger.warn("Could not join a notifcation thread" + e);
- }
- }
- }
- }
-
- private PolicyDBDao() {
- // empty constructor
- }
-
public static PolicyDBDaoTestClass getPolicyDBDaoTestClass() {
return new PolicyDBDao().new PolicyDBDaoTestClass();
}
@@ -2870,18 +809,14 @@ public class PolicyDBDao {
String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName) throws PolicyDBException {
return PolicyDBDao.this.getPolicyNameAndVersionFromPolicyFileName(originalPolicyName);
}
-
+
String[] getNameScopeAndVersionFromPdpPolicy(String fileName) {
return PolicyDBDao.this.getNameScopeAndVersionFromPdpPolicy(fileName);
}
-
+
String getPdpPolicyName(String name, String scope) {
return PolicyDBDao.this.getPdpPolicyName(name, scope);
}
-
- Path getPolicySubFile(String inputFileName, String subFileType) {
- return PolicyDBDao.this.getPolicySubFile(inputFileName, subFileType);
- }
}
}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTransaction.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTransaction.java
index d6ace7cf3..3cfe24524 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTransaction.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTransaction.java
@@ -2,14 +2,14 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,10 +20,9 @@
package org.onap.policy.pap.xacml.rest.components;
+import com.att.research.xacml.api.pap.PAPException;
import java.util.List;
-
import javax.persistence.PersistenceException;
-
import org.onap.policy.rest.dao.PolicyDBException;
import org.onap.policy.rest.jpa.GroupEntity;
import org.onap.policy.rest.jpa.PdpEntity;
@@ -31,13 +30,14 @@ import org.onap.policy.xacml.api.pap.OnapPDP;
import org.onap.policy.xacml.api.pap.OnapPDPGroup;
import org.onap.policy.xacml.std.pap.StdPDPGroup;
-import com.att.research.xacml.api.pap.PAPException;
-
public interface PolicyDBDaoTransaction {
/**
- * Commits (makes permanent) the current transaction. Also, notifies other PolicyDBDao instances on other PAP servers of the update.
- * @throws IllegalStateException if the PolicyDBDao transaction has not been used or has been committed already.
+ * Commits (makes permanent) the current transaction. Also, notifies other PolicyDBDao instances
+ * on other PAP servers of the update.
+ *
+ * @throws IllegalStateException if the PolicyDBDao transaction has not been used or has been
+ * committed already.
* @throws PersistenceException if the commit fails for some reason
*/
public void commitTransaction();
@@ -54,7 +54,9 @@ public interface PolicyDBDaoTransaction {
/**
* Check if the PolicyDBDaoTransaction is currently open
- * @return False if the PolicyDBDao transaction has not been used or has been committed already, true if it is open.
+ *
+ * @return False if the PolicyDBDao transaction has not been used or has been committed already,
+ * true if it is open.
*/
public boolean isTransactionOpen();
@@ -64,7 +66,8 @@ public interface PolicyDBDaoTransaction {
public void rollbackTransaction();
/**
- * Close the PolicyDBDaoTransaction without rolling back or doing anything. Just used to close the EntityManager
+ * Close the PolicyDBDaoTransaction without rolling back or doing anything. Just used to close
+ * the Hibernate session.
*/
public void close();
@@ -79,7 +82,8 @@ public interface PolicyDBDaoTransaction {
* @throws IllegalStateException If a transaction is already open
* @throws PersistenceException If a database error occurs
*/
- public void createGroup(String groupID, String groupName, String groupDescription, String username) throws PolicyDBException;
+ public void createGroup(String groupID, String groupName, String groupDescription, String username)
+ throws PolicyDBException;
/**
* Updates a group in the database with a new name of description
@@ -89,7 +93,7 @@ public interface PolicyDBDaoTransaction {
* @throws IllegalStateException If a transaction is already open
* @throws PersistenceException If a database error occurs or if the group can not be found
*/
- public void updateGroup(OnapPDPGroup group, String username) throws PolicyDBException;
+ public void updateGroup(OnapPDPGroup group, String requestType, String username) throws PolicyDBException;
/**
* Updates a PDP in the database with new information
@@ -146,7 +150,8 @@ public interface PolicyDBDaoTransaction {
* @throws PersistenceException If a database error occurs
* @throws PolicyDBException
*/
- public StdPDPGroup addPolicyToGroup(String group, String policyID, String username) throws PolicyDBException;
+ public StdPDPGroup addPolicyToGroup(String group, String policyID, String requestType, String username)
+ throws PolicyDBException;
/**
@@ -158,7 +163,7 @@ public interface PolicyDBDaoTransaction {
* @throws PersistenceException If a database error occurs
* @throws PAPException If an error relating to how groups are handled occurs
*/
- public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username)throws PolicyDBException;
+ public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username) throws PolicyDBException;
/**
* Removes an existing PDP from its group and deletes it.
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDbDaoTransactionInstance.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDbDaoTransactionInstance.java
new file mode 100644
index 000000000..bc6c79583
--- /dev/null
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDbDaoTransactionInstance.java
@@ -0,0 +1,1538 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP-PAP-REST
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.pap.xacml.rest.components;
+
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.api.pap.PDPPolicy;
+import com.att.research.xacml.util.XACMLProperties;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringReader;
+import java.nio.file.InvalidPathException;
+import java.nio.file.Paths;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import javax.persistence.PersistenceException;
+import javax.persistence.RollbackException;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathFactory;
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.io.IOUtils;
+import org.hibernate.Query;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.onap.policy.common.logging.eelf.MessageCodes;
+import org.onap.policy.common.logging.eelf.PolicyLogger;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.rest.XACMLRestProperties;
+import org.onap.policy.rest.adapter.PolicyRestAdapter;
+import org.onap.policy.rest.dao.PolicyDBException;
+import org.onap.policy.rest.jpa.ActionBodyEntity;
+import org.onap.policy.rest.jpa.ConfigurationDataEntity;
+import org.onap.policy.rest.jpa.GroupEntity;
+import org.onap.policy.rest.jpa.PdpEntity;
+import org.onap.policy.rest.jpa.PolicyEntity;
+import org.onap.policy.xacml.api.pap.OnapPDP;
+import org.onap.policy.xacml.api.pap.OnapPDPGroup;
+import org.onap.policy.xacml.std.pap.StdPDPGroup;
+import org.onap.policy.xacml.util.XACMLPolicyWriter;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicySetType;
+import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
+
+
+@Component
+public class PolicyDbDaoTransactionInstance implements PolicyDBDaoTransaction {
+
+ private static final Logger logger = FlexLogger.getLogger(PolicyDbDaoTransactionInstance.class);
+
+ private final Object emLock = new Object();
+ long policyId;
+ long groupId;
+ long pdpId;
+ String newGroupId;
+ private boolean operationRun = false;
+ private Thread transactionTimer;
+ private static final String POLICY_NOTIFICATION = "policy";
+ private static final String PDP_NOTIFICATION = "pdp";
+ private static final String GROUP_NOTIFICATION = "group";
+
+
+ private static final String DECISIONMS_MODEL = "MicroService_Model";
+ public static boolean isJunit = false;
+ Session session;
+
+ /**
+ * Instantiates a new policy DB dao transaction instance.
+ *
+ * @param test the test
+ */
+ public PolicyDbDaoTransactionInstance(String test) {
+ // call the constructor with arguments
+ this(Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)),
+ Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT)));
+ }
+
+ public PolicyDbDaoTransactionInstance() {
+ // Default Constructor
+ }
+
+ @Autowired
+ public PolicyDbDaoTransactionInstance(SessionFactory sessionfactory) {
+ PolicyDbDaoTransactionInstance.sessionfactory = sessionfactory;
+ }
+
+ private static SessionFactory sessionfactory;
+
+
+ /**
+ * Instantiates a new policy DB dao transaction instance.
+ *
+ * @param transactionTimeout the transaction timeout is how long the transaction can sit before
+ * rolling back
+ * @param transactionWaitTime the transaction wait time is how long to wait for the transaction
+ * to start before
+ */
+ public PolicyDbDaoTransactionInstance(int transactionTimeout, int transactionWaitTime) {
+ logger.info("\n\nPolicyDBDaoTransactionInstance() as PolicyDBDaoTransactionInstance() called:"
+ + "\n transactionTimeout = " + transactionTimeout + "\n transactionWaitTime = "
+ + transactionWaitTime + "\n\n");
+
+ policyId = -1;
+ groupId = -1;
+ pdpId = -1;
+ newGroupId = null;
+ synchronized (emLock) {
+ session = sessionfactory.openSession();
+ try {
+ PolicyDBDao.getPolicyDBDaoInstance().startTransactionSynced(session, transactionWaitTime);
+ } catch (Exception e) {
+ logger.error("Could not lock transaction within " + transactionWaitTime + " milliseconds" + e);
+ throw new PersistenceException(
+ "Could not lock transaction within " + transactionWaitTime + " milliseconds");
+ }
+ }
+ class TransactionTimer implements Runnable {
+
+ private int sleepTime;
+
+ public TransactionTimer(int timeout) {
+ this.sleepTime = timeout;
+ }
+
+ @Override
+ public void run() {
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nTransactionTimer.run() - SLEEPING: " + "\n sleepTime (ms) = " + sleepTime
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
+ }
+ try {
+ Thread.sleep(sleepTime);
+ } catch (InterruptedException e) {
+ // probably, the transaction was completed, the last thing
+ // we want to do is roll back
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nTransactionTimer.run() - WAKE Interrupt: " + "\n TimeStamp = "
+ + date.getTime() + "\n\n");
+ }
+ Thread.currentThread().interrupt();
+ return;
+ }
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nTransactionTimer.run() - WAKE Timeout: " + "\n TimeStamp = " + date.getTime()
+ + "\n\n");
+ }
+ logger.warn("PolicyDBDaoTransactionInstance - TransactionTimer - Rolling back transaction.");
+ rollbackTransaction();
+ }
+
+ }
+
+ transactionTimer = new Thread(new TransactionTimer(transactionTimeout), "transactionTimerThread");
+ transactionTimer.start();
+
+ }
+
+ private void checkBeforeOperationRun() {
+ checkBeforeOperationRun(false);
+ }
+
+ private void checkBeforeOperationRun(boolean justCheckOpen) {
+ if (!isTransactionOpen()) {
+ PolicyLogger.warn("checkBeforeOperationRun - There is no transaction currently open");
+ throw new IllegalStateException("There is no transaction currently open");
+ }
+ if (operationRun && !justCheckOpen) {
+ PolicyLogger.warn("checkBeforeOperationRun - "
+ + "An operation has already been performed and the current transaction should be committed");
+ throw new IllegalStateException(
+ "An operation has already been performed and the current transaction should be committed");
+ }
+ operationRun = true;
+ }
+
+ @Override
+ public void commitTransaction() {
+ synchronized (emLock) {
+ NotifyOtherPaps otherPaps = new NotifyOtherPaps();
+ logger.debug("commitTransaction() as commitTransaction() called");
+ if (!isTransactionOpen()) {
+ logger.warn(
+ "There is no open transaction to commit - PolicyId - " + policyId + ", GroupId - " + groupId);
+ try {
+ session.close();
+ } catch (Exception e) {
+ logger.error("Exception Occured" + e);
+ }
+ return;
+ }
+ try {
+ session.getTransaction().commit();
+ } catch (RollbackException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught RollbackException on em.getTransaction().commit()");
+ throw new PersistenceException("The commit failed. Message:\n" + e.getMessage());
+ }
+ session.close();
+ // need to revisit
+ if (policyId >= 0) {
+ if (newGroupId != null) {
+ try {
+ otherPaps.notifyOthers(policyId, POLICY_NOTIFICATION, newGroupId);
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on notifyOthers(" + policyId + "," + POLICY_NOTIFICATION + ","
+ + newGroupId + ")");
+ }
+ } else {
+ try {
+ otherPaps.notifyOthers(policyId, POLICY_NOTIFICATION);
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on notifyOthers(" + policyId + "," + POLICY_NOTIFICATION + ")");
+ }
+ }
+ }
+ if (groupId >= 0) {
+ // we don't want commit to fail just because this does
+ if (newGroupId != null) {
+ try {
+ otherPaps.notifyOthers(groupId, GROUP_NOTIFICATION, newGroupId);
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on notifyOthers(" + groupId + "," + GROUP_NOTIFICATION + ","
+ + newGroupId + ")");
+ }
+ } else {
+ try {
+ otherPaps.notifyOthers(groupId, GROUP_NOTIFICATION);
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on notifyOthers(" + groupId + "," + GROUP_NOTIFICATION + ")");
+ }
+ }
+ }
+ if (pdpId >= 0) {
+ // we don't want commit to fail just because this does
+ try {
+ otherPaps.notifyOthers(pdpId, PDP_NOTIFICATION);
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on notifyOthers(" + pdpId + "," + PDP_NOTIFICATION + ")");
+ }
+ }
+ }
+ if (transactionTimer != null) {
+ transactionTimer.interrupt();
+ }
+ }
+
+ @Override
+ public void rollbackTransaction() {
+ logger.debug("rollbackTransaction() as rollbackTransaction() called");
+ synchronized (emLock) {
+ if (isTransactionOpen()) {
+ try {
+ session.getTransaction().rollback();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Could not rollback transaction");
+ }
+ try {
+ session.close();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Could not close Hibernate Session.");
+ }
+
+ } else {
+ try {
+ session.close();
+ } catch (Exception e) {
+ logger.warn("Could not close already closed transaction", e);
+ }
+ }
+ }
+ if (transactionTimer != null) {
+ transactionTimer.interrupt();
+ }
+ }
+
+ private void createPolicy(PolicyRestAdapter policy, String username, String policyScope, String inputPolicyName,
+ String policyDataString) {
+ String policyName = inputPolicyName;
+ logger.debug("createPolicy(PolicyRestAdapter policy, String username, String policyScope,"
+ + " String policyName, String policyDataString) as createPolicy(" + policy + ", " + username + ", "
+ + policyScope + ", " + policyName + ", " + policyDataString + ") called");
+ synchronized (emLock) {
+ PolicyDBDao policyDbDao = new PolicyDBDao();
+ checkBeforeOperationRun();
+ String configName = policyName;
+ if (policyName.contains("Config_")) {
+ policyName = policyName.replace(".Config_", ":Config_");
+ } else if (policyName.contains("Action_")) {
+ policyName = policyName.replace(".Action_", ":Action_");
+ } else if (policyName.contains("Decision_MS_")) {
+ policyName = policyName.replace(".Decision_MS_", ":Decision_MS_");
+ } else if (policyName.contains("Decision_")) {
+ policyName = policyName.replace(".Decision_", ":Decision_");
+ }
+ policyName = policyName.split(":")[1];
+ Query createPolicyQuery = session
+ .createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName");
+ createPolicyQuery.setParameter(PolicyDBDao.SCOPE, policyScope);
+ createPolicyQuery.setParameter("policyName", policyName);
+ List<?> createPolicyQueryList = createPolicyQuery.list();
+ PolicyEntity newPolicyEntity;
+ boolean update;
+ if (createPolicyQueryList.isEmpty()) {
+ newPolicyEntity = new PolicyEntity();
+ update = false;
+ } else if (createPolicyQueryList.size() > 1) {
+ PolicyLogger.error("Somehow, more than one policy with the same "
+ + "scope, name, and deleted status were found in the database");
+ throw new PersistenceException("Somehow, more than one policy with the same"
+ + " scope, name, and deleted status were found in the database");
+ } else {
+ newPolicyEntity = (PolicyEntity) createPolicyQueryList.get(0);
+ update = true;
+ }
+
+ ActionBodyEntity newActionBodyEntity = null;
+ if (policy.getPolicyType().equals(PolicyDBDao.ACTION)) {
+ boolean abupdate = false;
+ if (newPolicyEntity.getActionBodyEntity() == null) {
+ newActionBodyEntity = new ActionBodyEntity();
+ } else {
+ newActionBodyEntity = (ActionBodyEntity) session.get(ActionBodyEntity.class,
+ newPolicyEntity.getActionBodyEntity().getActionBodyId());
+ abupdate = true;
+ }
+
+ if (newActionBodyEntity != null) {
+ // build the file path
+ // trim the .xml off the end
+ String policyNameClean = FilenameUtils.removeExtension(configName);
+ String actionBodyName = policyNameClean + ".json";
+
+ // get the action body
+ String actionBodyString = policy.getActionBody();
+ if (actionBodyString == null) {
+ actionBodyString = "{}";
+ }
+ newActionBodyEntity.setActionBody(actionBodyString);
+ newActionBodyEntity.setActionBodyName(actionBodyName);
+ newActionBodyEntity.setModifiedBy("PolicyDBDao.createPolicy()");
+ newActionBodyEntity.setDeleted(false);
+ if (!abupdate) {
+ newActionBodyEntity.setCreatedBy("PolicyDBDao.createPolicy()");
+ }
+ if (logger.isDebugEnabled()) {
+ logger.debug("\nPolicyDBDao.createPolicy" + "\n newActionBodyEntity.getActionBody() = "
+ + newActionBodyEntity.getActionBody()
+ + "\n newActionBodyEntity.getActionBodyName() = "
+ + newActionBodyEntity.getActionBodyName()
+ + "\n newActionBodyEntity.getModifiedBy() = " + newActionBodyEntity.getModifiedBy()
+ + "\n newActionBodyEntity.getCreatedBy() = " + newActionBodyEntity.getCreatedBy()
+ + "\n newActionBodyEntity.isDeleted() = " + newActionBodyEntity.isDeleted()
+ + "\n FLUSHING to DB");
+ }
+ // push the actionBodyEntity to the DB
+ if (isJunit) {
+ newActionBodyEntity.prePersist();
+ }
+ if (!abupdate) {
+ session.persist(newActionBodyEntity);
+ }
+ } else {
+ // newActionBodyEntity == null
+ // We have a actionBody in the policy but we found no
+ // actionBody in the DB
+ String msg = "\n\nPolicyDBDao.createPolicy - Incoming Action policy had an "
+ + "actionBody, but it could not be found in the DB for update." + "\n policyScope = "
+ + policyScope + "\n policyName = " + policyName + "\n\n";
+ PolicyLogger.error("PolicyDBDao.createPolicy - Incoming Action policy had an actionBody, "
+ + "but it could not be found in the DB for update: policyName = " + policyName);
+ throw new IllegalArgumentException(msg);
+ }
+ }
+
+ ConfigurationDataEntity newConfigurationDataEntity;
+ if (PolicyDBDao.CONFIG.equals(policy.getPolicyType())
+ || DECISIONMS_MODEL.equals(policy.getRuleProvider())) {
+ boolean configUpdate;
+ if (newPolicyEntity.getConfigurationData() == null) {
+ newConfigurationDataEntity = new ConfigurationDataEntity();
+ configUpdate = false;
+ } else {
+ newConfigurationDataEntity = (ConfigurationDataEntity) session.get(ConfigurationDataEntity.class,
+ newPolicyEntity.getConfigurationData().getConfigurationDataId());
+ configUpdate = true;
+ }
+
+ if (newConfigurationDataEntity != null) {
+ if (!PolicyDBDao.stringEquals(newConfigurationDataEntity.getConfigurationName(),
+ policyDbDao.getConfigFile(configName, policy))) {
+ newConfigurationDataEntity.setConfigurationName(policyDbDao.getConfigFile(configName, policy));
+ }
+ if (newConfigurationDataEntity.getConfigType() == null
+ || !newConfigurationDataEntity.getConfigType().equals(policy.getConfigType())) {
+ newConfigurationDataEntity.setConfigType(policy.getConfigType());
+ }
+ if (!configUpdate) {
+ newConfigurationDataEntity.setCreatedBy(username);
+ }
+ if (newConfigurationDataEntity.getModifiedBy() == null
+ || !newConfigurationDataEntity.getModifiedBy().equals(username)) {
+ newConfigurationDataEntity.setModifiedBy(username);
+ }
+ if (newConfigurationDataEntity.getDescription() == null
+ || !newConfigurationDataEntity.getDescription().equals("")) {
+ newConfigurationDataEntity.setDescription("");
+ }
+ if (newConfigurationDataEntity.getConfigBody() == null
+ || newConfigurationDataEntity.getConfigBody().isEmpty()
+ || (!newConfigurationDataEntity.getConfigBody().equals(policy.getConfigBodyData()))) {
+ // hopefully one of these won't be null
+ if (policy.getConfigBodyData() == null || policy.getConfigBodyData().isEmpty()) {
+ newConfigurationDataEntity.setConfigBody(policy.getJsonBody());
+ } else {
+ newConfigurationDataEntity.setConfigBody(policy.getConfigBodyData());
+ }
+ }
+ if (newConfigurationDataEntity.isDeleted()) {
+ newConfigurationDataEntity.setDeleted(false);
+ }
+ if (isJunit) {
+ newConfigurationDataEntity.prePersist();
+ }
+ if (!configUpdate) {
+ session.persist(newConfigurationDataEntity);
+ }
+ } else {
+ // We have a configurationData body in the policy but we
+ // found no configurationData body in the DB
+ String msg = "\n\nPolicyDBDao.createPolicy - Incoming Config policy had a "
+ + "configurationData body, but it could not be found in the DB for update."
+ + "\n policyScope = " + policyScope + "\n policyName = " + policyName + "\n\n";
+ PolicyLogger
+ .error("PolicyDBDao.createPolicy - Incoming Config policy had a configurationData body, "
+ + "but it could not be found in the DB for update: policyName = " + policyName);
+ throw new IllegalArgumentException(msg);
+ }
+
+ } else {
+ newConfigurationDataEntity = null;
+ }
+ policyId = newPolicyEntity.getPolicyId();
+
+ if (!PolicyDBDao.stringEquals(newPolicyEntity.getPolicyName(), policyName)) {
+ newPolicyEntity.setPolicyName(policyName);
+ }
+ if (!PolicyDBDao.stringEquals(newPolicyEntity.getCreatedBy(), username)) {
+ newPolicyEntity.setCreatedBy(username);
+ }
+ if (!PolicyDBDao.stringEquals(newPolicyEntity.getDescription(), policy.getPolicyDescription())) {
+ newPolicyEntity.setDescription(policy.getPolicyDescription());
+ }
+ if (!PolicyDBDao.stringEquals(newPolicyEntity.getModifiedBy(), username)) {
+ newPolicyEntity.setModifiedBy(username);
+ }
+ if (!PolicyDBDao.stringEquals(newPolicyEntity.getPolicyData(), policyDataString)) {
+ newPolicyEntity.setPolicyData(policyDataString);
+ }
+ if (!PolicyDBDao.stringEquals(newPolicyEntity.getScope(), policyScope)) {
+ newPolicyEntity.setScope(policyScope);
+ }
+ if (newPolicyEntity.isDeleted()) {
+ newPolicyEntity.setDeleted(false);
+ }
+ newPolicyEntity.setConfigurationData(newConfigurationDataEntity);
+ newPolicyEntity.setActionBodyEntity(newActionBodyEntity);
+ if (isJunit) {
+ newPolicyEntity.prePersist();
+ }
+ if (!update) {
+ session.persist(newPolicyEntity);
+ }
+ session.flush();
+ this.policyId = newPolicyEntity.getPolicyId();
+ }
+ return;
+ }
+
+ @Override
+ public void createPolicy(Policy policy, String username) {
+ InputStream policyXmlStream = null;
+ try {
+ logger.debug("createPolicy(PolicyRestAdapter policy, String username) as createPolicy(" + policy + ","
+ + username + ") called");
+ String policyScope = policy.policyAdapter.getDomainDir().replace(File.separator, ".");
+ // Does not need to be XACMLPolicyWriterWithPapNotify since it is
+ // already in the PAP
+ // and this transaction is intercepted up stream.
+ String policyDataString;
+
+ try {
+ if (policy.policyAdapter.getData() instanceof PolicySetType) {
+ policyXmlStream = XACMLPolicyWriter
+ .getPolicySetXmlAsInputStream((PolicySetType) policy.getCorrectPolicyDataObject());
+ } else {
+ policyXmlStream = XACMLPolicyWriter.getXmlAsInputStream(policy.getCorrectPolicyDataObject());
+ }
+ policyDataString = IOUtils.toString(policyXmlStream);
+ } catch (IOException e) {
+ policyDataString = "could not read";
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught IOException on IOUtils.toString(" + policyXmlStream + ")");
+ throw new IllegalArgumentException("Cannot parse the policy xml from the PolicyRestAdapter.");
+ }
+
+ IOUtils.closeQuietly(policyXmlStream);
+ if (PolicyDBDao.isJunit) {
+ // Using parentPath object to set policy data.
+ policyDataString = policy.policyAdapter.getParentPath();
+ }
+ String configPath = "";
+ if (PolicyDBDao.CONFIG.equalsIgnoreCase(policy.policyAdapter.getPolicyType())) {
+ configPath = evaluateXPath(
+ "/Policy/Rule/AdviceExpressions/AdviceExpression[contains(@AdviceId,'ID')]/AttributeAssignmentExpression[@AttributeId='URLID']/AttributeValue/text()",
+ policyDataString);
+ } else if (PolicyDBDao.ACTION.equalsIgnoreCase(policy.policyAdapter.getPolicyType())) {
+ configPath = evaluateXPath(
+ "/Policy/Rule/ObligationExpressions/ObligationExpression[contains(@ObligationId, "
+ + policy.policyAdapter.getActionAttribute()
+ + ")]/AttributeAssignmentExpression[@AttributeId='body']/AttributeValue/text()",
+ policyDataString);
+ } else if (DECISIONMS_MODEL.equalsIgnoreCase(policy.policyAdapter.getRuleProvider())) {
+ configPath = evaluateXPath(
+ "/Policy/Rule/AdviceExpressions/AdviceExpression[contains(@AdviceId,'MicroService')]/AttributeAssignmentExpression[@AttributeId='URLID']/AttributeValue/text()",
+ policyDataString);
+ }
+
+ String prefix = null;
+ if (PolicyDBDao.CONFIG.equalsIgnoreCase(policy.policyAdapter.getPolicyType())
+ || DECISIONMS_MODEL.equalsIgnoreCase(policy.policyAdapter.getRuleProvider())) {
+ prefix = configPath.substring(configPath.indexOf(policyScope + ".") + policyScope.concat(".").length(),
+ configPath.lastIndexOf(policy.policyAdapter.getPolicyName()));
+ if (PolicyDBDao.isNullOrEmpty(policy.policyAdapter.getConfigBodyData())) {
+ String configData = "";
+ try {
+ String newConfigPath = configPath;
+ try {
+ newConfigPath = processConfigPath(newConfigPath);
+ } catch (Exception e2) {
+ logger.error("Could not process config path: " + newConfigPath, e2);
+ }
+ configData = readConfigFile(newConfigPath);
+ } catch (Exception e) {
+ logger.error("Could not read config body data for " + configPath, e);
+ }
+ policy.policyAdapter.setConfigBodyData(configData);
+ }
+ } else if (PolicyDBDao.ACTION.equalsIgnoreCase(policy.policyAdapter.getPolicyType())) {
+ prefix = "Action_";
+ } else if ("Decision".equalsIgnoreCase(policy.policyAdapter.getPolicyType())) {
+ prefix = "Decision_";
+ }
+
+ if (!(policy.policyAdapter.getData() instanceof PolicyType)
+ && !(policy.policyAdapter.getData() instanceof PolicySetType)) {
+ PolicyLogger.error("The data field is not an instance of PolicyType");
+ throw new IllegalArgumentException("The data field is not an instance of PolicyType");
+ }
+ String finalName = policyScope + "." + prefix + policy.policyAdapter.getPolicyName() + "."
+ + policy.policyAdapter.getHighestVersion() + ".xml";
+ if (policy.policyAdapter.getConfigType() == null || "".equals(policy.policyAdapter.getConfigType())) {
+ // get the config file extension
+ String ext = "";
+ if (configPath != null && !"".equalsIgnoreCase(configPath)) {
+ ext = configPath.substring(configPath.lastIndexOf('.'), configPath.length());;
+ }
+
+ if (ext.contains("txt")) {
+ policy.policyAdapter.setConfigType(PolicyDBDao.OTHER_CONFIG);
+ } else if (ext.contains("json")) {
+ policy.policyAdapter.setConfigType(PolicyDBDao.JSON_CONFIG);
+ } else if (ext.contains("xml")) {
+ policy.policyAdapter.setConfigType(PolicyDBDao.XML_CONFIG);
+ } else if (ext.contains("properties")) {
+ policy.policyAdapter.setConfigType(PolicyDBDao.PROPERTIES_CONFIG);
+ } else {
+ if (policy.policyAdapter.getPolicyType().equalsIgnoreCase(PolicyDBDao.ACTION)) {
+ policy.policyAdapter.setConfigType(PolicyDBDao.JSON_CONFIG);
+ }
+ }
+ }
+
+ createPolicy(policy.policyAdapter, username, policyScope, finalName, policyDataString);
+ } finally {
+ if (policyXmlStream != null) {
+ try {
+ policyXmlStream.close();
+ } catch (IOException e) {
+ logger.error("Exception Occured while closing input stream" + e);
+ }
+ }
+ }
+ }
+
+
+ public PolicyEntity getPolicy(int policyId) {
+ return getPolicy(policyId, null, null);
+ }
+
+ public PolicyEntity getPolicy(String policyName, String scope) {
+ return getPolicy(-1, policyName, scope);
+ }
+
+ private PolicyEntity getPolicy(int policyIdVar, String policyName, String scope) {
+ logger.debug("getPolicy(int policyId, String policyName) as " + " getPolicy(" + policyIdVar + "," + policyName
+ + ") called");
+ if (policyIdVar < 0 && PolicyDBDao.isNullOrEmpty(policyName, scope)) {
+ throw new IllegalArgumentException("policyID must be at least 0 or policyName must be not null or blank");
+ }
+
+ synchronized (emLock) {
+ checkBeforeOperationRun(true);
+ // check if group exists
+ String policyId;
+ Query policyQuery;
+ if (!PolicyDBDao.isNullOrEmpty(policyName, scope)) {
+ policyId = policyName;
+ policyQuery =
+ session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
+ policyQuery.setParameter("name", policyId);
+ policyQuery.setParameter("scope", scope);
+ } else {
+ policyId = String.valueOf(policyIdVar);
+ policyQuery = session.getNamedQuery("PolicyEntity.FindById");
+ policyQuery.setParameter("id", policyId);
+ }
+ List<?> policyQueryList;
+ try {
+ policyQueryList = policyQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to get policy with policyQuery.getResultList()");
+ throw new PersistenceException("Query failed trying to get policy " + policyId);
+ }
+
+ if (policyQueryList.isEmpty()) {
+ PolicyLogger.error("Policy does not exist with id " + policyId);
+ throw new PersistenceException("Group policy is being added to does not exist with id " + policyId);
+ } else if (policyQueryList.size() > 1) {
+ PolicyLogger.error(PolicyDBDao.DUP_POLICYID + policyId + PolicyDBDao.FOUND_IN_DB);
+ throw new PersistenceException(PolicyDBDao.DUP_POLICYID + policyId + PolicyDBDao.FOUND_IN_DB);
+ }
+ return (PolicyEntity) policyQueryList.get(0);
+ }
+ }
+
+ @Override
+ public GroupEntity getGroup(long groupKey) {
+ logger.debug("getGroup(int groupKey) as getGroup(" + groupKey + ") called");
+ if (groupKey < 0) {
+ throw new IllegalArgumentException("groupKey must be at least 0");
+ }
+ synchronized (emLock) {
+ checkBeforeOperationRun(true);
+ // check if group exists
+ Query groupQuery = session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupKey=:groupKey");
+ groupQuery.setParameter("groupKey", groupKey);
+ List<?> groupQueryList;
+ try {
+ groupQueryList = groupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to get group with groupQuery.getResultList()");
+ throw new PersistenceException(PolicyDBDao.QUERY_FAILED_GET_GROUP + groupKey);
+ }
+ if (groupQueryList.isEmpty()) {
+ PolicyLogger.error("Group does not exist with groupKey " + groupKey);
+ throw new PersistenceException("Group does not exist with groupKey " + groupKey);
+ } else if (groupQueryList.size() > 1) {
+ PolicyLogger
+ .error("Somehow, more than one group with the groupKey " + groupKey + PolicyDBDao.FOUND_IN_DB);
+ throw new PersistenceException(
+ "Somehow, more than one group with the groupKey " + groupKey + PolicyDBDao.FOUND_IN_DB);
+ }
+ return (GroupEntity) groupQueryList.get(0);
+ }
+ }
+
+ @Override
+ public GroupEntity getGroup(String groupId) {
+ logger.debug("getGroup(String groupId) as getGroup(" + groupId + ") called");
+ if (PolicyDBDao.isNullOrEmpty(groupId)) {
+ throw new IllegalArgumentException("groupId must not be null or empty");
+ }
+ synchronized (emLock) {
+ checkBeforeOperationRun(true);
+ // check if group exists
+ Query groupQuery = session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId");
+ groupQuery.setParameter(PolicyDBDao.GROUP_ID, groupId);
+ List<?> groupQueryList;
+ try {
+ groupQueryList = groupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to get group with groupQuery.getResultList()");
+ throw new PersistenceException(PolicyDBDao.QUERY_FAILED_GET_GROUP + groupId);
+ }
+ if (groupQueryList.isEmpty()) {
+ PolicyLogger.error("Group does not exist with id " + groupId);
+ throw new PersistenceException("Group does not exist with id " + groupId);
+ } else if (groupQueryList.size() > 1) {
+ PolicyLogger.error(PolicyDBDao.DUPLICATE_GROUPID + groupId + PolicyDBDao.FOUND_IN_DB);
+ throw new PersistenceException(PolicyDBDao.DUPLICATE_GROUPID + groupId + PolicyDBDao.FOUND_IN_DB);
+ }
+ return (GroupEntity) groupQueryList.get(0);
+ }
+ }
+
+ @Override
+ public List<?> getPdpsInGroup(long groupKey) {
+ logger.debug("getPdpsInGroup(int groupKey) as getPdpsInGroup(" + groupKey + ") called");
+ if (groupKey < 0) {
+ throw new IllegalArgumentException("groupId must not be < 0");
+ }
+ synchronized (emLock) {
+ checkBeforeOperationRun(true);
+ Query pdpsQuery = session.createQuery("SELECT p FROM PdpEntity p WHERE p.groupEntity=:group");
+ pdpsQuery.setParameter("group", getGroup(groupKey));
+ return pdpsQuery.list();
+ }
+ }
+
+ @Override
+ public PdpEntity getPdp(long pdpKey) {
+ logger.debug("getPdp(int pdpKey) as getPdp(" + pdpKey + ") called");
+ if (pdpKey < 0) {
+ throw new IllegalArgumentException("pdpKey must be at least 0");
+ }
+ synchronized (emLock) {
+ checkBeforeOperationRun(true);
+ // check if group exists
+ Query pdpQuery = session.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpKey=:pdpKey");
+ pdpQuery.setParameter("pdpKey", pdpKey);
+ List<?> pdpQueryList;
+ try {
+ pdpQueryList = pdpQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to get pdp with pdpQuery.getResultList()");
+ throw new PersistenceException("Query failed trying to get pdp " + pdpKey);
+ }
+ if (pdpQueryList.isEmpty()) {
+ PolicyLogger.error("Pdp does not exist with pdpKey " + pdpKey);
+ throw new PersistenceException("Pdp does not exist with pdpKey " + pdpKey);
+ } else if (pdpQueryList.size() > 1) {
+ PolicyLogger.error("Somehow, more than one pdp with the pdpKey " + pdpKey + PolicyDBDao.FOUND_IN_DB);
+ throw new PersistenceException(
+ "Somehow, more than one pdp with the pdpKey " + pdpKey + PolicyDBDao.FOUND_IN_DB);
+ }
+ return (PdpEntity) pdpQueryList.get(0);
+ }
+ }
+
+ @Override
+ public boolean isTransactionOpen() {
+ logger.debug("isTransactionOpen() as isTransactionOpen() called");
+ synchronized (emLock) {
+ return session.isOpen() && session.getTransaction().isActive();
+ }
+ }
+
+ private String processConfigPath(String inputConfigPath) {
+ String configPath = inputConfigPath;
+ String webappsPath = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS);
+ if (webappsPath == null) {
+ logger.error("Webapps property does not exist");
+ throw new IllegalArgumentException("Webapps property does not exist");
+ }
+ configPath = configPath.replace("$URL", webappsPath);
+ // make sure the correct slashes are in
+ try {
+ configPath = Paths.get(configPath).toString();
+ } catch (InvalidPathException e) {
+ logger.error("Invalid config path: " + configPath, e);
+ throw new IllegalArgumentException("Invalid config path: " + configPath);
+ }
+ return configPath;
+ }
+
+ private String readConfigFile(String configPath) {
+ String configDataString = null;
+ InputStream configContentStream = null;
+ try {
+ configContentStream = new FileInputStream(configPath);
+ configDataString = IOUtils.toString(configContentStream);
+ } catch (FileNotFoundException e) {
+ logger.error("Caught FileNotFoundException on new FileInputStream(" + configPath + ")", e);
+ throw new IllegalArgumentException("The config file path does not exist");
+ } catch (IOException e2) {
+ logger.error("Caught IOException on newIOUtils.toString(" + configContentStream + ")", e2);
+ throw new IllegalArgumentException("The config file path cannot be read");
+ } finally {
+ IOUtils.closeQuietly(configContentStream);
+ }
+ if (configDataString == null) {
+ throw new IllegalArgumentException("The config file path cannot be read");
+ }
+ return configDataString;
+ }
+
+
+ @Override
+ public void close() {
+ synchronized (emLock) {
+ if (session.isOpen()) {
+ if (session.getTransaction().isActive()) {
+ session.getTransaction().rollback();
+ }
+ session.close();
+ }
+ if (transactionTimer != null) {
+ transactionTimer.interrupt();
+ }
+ }
+ }
+
+ @Override
+ public void createGroup(String groupId, String groupName, String inputGroupDescription, String username) {
+ String groupDescription = inputGroupDescription;
+ logger.debug("deletePolicy(String policyToDeletes) as createGroup(" + groupId + ", " + groupName + ", "
+ + groupDescription + ") called");
+ if (PolicyDBDao.isNullOrEmpty(groupId, groupName, username)) {
+ throw new IllegalArgumentException("groupId, groupName, and username must not be null or empty");
+ }
+ if (groupDescription == null) {
+ groupDescription = "";
+ }
+
+ synchronized (emLock) {
+ checkBeforeOperationRun();
+ Query checkGroupQuery = session.createQuery(PolicyDBDao.GROUPENTITY_SELECT);
+ checkGroupQuery.setParameter(PolicyDBDao.GROUP_ID, groupId);
+ checkGroupQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> checkGroupQueryList;
+ try {
+ checkGroupQueryList = checkGroupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on checkGroupQuery.getResultList()");
+ throw new PersistenceException(PolicyDBDao.QUERY_FAILED_FOR_GROUP);
+ }
+ if (!checkGroupQueryList.isEmpty()) {
+ PolicyLogger.error("The group being added already exists with id " + groupId);
+ throw new PersistenceException("The group being added already exists with id " + groupId);
+ }
+ GroupEntity newGroup = new GroupEntity();
+ newGroup.setCreatedBy(username);
+ newGroup.setModifiedBy(username);
+ newGroup.setGroupName(groupName);
+ newGroup.setGroupId(groupId);
+ newGroup.setDescription(groupDescription);
+ if (isJunit) {
+ newGroup.prePersist();
+ }
+ session.persist(newGroup);
+ session.flush();
+ this.groupId = newGroup.getGroupKey();
+ }
+ }
+
+ @Override
+ public void updateGroup(OnapPDPGroup group, String requestType, String username) {
+ logger.info("PolicyDBDao: updateGroup(PDPGroup group) as updateGroup(" + group + "," + requestType + ","
+ + username + ") called");
+ if (group == null) {
+ throw new IllegalArgumentException("PDPGroup group must not be null");
+ }
+ if (PolicyDBDao.isNullOrEmpty(group.getId(), requestType)) {
+ throw new IllegalArgumentException("group.getId() and username must not be null or empty");
+ }
+
+ synchronized (emLock) {
+ PolicyDBDao policyDbDaoVar = new PolicyDBDao();
+ checkBeforeOperationRun();
+ Query getGroupQuery = session.createQuery(PolicyDBDao.GROUPENTITY_SELECT);
+ getGroupQuery.setParameter(PolicyDBDao.GROUP_ID, group.getId());
+ getGroupQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> getGroupQueryList;
+ try {
+ getGroupQueryList = getGroupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on getGroupQuery.getResultList()");
+ throw new PersistenceException(PolicyDBDao.QUERY_FAILED_GET_GROUP + group.getId() + " for editing");
+ }
+ if (getGroupQueryList.isEmpty()) {
+ PolicyLogger.error("The group cannot be found to update with id " + group.getId());
+ throw new PersistenceException("The group cannot be found to update with id " + group.getId());
+ } else if (getGroupQueryList.size() > 1) {
+ PolicyLogger.error(PolicyDBDao.DUPLICATE_GROUPID + group.getId() + PolicyDBDao.DELETED_STATUS_FOUND);
+ throw new PersistenceException(
+ PolicyDBDao.DUPLICATE_GROUPID + group.getId() + PolicyDBDao.DELETED_STATUS_FOUND);
+ }
+ GroupEntity groupToUpdateInDb = (GroupEntity) getGroupQueryList.get(0);
+ if (!PolicyDBDao.stringEquals(groupToUpdateInDb.getModifiedBy(), requestType)) {
+ groupToUpdateInDb.setModifiedBy(requestType);
+ }
+ if (group.getDescription() != null
+ && !PolicyDBDao.stringEquals(group.getDescription(), groupToUpdateInDb.getDescription())) {
+ groupToUpdateInDb.setDescription(group.getDescription());
+ }
+ // let's find out what policies have been deleted
+ StdPDPGroup oldGroup = null;
+ try {
+ oldGroup = (StdPDPGroup) PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(group.getId());
+ } catch (PAPException e1) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, PolicyDBDao.POLICYDBDAO_VAR,
+ "We cannot get the group from the papEngine to delete policies");
+ }
+ if (oldGroup == null) {
+ PolicyLogger.error("We cannot get the group from the papEngine to delete policies");
+ } else {
+ Set<String> newPolicySet = new HashSet<>(group.getPolicies().size());
+ // a multiple of n runtime is faster than n^2, so I am using a
+ // hashset to do the comparison
+ for (PDPPolicy pol : group.getPolicies()) {
+ newPolicySet.add(pol.getId());
+ }
+ for (PDPPolicy pol : oldGroup.getPolicies()) {
+ // should be fast since getPolicies uses a HashSet in
+ // StdPDPGroup
+ if (!newPolicySet.contains(pol.getId())) {
+ String[] scopeAndName = policyDbDaoVar.getNameScopeAndVersionFromPdpPolicy(pol.getId());
+ PolicyEntity policyToDelete = null;
+ try {
+ if (scopeAndName != null) {
+ policyToDelete = getPolicy(scopeAndName[0], scopeAndName[1]);
+ if ("XACMLPapServlet.doDelete".equals(requestType)) {
+ Iterator<PolicyEntity> dbPolicyIt = groupToUpdateInDb.getPolicies().iterator();
+ String policyName = policyDbDaoVar.getPolicyNameAndVersionFromPolicyFileName(
+ policyToDelete.getPolicyName())[0];
+
+ logger.info("PolicyDBDao: delete policy from GroupEntity");
+ try {
+ while (dbPolicyIt.hasNext()) {
+ PolicyEntity dbpolicy = dbPolicyIt.next();
+ if (policyToDelete.getScope().equals(dbpolicy.getScope())
+ && policyDbDaoVar.getPolicyNameAndVersionFromPolicyFileName(
+ dbpolicy.getPolicyName())[0].equals(policyName)) {
+ dbPolicyIt.remove();
+ logger.info("PolicyDBDao: deleting policy from the existing group:\n "
+ + "policyName is " + policyToDelete.getScope() + "."
+ + policyToDelete.getPolicyName() + "\n" + "group is "
+ + groupToUpdateInDb.getGroupId());
+ }
+ }
+ } catch (Exception e) {
+ logger.debug(e);
+ PolicyLogger.error("Could not delete policy with name: "
+ + policyToDelete.getScope() + "." + policyToDelete.getPolicyName()
+ + "\n ID: " + policyToDelete.getPolicyId());
+ }
+ }
+ }
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Could not get policy to remove: " + pol.getId());
+ throw new PersistenceException("Could not get policy to remove: " + pol.getId());
+ }
+ }
+ }
+ }
+
+ if (group.getName() != null
+ && !PolicyDBDao.stringEquals(group.getName(), groupToUpdateInDb.getgroupName())) {
+ // we need to check if the new id exists in the database
+ String newGrpId = PolicyDBDao.createNewPDPGroupId(group.getName());
+ Query checkGroupQuery = session.createQuery(PolicyDBDao.GROUPENTITY_SELECT);
+ checkGroupQuery.setParameter(PolicyDBDao.GROUP_ID, newGrpId);
+ checkGroupQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> checkGroupQueryList;
+ try {
+ checkGroupQueryList = checkGroupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on checkGroupQuery.getResultList()");
+ throw new PersistenceException(PolicyDBDao.QUERY_FAILED_FOR_GROUP);
+ }
+ if (!checkGroupQueryList.isEmpty()) {
+ PolicyLogger.error("The new group name already exists, group id " + newGrpId);
+ throw new PersistenceException("The new group name already exists, group id " + newGrpId);
+ }
+ groupToUpdateInDb.setGroupId(newGrpId);
+ groupToUpdateInDb.setGroupName(group.getName());
+ this.newGroupId = group.getId();
+ }
+ session.flush();
+ this.groupId = groupToUpdateInDb.getGroupKey();
+ }
+ }
+
+ @Override
+ public void addPdpToGroup(String pdpId, String groupIdVar, String pdpName, String pdpDescription, int pdpJmxPort,
+ String username) {
+ logger.debug("addPdpToGroup(String pdpID, String groupID, String pdpName, "
+ + "String pdpDescription, int pdpJmxPort, String username) as addPdpToGroup(" + pdpId + ", "
+ + groupIdVar + ", " + pdpName + ", " + pdpDescription + ", " + pdpJmxPort + ", " + username
+ + ") called");
+ if (PolicyDBDao.isNullOrEmpty(pdpId, groupIdVar, pdpName, username)) {
+ throw new IllegalArgumentException("pdpID, groupID, pdpName, and username must not be null or empty");
+ }
+ synchronized (emLock) {
+ checkBeforeOperationRun();
+ Query checkGroupQuery = session.createQuery(PolicyDBDao.GROUPENTITY_SELECT);
+ checkGroupQuery.setParameter(PolicyDBDao.GROUP_ID, groupIdVar);
+ checkGroupQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> checkGroupQueryList;
+ try {
+ checkGroupQueryList = checkGroupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to check for existing group on checkGroupQuery.getResultList()");
+ throw new PersistenceException(PolicyDBDao.QUERY_FAILED_FOR_GROUP);
+ }
+ if (checkGroupQueryList.size() != 1) {
+ PolicyLogger.error("The group does not exist");
+ throw new PersistenceException("The group does not exist");
+ }
+ Query checkDuplicateQuery = session.createQuery(PolicyDBDao.PDPENTITY_SELECT);
+ checkDuplicateQuery.setParameter(PolicyDBDao.PDP_ID, pdpId);
+ checkDuplicateQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> checkDuplicateList;
+ try {
+ checkDuplicateList = checkDuplicateQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to check for duplicate PDP " + pdpId
+ + " on checkDuplicateQuery.getResultList()");
+ throw new PersistenceException("Query failed trying to check for duplicate PDP " + pdpId);
+ }
+ PdpEntity newPdp;
+ if (!checkDuplicateList.isEmpty()) {
+ logger.warn("PDP already exists with id " + pdpId);
+ newPdp = (PdpEntity) checkDuplicateList.get(0);
+ } else {
+ newPdp = new PdpEntity();
+ }
+
+ newPdp.setCreatedBy(username);
+ newPdp.setDeleted(false);
+ newPdp.setDescription(pdpDescription);
+ newPdp.setGroup((GroupEntity) checkGroupQueryList.get(0));
+ newPdp.setJmxPort(pdpJmxPort);
+ newPdp.setModifiedBy(username);
+ newPdp.setPdpId(pdpId);
+ newPdp.setPdpName(pdpName);
+ if (isJunit) {
+ newPdp.prePersist();
+ }
+ session.persist(newPdp);
+ session.flush();
+ this.pdpId = newPdp.getPdpKey();
+ }
+ }
+
+ @Override
+ public void updatePdp(OnapPDP pdp, String username) {
+ logger.debug("updatePdp(PDP pdp, String username) as updatePdp(" + pdp + "," + username + ") called");
+ if (pdp == null) {
+ throw new IllegalArgumentException("PDP pdp must not be null");
+ }
+ if (PolicyDBDao.isNullOrEmpty(pdp.getId(), username)) {
+ throw new IllegalArgumentException("pdp.getId() and username must not be null or empty");
+ }
+
+ synchronized (emLock) {
+ checkBeforeOperationRun();
+ Query getPdpQuery = session.createQuery(PolicyDBDao.PDPENTITY_SELECT);
+ getPdpQuery.setParameter(PolicyDBDao.PDP_ID, pdp.getId());
+ getPdpQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> getPdpQueryList;
+ try {
+ getPdpQueryList = getPdpQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on getPdpQuery.getResultList()");
+ throw new PersistenceException("Query failed trying to get PDP " + pdp.getId());
+ }
+ if (getPdpQueryList.isEmpty()) {
+ PolicyLogger.error("The pdp cannot be found to update with id " + pdp.getId());
+ throw new PersistenceException("The pdp cannot be found to update with id " + pdp.getId());
+ } else if (getPdpQueryList.size() > 1) {
+ PolicyLogger.error(PolicyDBDao.MORE_THAN_ONE_PDP + pdp.getId() + PolicyDBDao.DELETED_STATUS_FOUND);
+ throw new PersistenceException(
+ PolicyDBDao.MORE_THAN_ONE_PDP + pdp.getId() + PolicyDBDao.DELETED_STATUS_FOUND);
+ }
+ PdpEntity pdpToUpdate = (PdpEntity) getPdpQueryList.get(0);
+ if (!PolicyDBDao.stringEquals(pdpToUpdate.getModifiedBy(), username)) {
+ pdpToUpdate.setModifiedBy(username);
+ }
+ if (pdp.getDescription() != null
+ && !PolicyDBDao.stringEquals(pdp.getDescription(), pdpToUpdate.getDescription())) {
+ pdpToUpdate.setDescription(pdp.getDescription());
+ }
+ if (pdp.getName() != null && !PolicyDBDao.stringEquals(pdp.getName(), pdpToUpdate.getPdpName())) {
+ pdpToUpdate.setPdpName(pdp.getName());
+ }
+ if (pdp.getJmxPort() != null && !pdp.getJmxPort().equals(pdpToUpdate.getJmxPort())) {
+ pdpToUpdate.setJmxPort(pdp.getJmxPort());
+ }
+
+ session.flush();
+ this.pdpId = pdpToUpdate.getPdpKey();
+ }
+ }
+
+ @Override
+ public void movePdp(OnapPDP pdp, OnapPDPGroup group, String username) {
+ logger.debug("movePdp(PDP pdp, PDPGroup group, String username) as movePdp(" + pdp + "," + group + ","
+ + username + ") called");
+ if (pdp == null || group == null) {
+ throw new IllegalArgumentException("PDP pdp and PDPGroup group must not be null");
+ }
+ if (PolicyDBDao.isNullOrEmpty(username, pdp.getId(), group.getId())) {
+ throw new IllegalArgumentException("pdp.getId(), group.getId(), and username must not be null or empty");
+ }
+
+ synchronized (emLock) {
+ checkBeforeOperationRun();
+ // check if pdp exists
+ Query getPdpQuery = session.createQuery(PolicyDBDao.PDPENTITY_SELECT);
+ getPdpQuery.setParameter(PolicyDBDao.PDP_ID, pdp.getId());
+ getPdpQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> getPdpQueryList;
+ try {
+ getPdpQueryList = getPdpQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on getPdpQuery.getResultList()");
+ throw new PersistenceException("Query failed trying to get pdp to move with id " + pdp.getId());
+ }
+ if (getPdpQueryList.isEmpty()) {
+ PolicyLogger.error("The pdp cannot be found to move with id " + pdp.getId());
+ throw new PersistenceException("The pdp cannot be found to move with id " + pdp.getId());
+ } else if (getPdpQueryList.size() > 1) {
+ PolicyLogger.error(PolicyDBDao.MORE_THAN_ONE_PDP + pdp.getId() + PolicyDBDao.DELETED_STATUS_FOUND);
+ throw new PersistenceException(
+ PolicyDBDao.MORE_THAN_ONE_PDP + pdp.getId() + PolicyDBDao.DELETED_STATUS_FOUND);
+ }
+
+ // check if new group exists
+ Query checkGroupQuery = session.createQuery(PolicyDBDao.GROUPENTITY_SELECT);
+ checkGroupQuery.setParameter(PolicyDBDao.GROUP_ID, group.getId());
+ checkGroupQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> checkGroupQueryList;
+ try {
+ checkGroupQueryList = checkGroupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to get group on checkGroupQuery.getResultList()");
+ throw new PersistenceException("Query failed trying to get new group " + group.getId());
+ }
+ if (checkGroupQueryList.size() != 1) {
+ PolicyLogger.error("The group " + group.getId() + " does not exist");
+ throw new PersistenceException("The group " + group.getId() + " does not exist");
+ }
+ GroupEntity groupToMoveInto = (GroupEntity) checkGroupQueryList.get(0);
+ PdpEntity pdpToUpdate = (PdpEntity) getPdpQueryList.get(0);
+ pdpToUpdate.setGroup(groupToMoveInto);
+ if (!PolicyDBDao.stringEquals(pdpToUpdate.getModifiedBy(), username)) {
+ pdpToUpdate.setModifiedBy(username);
+ }
+
+ session.flush();
+ this.pdpId = pdpToUpdate.getPdpKey();
+ }
+ }
+
+ @Override
+ public void changeDefaultGroup(OnapPDPGroup group, String username) {
+ logger.debug("changeDefaultGroup(PDPGroup group, String username) as changeDefaultGroup(" + group + ","
+ + username + ") called");
+ if (group == null) {
+ throw new IllegalArgumentException("PDPGroup group must not be null");
+ }
+ if (PolicyDBDao.isNullOrEmpty(group.getId(), username)) {
+ throw new IllegalArgumentException("group.getId() and username must not be null or empty");
+ }
+
+ synchronized (emLock) {
+ checkBeforeOperationRun();
+ Query getGroupQuery = session.createQuery(PolicyDBDao.GROUPENTITY_SELECT);
+ getGroupQuery.setParameter(PolicyDBDao.GROUP_ID, group.getId());
+ getGroupQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> getGroupQueryList;
+ try {
+ getGroupQueryList = getGroupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on getGroupQuery.getResultList()");
+ throw new PersistenceException(PolicyDBDao.QUERY_FAILED_GET_GROUP + group.getId());
+ }
+ if (getGroupQueryList.isEmpty()) {
+ PolicyLogger.error("The group cannot be found to set default with id " + group.getId());
+ throw new PersistenceException("The group cannot be found to set default with id " + group.getId());
+ } else if (getGroupQueryList.size() > 1) {
+ PolicyLogger.error(PolicyDBDao.DUPLICATE_GROUPID + group.getId() + PolicyDBDao.DELETED_STATUS_FOUND);
+ throw new PersistenceException(
+ PolicyDBDao.DUPLICATE_GROUPID + group.getId() + PolicyDBDao.DELETED_STATUS_FOUND);
+ }
+ GroupEntity newDefaultGroup = (GroupEntity) getGroupQueryList.get(0);
+ newDefaultGroup.setDefaultGroup(true);
+ if (!PolicyDBDao.stringEquals(newDefaultGroup.getModifiedBy(), username)) {
+ newDefaultGroup.setModifiedBy(username);
+ }
+
+ session.flush();
+ this.groupId = newDefaultGroup.getGroupKey();
+ Query setAllGroupsNotDefault = session.createQuery("UPDATE GroupEntity g SET g.defaultGroup=:defaultGroup "
+ + "WHERE g.deleted=:deleted AND g.groupKey<>:groupKey");
+ // not going to set modified by for all groups
+ setAllGroupsNotDefault.setParameter("defaultGroup", false);
+ setAllGroupsNotDefault.setParameter(PolicyDBDao.DELETED, false);
+ setAllGroupsNotDefault.setParameter("groupKey", newDefaultGroup.getGroupKey());
+ try {
+ logger.info("set " + setAllGroupsNotDefault.executeUpdate() + " groups as not default");
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception on setAllGroupsNotDefault.executeUpdate()");
+ throw new PersistenceException("Could not set all other groups default to false");
+ }
+ session.flush();
+ }
+ }
+
+ @Override
+ public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username) throws PolicyDBException {
+ logger.debug("deleteGroup(PDPGroup group, PDPGroup moveToGroup, String username) as deleteGroup(" + group + ", "
+ + moveToGroup + "," + username + ") called");
+ if (group == null) {
+ throw new IllegalArgumentException("PDPGroup group cannot be null");
+ }
+ if (PolicyDBDao.isNullOrEmpty(username, group.getId())) {
+ throw new IllegalArgumentException("group.getId() and and username must not be null or empty");
+ }
+
+ if (group.isDefaultGroup()) {
+ PolicyLogger.error("The default group " + group.getId() + " was attempted to be deleted. It cannot be.");
+ throw new PolicyDBException("You cannot delete the default group.");
+ }
+ synchronized (emLock) {
+ checkBeforeOperationRun();
+ Query deleteGroupQuery = session.createQuery(PolicyDBDao.GROUPENTITY_SELECT);
+ deleteGroupQuery.setParameter(PolicyDBDao.GROUP_ID, group.getId());
+ deleteGroupQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> deleteGroupQueryList;
+ try {
+ deleteGroupQueryList = deleteGroupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to check if group exists deleteGroupQuery.getResultList()");
+ throw new PersistenceException("Query failed trying to check if group exists");
+ }
+ if (deleteGroupQueryList.isEmpty()) {
+ logger.warn(PolicyDBDao.GROUP_NOT_FOUND + group.getId());
+ return;
+ } else if (deleteGroupQueryList.size() > 1) {
+ PolicyLogger.error(PolicyDBDao.DUPLICATE_GROUPID + group.getId() + PolicyDBDao.FOUND_IN_DB_NOT_DEL);
+ throw new PersistenceException(
+ PolicyDBDao.DUPLICATE_GROUPID + group.getId() + PolicyDBDao.FOUND_IN_DB_NOT_DEL);
+ }
+
+ Query pdpsInGroupQuery =
+ session.createQuery("SELECT p FROM PdpEntity p WHERE p.groupEntity=:group and p.deleted=:deleted");
+ pdpsInGroupQuery.setParameter("group", (deleteGroupQueryList.get(0)));
+ pdpsInGroupQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> pdpsInGroupList;
+ try {
+ pdpsInGroupList = pdpsInGroupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to get PDPs in group on pdpsInGroupQuery.getResultList()");
+ throw new PersistenceException("Query failed trying to get PDPs in group");
+ }
+ if (!pdpsInGroupList.isEmpty()) {
+ if (moveToGroup != null) {
+ Query checkMoveToGroupQuery = session
+ .createQuery("SELECT o FROM GroupEntity o WHERE o.groupId=:groupId AND o.deleted=:deleted");
+ checkMoveToGroupQuery.setParameter(PolicyDBDao.GROUP_ID, moveToGroup.getId());
+ checkMoveToGroupQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> checkMoveToGroupList;
+ try {
+ checkMoveToGroupList = checkMoveToGroupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to check if group exists checkMoveToGroupQuery.getResultList");
+ throw new PersistenceException("Query failed trying to check if group exists");
+ }
+ if (checkMoveToGroupList.isEmpty()) {
+ PolicyLogger.error(PolicyDBDao.GROUP_NOT_FOUND + moveToGroup.getId());
+ throw new PersistenceException(PolicyDBDao.GROUP_NOT_FOUND + moveToGroup.getId());
+ } else if (checkMoveToGroupList.size() > 1) {
+ PolicyLogger.error(
+ PolicyDBDao.DUPLICATE_GROUPID + moveToGroup.getId() + PolicyDBDao.FOUND_IN_DB_NOT_DEL);
+ throw new PersistenceException(
+ PolicyDBDao.DUPLICATE_GROUPID + moveToGroup.getId() + PolicyDBDao.FOUND_IN_DB_NOT_DEL);
+ } else {
+ GroupEntity newGroup = (GroupEntity) checkMoveToGroupList.get(0);
+ for (Object pdpObject : pdpsInGroupList) {
+ PdpEntity pdp = (PdpEntity) pdpObject;
+ pdp.setGroup(newGroup);
+ if (!PolicyDBDao.stringEquals(pdp.getModifiedBy(), username)) {
+ pdp.setModifiedBy(username);
+ }
+ try {
+ session.flush();
+ this.newGroupId = newGroup.getGroupId();
+ } catch (PersistenceException e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught PersistenceException trying to set pdp group to null on em.flush()");
+ throw new PersistenceException("Query failed trying to set pdp group to ");
+ }
+ }
+ }
+ } else {
+ PolicyLogger.error("Group " + group.getId()
+ + " is trying to be delted with PDPs. No group was provided to move them to");
+ throw new PolicyDBException("Group has PDPs. Must provide a group for them to move to");
+ }
+ }
+
+ // delete group here
+ GroupEntity groupToDelete = (GroupEntity) deleteGroupQueryList.get(0);
+ groupToDelete.setDeleted(true);
+ if (!PolicyDBDao.stringEquals(groupToDelete.getModifiedBy(), username)) {
+ groupToDelete.setModifiedBy(username);
+ }
+ session.flush();
+ this.groupId = groupToDelete.getGroupKey();
+ }
+ }
+
+ @Override
+ public StdPDPGroup addPolicyToGroup(String groupIdVar, String policyIdVar, String requestType, String username)
+ throws PolicyDBException {
+ logger.info(
+ "PolicyDBDao: addPolicyToGroup(String groupID, String policyID, String username) as addPolicyToGroup("
+ + groupIdVar + ", " + policyIdVar + "," + requestType + "," + username + ") called");
+ if (PolicyDBDao.isNullOrEmpty(groupIdVar, policyIdVar, requestType)) {
+ throw new IllegalArgumentException("groupID, policyID, and username must not be null or empty");
+ }
+ synchronized (emLock) {
+ checkBeforeOperationRun();
+ // check if group exists
+ Query groupQuery = session.createQuery(PolicyDBDao.GROUPENTITY_SELECT);
+ groupQuery.setParameter(PolicyDBDao.GROUP_ID, groupIdVar);
+ groupQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> groupQueryList;
+ try {
+ groupQueryList = groupQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to check if group exists groupQuery.getResultList()");
+ throw new PersistenceException("Query failed trying to check if group " + groupIdVar + " exists");
+ }
+ if (groupQueryList.isEmpty()) {
+ PolicyLogger.error("Group policy is being added to does not exist with id " + groupIdVar);
+ throw new PersistenceException("Group policy is being added to does not exist with id " + groupIdVar);
+ } else if (groupQueryList.size() > 1) {
+ PolicyLogger.error(PolicyDBDao.DUPLICATE_GROUPID + groupIdVar + PolicyDBDao.FOUND_IN_DB_NOT_DEL);
+ throw new PersistenceException(
+ PolicyDBDao.DUPLICATE_GROUPID + groupIdVar + PolicyDBDao.FOUND_IN_DB_NOT_DEL);
+ }
+
+ // we need to convert the form of the policy id that is used groups
+ // into the form that is used
+ // for the database. (com.Config_mypol.1.xml) to (Config_mypol.xml)
+ PolicyDBDao policyDbDao = new PolicyDBDao();
+ String[] policyNameScopeAndVersion = policyDbDao.getNameScopeAndVersionFromPdpPolicy(policyIdVar);
+ if (policyNameScopeAndVersion == null) {
+ throw new IllegalArgumentException("Invalid input - policyID must contain name, scope and version");
+ }
+ Query policyQuery = session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:policyName "
+ + "AND p.scope=:scope AND p.deleted=:deleted");
+ policyQuery.setParameter("policyName", policyNameScopeAndVersion[0]);
+ policyQuery.setParameter(PolicyDBDao.SCOPE, policyNameScopeAndVersion[1]);
+ policyQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> policyQueryList;
+ try {
+ policyQueryList = policyQuery.list();
+ } catch (Exception e) {
+ logger.debug(e);
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to check if policy exists policyQuery.getResultList()");
+ throw new PersistenceException(
+ "Query failed trying to check if policy " + policyNameScopeAndVersion[0] + " exists");
+ }
+ if (policyQueryList.isEmpty()) {
+ PolicyLogger.error("Policy being added to the group does not exist with policy id "
+ + policyNameScopeAndVersion[0]);
+ throw new PersistenceException("Policy being added to the group does not exist with policy id "
+ + policyNameScopeAndVersion[0]);
+ } else if (policyQueryList.size() > 1) {
+ PolicyLogger.error(
+ PolicyDBDao.DUP_POLICYID + policyNameScopeAndVersion[0] + PolicyDBDao.FOUND_IN_DB_NOT_DEL);
+ throw new PersistenceException(
+ PolicyDBDao.DUPLICATE_GROUPID + policyNameScopeAndVersion[0] + PolicyDBDao.FOUND_IN_DB_NOT_DEL);
+ }
+ logger.info("PolicyDBDao: Getting group and policy from database");
+ GroupEntity group = (GroupEntity) groupQueryList.get(0);
+ PolicyEntity policy = (PolicyEntity) policyQueryList.get(0);
+ Iterator<PolicyEntity> policyIt = group.getPolicies().iterator();
+ String policyName = policyDbDao.getPolicyNameAndVersionFromPolicyFileName(policy.getPolicyName())[0];
+
+ logger.info("PolicyDBDao: policyName retrieved is " + policyName);
+ try {
+ while (policyIt.hasNext()) {
+ PolicyEntity pol = policyIt.next();
+ if (policy.getScope().equals(pol.getScope())
+ && policyDbDao.getPolicyNameAndVersionFromPolicyFileName(pol.getPolicyName())[0]
+ .equals(policyName)) {
+ policyIt.remove();
+ }
+ }
+ } catch (Exception e) {
+ logger.debug(e);
+ PolicyLogger.error("Could not delete old versions for policy " + policy.getPolicyName() + ", ID: "
+ + policy.getPolicyId());
+ }
+ group.addPolicyToGroup(policy);
+ session.flush();
+
+ // After adding policy to the db group we need to make sure the
+ // filesytem group is in sync with the db group
+ try {
+ StdPDPGroup pdpGroup =
+ (StdPDPGroup) PolicyDBDao.getPolicyDBDaoInstance().getPapEngine().getGroup(group.getGroupId());
+ return policyDbDao.synchronizeGroupPoliciesInFileSystem(pdpGroup, group);
+ } catch (PAPException e) {
+ logger.debug(e);
+ PolicyLogger.error("PolicyDBDao: Could not synchronize the filesystem group with the database group. "
+ + e.getMessage());
+ }
+ return null;
+ }
+ }
+
+ // this means delete pdp not just remove from group
+ @Override
+ public void removePdpFromGroup(String pdpId, String username) {
+ logger.debug("removePdpFromGroup(String pdpID, String username) as removePdpFromGroup(" + pdpId + "," + username
+ + ") called");
+ if (PolicyDBDao.isNullOrEmpty(pdpId, username)) {
+ throw new IllegalArgumentException("pdpID and username must not be null or empty");
+ }
+ synchronized (emLock) {
+ checkBeforeOperationRun();
+ Query pdpQuery = session.createQuery(PolicyDBDao.PDPENTITY_SELECT);
+ pdpQuery.setParameter(PolicyDBDao.PDP_ID, pdpId);
+ pdpQuery.setParameter(PolicyDBDao.DELETED, false);
+ List<?> pdpList;
+ try {
+ pdpList = pdpQuery.list();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, PolicyDBDao.POLICYDBDAO_VAR,
+ "Caught Exception trying to check if pdp exists pdpQuery.getResultList()");
+ throw new PersistenceException("Query failed trying to check if pdp " + pdpId + " exists");
+ }
+ if (pdpList.size() > 1) {
+ PolicyLogger.error("Somehow, more than one pdp with the id " + pdpId + PolicyDBDao.FOUND_IN_DB_NOT_DEL);
+ throw new PersistenceException(
+ "Somehow, more than one pdp with the id " + pdpId + PolicyDBDao.FOUND_IN_DB_NOT_DEL);
+ } else if (pdpList.isEmpty()) {
+ PolicyLogger.error("Pdp being removed does not exist with id " + pdpId);
+ return;
+ }
+ PdpEntity pdp = (PdpEntity) pdpList.get(0);
+ if (!isJunit) {
+ pdp.setGroup(null);
+ }
+
+ if (!PolicyDBDao.stringEquals(pdp.getModifiedBy(), username)) {
+ pdp.setModifiedBy(username);
+ }
+ pdp.setDeleted(true);
+
+ session.flush();
+ this.pdpId = pdp.getPdpKey();
+ }
+ }
+
+ private static String evaluateXPath(String expression, String xml) {
+ InputSource source = new InputSource(new StringReader(xml));
+
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ String description = "";
+ try {
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ Document document = db.parse(source);
+
+ XPathFactory xpathFactory = XPathFactory.newInstance();
+ XPath xpath = xpathFactory.newXPath();
+
+ description = xpath.evaluate(expression, document);
+ } catch (Exception e) {
+ logger.error("Exception Occured while evaluating path" + e);
+ }
+ return description;
+ }
+}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyController.java
index eec34b642..17fce7142 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyController.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyController.java
@@ -2,7 +2,7 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -17,8 +17,13 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
+
package org.onap.policy.pap.xacml.rest.controller;
+import com.att.research.xacml.api.pap.PAPException;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
@@ -27,12 +32,9 @@ import java.io.ObjectOutputStream;
import java.net.URI;
import java.util.List;
import java.util.UUID;
-
-import javax.persistence.EntityManager;
-import javax.persistence.Query;
+import javax.script.SimpleBindings;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-
import org.onap.policy.common.logging.eelf.MessageCodes;
import org.onap.policy.common.logging.eelf.PolicyLogger;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
@@ -48,11 +50,6 @@ import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
-import com.att.research.xacml.api.pap.PAPException;
-import com.fasterxml.jackson.databind.DeserializationFeature;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-
@Controller
public class PushPolicyController {
private static final Logger LOGGER = FlexLogger.getLogger(PushPolicyController.class);
@@ -144,13 +141,15 @@ public class PushPolicyController {
response.setStatus(HttpServletResponse.SC_NOT_FOUND);
return;
}
- //Get PolicyEntity from DB;
- EntityManager em = XACMLPapServlet.getEmf().createEntityManager();
- Query createPolicyQuery =
- em.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName");
- createPolicyQuery.setParameter("scope", policyScope);
- createPolicyQuery.setParameter(policyNames, policyName.substring(policyScope.length() + 1));
- List<?> createPolicyQueryList = createPolicyQuery.getResultList();
+ // Get PolicyEntity from DB;
+ String createPolicyQuery = "SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName";
+ SimpleBindings params = new SimpleBindings();
+ params.put("scope", policyScope);
+ params.put(policyNames, policyName.substring(policyScope.length() + 1));
+ List<?> createPolicyQueryList = commonClassDao.getDataByQuery(createPolicyQuery, params);
+ LOGGER.info("addPolicyToGroup:Total execution time to retrieve " + policyNames
+ + " from PolicyEntity");
+
PolicyEntity policyEntity = null;
if (!createPolicyQueryList.isEmpty()) {
policyEntity = (PolicyEntity) createPolicyQueryList.get(0);
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandler.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandler.java
index f71af87cc..ca0bb775a 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandler.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandler.java
@@ -2,7 +2,7 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -19,20 +19,16 @@
*/
package org.onap.policy.pap.xacml.rest.handler;
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.api.pap.PDPPolicy;
+import com.att.research.xacml.util.XACMLProperties;
import java.io.File;
import java.io.IOException;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.ResultSet;
import java.sql.SQLException;
-import java.sql.Statement;
import java.util.List;
-
-import javax.persistence.EntityManager;
-import javax.persistence.Query;
+import javax.script.SimpleBindings;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-
import org.onap.policy.common.logging.ONAPLoggingContext;
import org.onap.policy.common.logging.eelf.MessageCodes;
import org.onap.policy.common.logging.eelf.PolicyLogger;
@@ -43,8 +39,8 @@ import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTransaction;
import org.onap.policy.pap.xacml.rest.elk.client.PolicyElasticSearchController;
import org.onap.policy.pap.xacml.rest.model.RemoveGroupPolicy;
import org.onap.policy.pap.xacml.rest.util.JPAUtils;
-import org.onap.policy.rest.XACMLRestProperties;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
+import org.onap.policy.rest.dao.CommonClassDao;
import org.onap.policy.rest.jpa.PolicyEntity;
import org.onap.policy.rest.jpa.PolicyVersion;
import org.onap.policy.utils.PolicyUtils;
@@ -52,13 +48,23 @@ import org.onap.policy.xacml.api.XACMLErrorConstants;
import org.onap.policy.xacml.api.pap.OnapPDPGroup;
import org.onap.policy.xacml.std.pap.StdPAPPolicy;
import org.onap.policy.xacml.std.pap.StdPDPGroup;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
-import com.att.research.xacml.api.pap.PAPException;
-import com.att.research.xacml.api.pap.PDPPolicy;
-import com.att.research.xacml.util.XACMLProperties;
-
+@Component
public class DeleteHandler {
+ private static CommonClassDao commonClassDao;
+
+ @Autowired
+ public DeleteHandler(CommonClassDao commonClassDao) {
+ DeleteHandler.commonClassDao = commonClassDao;
+ }
+
+ public DeleteHandler() {
+ // Default Constructor
+ }
+
private OnapPDPGroup newgroup;
private static Logger logger = FlexLogger.getLogger(DeleteHandler.class);
public static final String POLICY_IN_PDP = "PolicyInPDP";
@@ -88,14 +94,8 @@ public class DeleteHandler {
PolicyEntity policyEntity = null;
JPAUtils jpaUtils = null;
- String papDbDriver = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_DRIVER);
- String papDbUrl = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_URL);
- String papDbUser = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_USER);
- String papDbPassword = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_PASSWORD);
- Connection con = null;
-
try {
- jpaUtils = JPAUtils.getJPAUtilsInstance(XACMLPapServlet.getEmf());
+ jpaUtils = JPAUtils.getJPAUtilsInstance();
} catch (Exception e) {
PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet",
" Could not create JPAUtils instance on the PAP");
@@ -111,8 +111,7 @@ public class DeleteHandler {
response.setStatus(HttpServletResponse.SC_ACCEPTED);
return;
}
- EntityManager em = XACMLPapServlet.getEmf().createEntityManager();
- Query policyEntityQuery = null;
+ String policyEntityQuery = null;
try {
if (policyName.endsWith(".xml")) {
removeXMLExtension = policyName.replace(".xml", "");
@@ -137,8 +136,8 @@ public class DeleteHandler {
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
return;
}
- policyEntityQuery = em.createQuery(
- "SELECT p FROM PolicyEntity p WHERE p.policyName LIKE :pName and p.scope=:pScope");
+ policyEntityQuery =
+ "SELECT p FROM PolicyEntity p WHERE p.policyName LIKE :pName and p.scope=:pScope";
} else if (policy.getDeleteCondition().equalsIgnoreCase("Current Version")) {
if (policyName.contains("Config_")) {
splitPolicyName = policyName.replace(".Config_", ":Config_");
@@ -149,34 +148,30 @@ public class DeleteHandler {
}
split = splitPolicyName.split(":");
queryCheck = false;
- policyEntityQuery = em.createQuery(
- "SELECT p FROM PolicyEntity p WHERE p.policyName=:pName and p.scope=:pScope");
+ policyEntityQuery = "SELECT p FROM PolicyEntity p WHERE p.policyName=:pName and p.scope=:pScope";
}
-
+ SimpleBindings params = new SimpleBindings();
if (queryCheck) {
- policyEntityQuery.setParameter("pName", "%" + split[1] + "%");
+ params.put("pName", "%" + split[1] + "%");
} else {
- policyEntityQuery.setParameter("pName", split[1]);
+ params.put("pName", split[1]);
}
- policyEntityQuery.setParameter("pScope", split[0]);
- List<?> peResult = policyEntityQuery.getResultList();
+ params.put("pScope", split[0]);
+ List<?> peResult = commonClassDao.getDataByQuery(policyEntityQuery, params);
if (!peResult.isEmpty()) {
- Query getPolicyVersion = em.createQuery("Select p from PolicyVersion p where p.policyName=:pname");
- getPolicyVersion.setParameter("pname", removeVersionExtension.replace(".", File.separator));
- List<?> pvResult = getPolicyVersion.getResultList();
+ String getPolicyVersion = "Select p from PolicyVersion p where p.policyName=:pname";
+ SimpleBindings pvParams = new SimpleBindings();
+ pvParams.put("pname", removeVersionExtension.replace(".", File.separator));
+ List<?> pvResult = commonClassDao.getDataByQuery(getPolicyVersion, pvParams);
PolicyVersion pVersion = (PolicyVersion) pvResult.get(0);
int newVersion = 0;
- em.getTransaction().begin();
- Class.forName(papDbDriver);
- con = DriverManager.getConnection(papDbUrl, papDbUser, papDbPassword);
-
if (policy.getDeleteCondition().equalsIgnoreCase("All Versions")) {
- boolean groupCheck = checkPolicyGroupEntity(con, peResult);
+ boolean groupCheck = checkPolicyGroupEntity(peResult);
if (!groupCheck) {
for (Object peData : peResult) {
policyEntity = (PolicyEntity) peData;
- status = deletePolicyEntityData(em, policyEntity);
+ status = deletePolicyEntityData(policyEntity);
}
} else {
status = POLICY_IN_PDP;
@@ -197,7 +192,7 @@ public class DeleteHandler {
default:
try {
policyVersionDeleted = true;
- em.remove(pVersion);
+ commonClassDao.delete(pVersion);
} catch (Exception e) {
logger.error(e.getMessage(), e);
policyVersionDeleted = false;
@@ -205,10 +200,10 @@ public class DeleteHandler {
break;
}
} else if (policy.getDeleteCondition().equalsIgnoreCase("Current Version")) {
- boolean groupCheck = checkPolicyGroupEntity(con, peResult);
+ boolean groupCheck = checkPolicyGroupEntity(peResult);
if (!groupCheck) {
policyEntity = (PolicyEntity) peResult.get(0);
- status = deletePolicyEntityData(em, policyEntity);
+ status = deletePolicyEntityData(policyEntity);
} else {
status = POLICY_IN_PDP;
}
@@ -242,7 +237,7 @@ public class DeleteHandler {
pVersion.setHigherVersion(newVersion);
try {
policyVersionDeleted = true;
- em.persist(pVersion);
+ commonClassDao.save(pVersion);
} catch (Exception e) {
logger.error(e.getMessage(), e);
policyVersionDeleted = false;
@@ -250,7 +245,7 @@ public class DeleteHandler {
} else {
try {
policyVersionDeleted = true;
- em.remove(pVersion);
+ commonClassDao.delete(pVersion);
} catch (Exception e) {
logger.error(e.getMessage(), e);
policyVersionDeleted = false;
@@ -267,18 +262,11 @@ public class DeleteHandler {
return;
}
}
- em.getTransaction().commit();
} catch (Exception e) {
- em.getTransaction().rollback();
PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet", " ERROR");
response.addHeader(ERROR, "deleteDB");
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
return;
- } finally {
- em.close();
- if (con != null) {
- con.close();
- }
}
if (policyVersionDeleted) {
@@ -294,20 +282,20 @@ public class DeleteHandler {
}
}
- public static String deletePolicyEntityData(EntityManager em, PolicyEntity policyEntity) {
+ public static String deletePolicyEntityData(PolicyEntity policyEntity) {
PolicyElasticSearchController controller = new PolicyElasticSearchController();
PolicyRestAdapter policyData = new PolicyRestAdapter();
String policyName = policyEntity.getPolicyName();
try {
- if (policyName.contains("Config_")) {
- em.remove(policyEntity.getConfigurationData());
+ if (policyName.contains("Config_") || policyName.contains("Decision_MS_")) {
+ commonClassDao.delete(policyEntity.getConfigurationData());
} else if (policyName.contains("Action_")) {
- em.remove(policyEntity.getActionBodyEntity());
+ commonClassDao.delete(policyEntity.getActionBodyEntity());
}
String searchPolicyName = policyEntity.getScope() + "." + policyEntity.getPolicyName();
policyData.setNewFileName(searchPolicyName);
controller.deleteElk(policyData);
- em.remove(policyEntity);
+ commonClassDao.delete(policyEntity);
} catch (Exception e) {
logger.error(e.getMessage(), e);
return ERROR;
@@ -315,16 +303,15 @@ public class DeleteHandler {
return "success";
}
- public static boolean checkPolicyGroupEntity(Connection con, List<?> peResult) throws SQLException {
+ public static boolean checkPolicyGroupEntity(List<?> peResult) {
+ String groupEntityquery = "from PolicyGroupEntity where policyid = :policyEntityId";
for (Object peData : peResult) {
PolicyEntity policyEntity = (PolicyEntity) peData;
- try (Statement st = con.createStatement();
- ResultSet rs = st.executeQuery(
- "Select * from PolicyGroupEntity where policyid = '" + policyEntity.getPolicyId() + "'")) {
- boolean gEntityList = rs.next();
- if (gEntityList) {
- return true;
- }
+ SimpleBindings geParams = new SimpleBindings();
+ geParams.put("policyEntityId", policyEntity.getPolicyId());
+ List<Object> groupobject = commonClassDao.getDataByQuery(groupEntityquery, geParams);
+ if (!groupobject.isEmpty()) {
+ return true;
}
}
return false;
@@ -458,7 +445,7 @@ public class DeleteHandler {
// so we need to fill that in before submitting the group for update
((StdPDPGroup) group).setDirectory(((StdPDPGroup) existingGroup).getDirectory());
try {
- acPutTransaction.updateGroup(group, "XACMLPapServlet.doDelete");
+ acPutTransaction.updateGroup(group, "XACMLPapServlet.doDelete", null);
} catch (Exception e) {
PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet",
" Error while updating group in the database: "
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandler.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandler.java
index 4dd87e22f..ed1c57369 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandler.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandler.java
@@ -2,14 +2,14 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017,2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,68 +17,69 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
+
package org.onap.policy.pap.xacml.rest.handler;
+import com.att.research.xacml.util.XACMLProperties;
import java.io.File;
import java.net.URI;
import java.util.List;
-
-import javax.persistence.EntityManager;
-import javax.persistence.Query;
+import javax.script.SimpleBindings;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-
-import org.onap.policy.common.logging.eelf.MessageCodes;
import org.onap.policy.common.logging.eelf.PolicyLogger;
-import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.rest.dao.CommonClassDao;
import org.onap.policy.rest.jpa.PolicyVersion;
import org.onap.policy.xacml.api.pap.OnapPDPGroup;
import org.onap.policy.xacml.std.pap.StdPDPPolicy;
-import org.onap.policy.common.logging.flexlogger.FlexLogger;
-import org.onap.policy.common.logging.flexlogger.Logger;
-import com.att.research.xacml.util.XACMLProperties;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+@Component
public class PushPolicyHandler {
private static final Logger logger = FlexLogger.getLogger(PushPolicyHandler.class);
+
+ private static CommonClassDao commonClassDao;
+
+ @Autowired
+ public PushPolicyHandler(CommonClassDao commonClassDao) {
+ PushPolicyHandler.commonClassDao = commonClassDao;
+ }
+
+ public PushPolicyHandler() {
+ // Default Constructor
+ }
+
/*
* Get Active Version.
*/
public void getActiveVersion(HttpServletRequest request, HttpServletResponse response) {
- EntityManager em = null;
- if(XACMLPapServlet.getEmf()!=null){
- em = (EntityManager) XACMLPapServlet.getEmf().createEntityManager();
- }
- if (em==null){
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Error creating entity manager with persistence unit: " + XACMLPapServlet.getPersistenceUnit());
- return;
- }
- String policyScope = request.getParameter("policyScope");
+ String policyScope = request.getParameter("policyScope").replace(".", File.separator);
String filePrefix = request.getParameter("filePrefix");
String policyName = request.getParameter("policyName");
String pvName = policyScope + File.separator + filePrefix + policyName;
int activeVersion = 0;
- //Get the Active Version to use in the ID
- em.getTransaction().begin();
- Query query = em.createQuery("Select p from PolicyVersion p where p.policyName=:pname");
- query.setParameter("pname", pvName);
+ // Get the Active Version to use in the ID
+ String query = "Select p from PolicyVersion p where p.policyName=:pname";
+ SimpleBindings params = new SimpleBindings();
+ params.put("pname", pvName);
@SuppressWarnings("rawtypes")
- List result = query.getResultList();
+ List result = commonClassDao.getDataByQuery(query, params);
PolicyVersion versionEntity = null;
if (!result.isEmpty()) {
versionEntity = (PolicyVersion) result.get(0);
- em.persist(versionEntity);
+ commonClassDao.save(versionEntity);
activeVersion = versionEntity.getActiveVersion();
- em.getTransaction().commit();
} else {
PolicyLogger.debug("No PolicyVersion using policyName found");
}
- //clean up connection
- em.close();
- if (String.valueOf(activeVersion)!=null || !String.valueOf(activeVersion).equalsIgnoreCase("")) {
+ if (String.valueOf(activeVersion) != null || !String.valueOf(activeVersion).equalsIgnoreCase("")) {
response.setStatus(HttpServletResponse.SC_OK);
response.addHeader("version", String.valueOf(activeVersion));
} else {
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/SavePolicyHandler.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/SavePolicyHandler.java
index 2da84d754..90f8b5a70 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/SavePolicyHandler.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/SavePolicyHandler.java
@@ -2,14 +2,14 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,28 +17,25 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
+
package org.onap.policy.pap.xacml.rest.handler;
+import com.att.research.xacml.util.XACMLProperties;
import java.io.IOException;
import java.util.HashMap;
-
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.parsers.ParserConfigurationException;
-
import org.onap.policy.common.logging.eelf.PolicyLogger;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
-import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
import org.onap.policy.utils.PolicyUtils;
import org.onap.policy.xacml.std.pap.StdPAPPolicy;
import org.xml.sax.SAXException;
-import com.att.research.xacml.util.XACMLProperties;
-
public class SavePolicyHandler {
private static final Logger logger = FlexLogger.getLogger(SavePolicyHandler.class);
private HashMap<String, String> ErrorHeaders = null;
@@ -76,7 +73,7 @@ public class SavePolicyHandler {
try {
PolicyLogger.info("SavePolicyHandler: Setting parameter values to PolicyAdapter");
policyAdapter = setDataToPolicyAdapter(policy, policyType, apiflag);
-
+
if(!extendedPolicyOptions(policyAdapter, response)){
creation.savePolicy(policyAdapter, response);
}
@@ -106,7 +103,6 @@ public class SavePolicyHandler {
policyAdapter.setPolicyType(policyType);
policyAdapter.setDynamicFieldConfigAttributes(policy.getDynamicFieldConfigAttributes());
policyAdapter.setEditPolicy(policy.isEditPolicy());
- policyAdapter.setEntityManagerFactory(XACMLPapServlet.getEmf());
//Config Specific
policyAdapter.setConfigName(policy.getConfigName()); //Base and Firewall
policyAdapter.setConfigBodyData(policy.getConfigBodyData()); //Base
@@ -139,7 +135,7 @@ public class SavePolicyHandler {
policyAdapter.setDomainDir(policyAdapter.getPolicyScope());
policyAdapter.setRainydayMap(policy.getTreatments());
policyAdapter.setRawXacmlPolicy(policy.getRawXacmlPolicy());
-
+
return policyAdapter;
}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/PolicyCreation.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/PolicyCreation.java
index de5d1cf49..d8a77269c 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/PolicyCreation.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/PolicyCreation.java
@@ -2,14 +2,14 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,8 +17,10 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
+
package org.onap.policy.pap.xacml.rest.policycontroller;
+import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.util.Date;
import java.util.HashMap;
@@ -26,15 +28,12 @@ import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
-
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-
import org.apache.commons.lang.StringUtils;
import org.onap.policy.common.logging.eelf.PolicyLogger;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
-import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
import org.onap.policy.pap.xacml.rest.components.ActionPolicy;
import org.onap.policy.pap.xacml.rest.components.ClosedLoopPolicy;
import org.onap.policy.pap.xacml.rest.components.ConfigPolicy;
@@ -69,8 +68,6 @@ import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
-import com.fasterxml.jackson.databind.ObjectMapper;
-
@RestController
@RequestMapping("/")
@@ -470,7 +467,7 @@ public class PolicyCreation extends AbstractPolicyCreation{
policyData.setErrorCodeList(errorCodeList);
policyData.setTreatmentList(treatmentList);
}
- newPolicy = new DecisionPolicy(policyData, commonClassDao);
+ newPolicy = new DecisionPolicy(policyData);
}
if(newPolicy != null){
@@ -485,7 +482,7 @@ public class PolicyCreation extends AbstractPolicyCreation{
PolicyDBDaoTransaction policyDBDaoTransaction = null;
try{
- policyDBDao = PolicyDBDao.getPolicyDBDaoInstance(XACMLPapServlet.getEmf());
+ policyDBDao = PolicyDBDao.getPolicyDBDaoInstance();
policyDBDaoTransaction = policyDBDao.getNewTransaction();
policyDBDaoTransaction.createPolicy(newPolicy, policyData.getUserId());
successMap = newPolicy.savePolicies();
@@ -521,7 +518,7 @@ public class PolicyCreation extends AbstractPolicyCreation{
} else {
PolicyLogger.info("SafetyCheckerResponse was empty or null.");
}
-
+
}else if (successMap.containsKey("invalidAttribute")) {
String message = XACMLErrorConstants.ERROR_DATA_ISSUE + "Invalid Action Attribute";
LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Could not fine " + policyData.getActionAttribute() + " in the ActionPolicyDict table.");
@@ -551,7 +548,7 @@ public class PolicyCreation extends AbstractPolicyCreation{
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
response.addHeader("error", message);
response.addHeader("policyName", policyData.getPolicyName());
- }else {
+ }else {
policyDBDaoTransaction.rollbackTransaction();
body = "error";
status = HttpStatus.INTERNAL_SERVER_ERROR;
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/MetricService.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/MetricService.java
index 66fb9acfc..0a539dcbb 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/MetricService.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/MetricService.java
@@ -2,7 +2,7 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017,2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -17,37 +17,46 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
+
package org.onap.policy.pap.xacml.rest.service;
+import com.att.research.xacml.api.pap.PDPPolicy;
import java.util.HashSet;
+import java.util.List;
import java.util.Set;
-
-import javax.persistence.EntityManager;
import javax.servlet.http.HttpServletResponse;
-
import org.json.JSONObject;
import org.onap.policy.common.logging.eelf.MessageCodes;
import org.onap.policy.common.logging.eelf.PolicyLogger;
import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
+import org.onap.policy.rest.dao.CommonClassDao;
+import org.onap.policy.rest.jpa.PolicyVersion;
import org.onap.policy.xacml.api.XACMLErrorConstants;
import org.onap.policy.xacml.api.pap.OnapPDPGroup;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
-import com.att.research.xacml.api.pap.PDPPolicy;
-
+@Component
public class MetricService {
private static String errorMsg = "error";
+ private static CommonClassDao commonClassDao;
/*
* This is a private constructor
- * */
+ */
private MetricService() {
}
+ @Autowired
+ private MetricService(CommonClassDao commonClassDao) {
+ MetricService.commonClassDao = commonClassDao;
+ }
+
public static void doGetPolicyMetrics(HttpServletResponse response) {
Set<OnapPDPGroup> groups = new HashSet<>();
try {
- //get the count of policies on the PDP
+ // get the count of policies on the PDP
if (XACMLPapServlet.getPAPEngine() != null) {
groups = XACMLPapServlet.getPAPEngine().getOnapPDPGroups();
}
@@ -56,47 +65,36 @@ public class MetricService {
Set<PDPPolicy> policies = group.getPolicies();
pdpCount += policies.size();
}
- //get the count of policies on the PAP
- EntityManager em = null;
- if (XACMLPapServlet.getEmf() != null) {
- em = XACMLPapServlet.getEmf().createEntityManager();
- }
- if (em == null) {
- PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE +
- " Error creating entity manager with persistence unit: " +
- XACMLPapServlet.getPersistenceUnit());
- response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
- response.addHeader(errorMsg, "Error creating entity manager with persistence unit");
- return;
- }
- int papCount = ((Number) em.createNamedQuery("PolicyVersion.findAllCount").getSingleResult()).intValue();
- em.close();
+ // get the count of policies on the PAP
+ List<Object> dataList = commonClassDao.getData(PolicyVersion.class);
+ int papCount = dataList.size();
int totalCount = pdpCount + papCount;
- //create json string for API response
+ // create json string for API response
JSONObject json = new JSONObject();
json.put("papCount", papCount);
json.put("pdpCount", pdpCount);
json.put("totalCount", totalCount);
if (pdpCount > 0 && papCount > 0 && totalCount > 0) {
- PolicyLogger
- .info("Metrics have been found on the Policy Engine for the number of policies on the PAP and" +
- " PDP.");
+ PolicyLogger.info(
+ "Metrics have been found on the Policy Engine for the number of policies on the PAP and PDP.");
response.setStatus(HttpServletResponse.SC_OK);
response.addHeader("successMapKey", "success");
response.addHeader("operation", "getMetrics");
response.addHeader("metrics", json.toString());
+ return;
} else {
String message =
- "The policy count on the PAP and PDP is 0. Please check the database and file system to " +
- "correct this error.";
+ "The policy count on the PAP and PDP is 0. Please check the database and file system to correct this error.";
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
response.addHeader(errorMsg, message);
+ return;
}
} catch (Exception e) {
String message = XACMLErrorConstants.ERROR_DATA_ISSUE + " Error Querying the Database: " + e.getMessage();
PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "XACMLPapServlet", " Error Querying the Database.");
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
response.addHeader(errorMsg, message);
+ return;
}
}
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JPAUtils.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JPAUtils.java
index b9880d8ac..cb9abb9db 100644
--- a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JPAUtils.java
+++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JPAUtils.java
@@ -2,14 +2,14 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,50 +20,52 @@
package org.onap.policy.pap.xacml.rest.util;
-import javax.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
-import javax.persistence.Query;
-
+import java.util.List;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
import org.onap.policy.rest.XacmlAdminAuthorization;
+import org.onap.policy.rest.dao.CommonClassDao;
import org.onap.policy.rest.jpa.GlobalRoleSettings;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
-import org.onap.policy.common.logging.flexlogger.FlexLogger;
-import org.onap.policy.common.logging.flexlogger.Logger;
-
+@Component
public class JPAUtils {
- private static final Logger LOGGER = FlexLogger.getLogger(JPAUtils.class);
+ private static final Logger LOGGER = FlexLogger.getLogger(JPAUtils.class);
- private static EntityManagerFactory emf;
+ private static CommonClassDao commonClassDao;
private static JPAUtils currentInstance = null;
+ @Autowired
+ public JPAUtils(CommonClassDao commonClassDao) {
+ JPAUtils.commonClassDao = commonClassDao;
+ }
+
/**
- * Get an instance of a JPAUtils. It creates one if it does not exist.
- * Only one instance is allowed to be created per server.
+ * Get an instance of a JPAUtils. It creates one if it does not exist. Only one instance is allowed
+ * to be created per server.
+ *
* @param emf The EntityFactoryManager to be used for database connections
* @return The new instance of JPAUtils or throw exception if the given emf is null.
- * @throws IllegalStateException if a JPAUtils has already been constructed. Call getJPAUtilsInstance() to get this.
+ * @throws IllegalStateException if a JPAUtils has already been constructed. Call
+ * getJPAUtilsInstance() to get this.
*/
- public static JPAUtils getJPAUtilsInstance(EntityManagerFactory emf){
- LOGGER.debug("getJPAUtilsInstance(EntityManagerFactory emf) as getJPAUtilsInstance("+emf+") called");
- if(currentInstance == null){
- if(emf != null){
- currentInstance = new JPAUtils(emf);
- return currentInstance;
- }
- throw new IllegalStateException("The EntityManagerFactory is Null");
+ public static JPAUtils getJPAUtilsInstance() {
+ if (currentInstance == null) {
+ currentInstance = new JPAUtils();
+ return currentInstance;
}
return currentInstance;
}
- private JPAUtils(EntityManagerFactory emf){
- LOGGER.debug("JPAUtils(EntityManagerFactory emf) as JPAUtils("+emf+") called");
- JPAUtils.emf = emf;
+ private JPAUtils() {
+ // Default Constructor
}
/**
- * Returns the lockdown value, in case of exception it is assumed that lockdown functionality
- * is not supported and returns false.
+ * Returns the lockdown value, in case of exception it is assumed that lockdown functionality is not
+ * supported and returns false.
*
*
* @throws ReadOnlyException
@@ -88,15 +90,16 @@ public class JPAUtils {
* @throws ReadOnlyException
* @throws ConversionException
*/
- public boolean dbLockdown()
- throws IllegalAccessException {
+ public boolean dbLockdown() throws IllegalAccessException {
if (LOGGER.isTraceEnabled())
LOGGER.trace("ENTER");
+ List<Object> data = commonClassDao.getData(GlobalRoleSettings.class);
- EntityManager em = emf.createEntityManager();
- Query globalRoleSettingsJPA = em.createNamedQuery("GlobalRoleSettings.findAll");
+ GlobalRoleSettings globalRoleSettings = null;
- GlobalRoleSettings globalRoleSettings = (GlobalRoleSettings) globalRoleSettingsJPA.getSingleResult();
+ if (!data.isEmpty()) {
+ globalRoleSettings = (GlobalRoleSettings) data.get(0);
+ }
if (globalRoleSettings == null) {
// this should not happen
diff --git a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/test/XACMLPAPTest.java b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/test/XACMLPAPTest.java
index 00553e0ee..6a3a9dc8d 100644
--- a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/test/XACMLPAPTest.java
+++ b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/test/XACMLPAPTest.java
@@ -2,7 +2,7 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
* Modifications Copyright (C) 2018 Samsung Electronics Co., Ltd.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,7 +24,7 @@ package org.onap.policy.pap.test;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.when;
-
+import com.mockrunner.mock.web.MockServletInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
@@ -35,27 +35,23 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
-
-import javax.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
-import javax.persistence.EntityTransaction;
-import javax.persistence.Persistence;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
import org.hibernate.SessionFactory;
-import org.junit.After;
+import org.junit.AfterClass;
import org.junit.Before;
+import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mockito;
-import org.onap.policy.common.ia.IntegrityAuditProperties;
import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
+import org.onap.policy.pap.xacml.rest.components.FirewallConfigPolicy;
+import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTest;
import org.onap.policy.pap.xacml.rest.controller.ActionPolicyDictionaryController;
import org.onap.policy.pap.xacml.rest.controller.ClosedLoopDictionaryController;
import org.onap.policy.pap.xacml.rest.controller.DecisionPolicyDictionaryController;
@@ -80,70 +76,33 @@ import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.mock.web.MockServletConfig;
import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
-import com.mockrunner.mock.web.MockServletInputStream;
public class XACMLPAPTest {
private static final Log logger = LogFactory.getLog(XACMLPAPTest.class);
private static final String ENVIRONMENT_HEADER = "Environment";
- private List<String> headers = new ArrayList<>();
+ private static List<String> headers = new ArrayList<>();
private HttpServletRequest httpServletRequest;
private HttpServletResponse httpServletResponse;
private ServletOutputStream mockOutput;
- private ServletConfig servletConfig;
- private XACMLPapServlet pap;
- private SessionFactory sessionFactory;
- private CommonClassDao commonClassDao;
+ private static ServletConfig servletConfig;
+ private static XACMLPapServlet pap;
+ private static SessionFactory sessionFactory;
+ private static CommonClassDao commonClassDao;
private static final String DEFAULT_DB_DRIVER = "org.h2.Driver";
private static final String DEFAULT_DB_USER = "sa";
private static final String DEFAULT_DB_PWD = "";
- @Before
- public void setUpDB() throws Exception {
- logger.info("setUpDB: Entering");
-
- Properties properties = new Properties();
- properties.put(IntegrityAuditProperties.DB_DRIVER, XACMLPAPTest.DEFAULT_DB_DRIVER);
- properties.put(IntegrityAuditProperties.DB_URL, "jdbc:h2:file:./sql/xacmlTest");
- properties.put(IntegrityAuditProperties.DB_USER, XACMLPAPTest.DEFAULT_DB_USER);
- properties.put(IntegrityAuditProperties.DB_PWD, XACMLPAPTest.DEFAULT_DB_PWD);
- properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
- properties.put(IntegrityAuditProperties.NODE_TYPE, "pap");
-
- //Clean the iaTest DB table for IntegrityAuditEntity entries
- cleanDb("testPapPU", properties);
-
- logger.info("setUpDB: Exiting");
- }
-
- public void cleanDb(String persistenceUnit, Properties properties) {
- logger.debug("cleanDb: enter");
-
- EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
-
- EntityManager em = emf.createEntityManager();
- // Start a transaction
- EntityTransaction et = em.getTransaction();
-
- et.begin();
-
- // Clean up the DB
- em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
-
- // commit transaction
- et.commit();
- em.close();
- logger.debug("cleanDb: exit");
+ @BeforeClass
+ public static void beforeClassSetup() throws ServletException {
+ sessionFactory = PolicyDBDaoTest.setupH2DbDaoImpl("xacmlpaptest");
+ new FirewallConfigPolicy(new CommonClassDaoImpl());
+ new DictionaryUtils(new CommonClassDaoImpl());
+ setUp();
}
- @Before
- public void setUp() throws ServletException {
- httpServletRequest = Mockito.mock(HttpServletRequest.class);
- httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- Mockito.when(httpServletRequest.getHeaderNames()).thenReturn(Collections.enumeration(headers));
- Mockito.when(httpServletRequest.getAttributeNames()).thenReturn(Collections.enumeration(headers));
-
+ public static void setUp() throws ServletException {
servletConfig = Mockito.mock(MockServletConfig.class);
System.setProperty("com.sun.management.jmxremote.port", "9993");
Mockito.when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
@@ -154,59 +113,56 @@ public class XACMLPAPTest {
commonClassDao = Mockito.mock(CommonClassDao.class);
new DictionaryUtils(commonClassDao);
DictionaryUtils.setDictionaryUtils(new DictionaryUtils());
+ UserInfo user = new UserInfo();
+ user.setUserLoginId("API");
+ user.setUserName("API");
+ Mockito.when(commonClassDao.getEntityItem(UserInfo.class, "userLoginId", "API")).thenReturn(user);
Mockito.mock(DictionaryUtils.class);
}
+ @Before
+ public void testInit() {
+ httpServletRequest = Mockito.mock(HttpServletRequest.class);
+ httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
+ Mockito.when(httpServletRequest.getHeaderNames()).thenReturn(Collections.enumeration(headers));
+ Mockito.when(httpServletRequest.getAttributeNames()).thenReturn(Collections.enumeration(headers));
+ CommonClassDaoImpl.setSessionfactory(sessionFactory);
+ PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
+ }
+
@Test
public void testFirwallCreatePolicy() throws IOException, ServletException, SQLException {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
- String json =
- "{\"serviceTypeId\":\"/v0/firewall/pan\",\"configName\":\"TestFwPolicyConfig\"," +
- "\"deploymentOption\":{\"deployNow\":false},\"securityZoneId\":\"cloudsite:dev1a\"," +
- "\"serviceGroups\":[{\"name\":\"SSH\",\"description\":\"Sshservice entry in servicelist\"," +
- "\"type\":\"SERVICE\",\"transportProtocol\":\"tcp\",\"appProtocol\":null,\"ports\":\"22\"}]," +
- "\"addressGroups\":[{\"name\":\"test\",\"description\":\"Destination\"," +
- "\"members\":[{\"type\":\"SUBNET\",\"value\":\"127.0.0.1/12\"}]},{\"name\":\"TestServers\"," +
- "\"description\":\"SourceTestServers for firsttesting\",\"members\":[{\"type\":\"SUBNET\"," +
- "\"value\":\"127.0.0.1/23\"}]}],\"firewallRuleList\":[{\"position\":\"1\"," +
- "\"ruleName\":\"FWRuleTestServerToTest\",\"fromZones\":[\"UntrustedZoneTestName\"]," +
- "\"toZones\":[\"TrustedZoneTestName\"],\"negateSource\":false,\"negateDestination\":false," +
- "\"sourceList\":[{\"type\":\"REFERENCE\",\"name\":\"TestServers\"}]," +
- "\"destinationList\":[{\"type\":\"REFERENCE\",\"name\":\"Test\"}],\"sourceServices\":[]," +
- "\"destServices\":[{\"type\":\"REFERENCE\",\"name\":\"SSH\"}],\"action\":\"accept\"," +
- "\"description\":\"FWrule for Test source to Test destination\",\"enabled\":true," +
- "\"log\":true}]}";
+ String json = "{\"serviceTypeId\":\"/v0/firewall/pan\",\"configName\":\"TestFwPolicyConfig\","
+ + "\"deploymentOption\":{\"deployNow\":false},\"securityZoneId\":\"cloudsite:dev1a\","
+ + "\"serviceGroups\":[{\"name\":\"SSH\",\"description\":\"Sshservice entry in servicelist\","
+ + "\"type\":\"SERVICE\",\"transportProtocol\":\"tcp\",\"appProtocol\":null,\"ports\":\"22\"}],"
+ + "\"addressGroups\":[{\"name\":\"test\",\"description\":\"Destination\","
+ + "\"members\":[{\"type\":\"SUBNET\",\"value\":\"127.0.0.1/12\"}]},{\"name\":\"TestServers\","
+ + "\"description\":\"SourceTestServers for firsttesting\",\"members\":[{\"type\":\"SUBNET\","
+ + "\"value\":\"127.0.0.1/23\"}]}],\"firewallRuleList\":[{\"position\":\"1\","
+ + "\"ruleName\":\"FWRuleTestServerToTest\",\"fromZones\":[\"UntrustedZoneTestName\"],"
+ + "\"toZones\":[\"TrustedZoneTestName\"],\"negateSource\":false,\"negateDestination\":false,"
+ + "\"sourceList\":[{\"type\":\"REFERENCE\",\"name\":\"TestServers\"}],"
+ + "\"destinationList\":[{\"type\":\"REFERENCE\",\"name\":\"Test\"}],\"sourceServices\":[],"
+ + "\"destServices\":[{\"type\":\"REFERENCE\",\"name\":\"SSH\"}],\"action\":\"accept\","
+ + "\"description\":\"FWrule for Test source to Test destination\",\"enabled\":true,"
+ + "\"log\":true}]}";
Mockito.when(httpServletRequest.getHeader(ENVIRONMENT_HEADER)).thenReturn("DEVL");
Mockito.when(httpServletRequest.getMethod()).thenReturn("PUT");
Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
- StdPAPPolicy newPAPPolicy =
- new StdPAPPolicy(StdPAPPolicyParams.builder()
- .configPolicyType("Firewall Config")
- .policyName("test")
- .description("testDescription")
- .configName("Test")
- .editPolicy(false)
- .domain("test")
- .jsonBody(json)
- .highestVersion(0)
- .riskLevel("5")
- .riskType("default")
- .guard("false")
- .ttlDate("")
- .build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("Firewall Config")
+ .policyName("test").description("testDescription").configName("Test").editPolicy(false).domain("test")
+ .jsonBody(json).highestVersion(0).riskLevel("5").riskType("default").guard("false").ttlDate("")
+ .build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Config_FW_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
@@ -222,38 +178,19 @@ public class XACMLPAPTest {
ruleAttributes.put("templateName", "testPolicy");
ruleAttributes.put("samPoll", "5");
ruleAttributes.put("value", "test");
- //Creating BRMS Param Policies from the Admin Console
- StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder()
- .configPolicyType("BRMS_Param")
- .policyName("test")
- .description("testing")
- .configName("BRMS_PARAM_RULE")
- .editPolicy(false)
- .domain("test")
- .dynamicFieldConfigAttributes(matchingAttributes)
- .highestVersion(0)
- .onapName("DROOLS")
- .configBodyData(null)
- .drlRuleAndUIParams(ruleAttributes)
- .riskLevel("5")
- .riskType("default")
- .guard("false")
- .ttlDate("")
- .brmsController(null)
- .brmsDependency(null)
- .build());
+ // Creating BRMS Param Policies from the Admin Console
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("BRMS_Param")
+ .policyName("test").description("testing").configName("BRMS_PARAM_RULE").editPolicy(false)
+ .domain("test").dynamicFieldConfigAttributes(matchingAttributes).highestVersion(0).onapName("DROOLS")
+ .configBodyData(null).drlRuleAndUIParams(ruleAttributes).riskLevel("5").riskType("default")
+ .guard("false").ttlDate("").brmsController(null).brmsDependency(null).build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
setPolicyCreation();
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Config_BRMS_Param_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
@@ -266,33 +203,17 @@ public class XACMLPAPTest {
Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
Map<String, String> ruleAttributes = new HashMap<>();
ruleAttributes.put("value", "test");
- StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder()
- .configPolicyType("BRMS_Raw")
- .policyName("test")
- .description("testig description")
- .configName("BRMS_RAW_RULE")
- .editPolicy(false)
- .domain("test")
- .dynamicFieldConfigAttributes(ruleAttributes)
- .highestVersion(0)
- .onapName("DROOLS")
- .configBodyData("test")
- .riskLevel("4")
- .riskType("default")
- .guard("false")
- .build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("BRMS_Raw")
+ .policyName("test").description("testig description").configName("BRMS_RAW_RULE").editPolicy(false)
+ .domain("test").dynamicFieldConfigAttributes(ruleAttributes).highestVersion(0).onapName("DROOLS")
+ .configBodyData("test").riskLevel("4").riskType("default").guard("false").build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
setPolicyCreation();
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Config_BRMS_Raw_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
@@ -304,36 +225,18 @@ public class XACMLPAPTest {
Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
String json = "{\"test\":\"java\"}";
- //Creating CloseLoop_Fault and Performance Metric Policies
- StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder()
- .configPolicyType("ClosedLoop_PM")
- .policyName("test")
- .description("testing")
- .onapName("onap")
- .jsonBody(json)
- .draft(false)
- .oldPolicyFileName(null)
- .serviceType("Registration Failure(Trinity)")
- .editPolicy(false)
- .domain("test")
- .highestVersion(0)
- .riskLevel(null)
- .riskType("default")
- .guard("true")
- .ttlDate("")
- .build());
+ // Creating CloseLoop_Fault and Performance Metric Policies
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder().configPolicyType("ClosedLoop_PM")
+ .policyName("test").description("testing").onapName("onap").jsonBody(json).draft(false)
+ .oldPolicyFileName(null).serviceType("Registration Failure(Trinity)").editPolicy(false).domain("test")
+ .highestVersion(0).riskLevel(null).riskType("default").guard("true").ttlDate("").build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
setPolicyCreation();
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Config_PM_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
@@ -344,26 +247,15 @@ public class XACMLPAPTest {
Mockito.when(httpServletRequest.getParameter("apiflag")).thenReturn("api");
Mockito.when(httpServletRequest.getParameter("operation")).thenReturn("create");
Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Decision");
- StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder()
- .policyName("test")
- .description("test rule")
- .onapName("ONAP")
- .providerComboBox("AAF")
- .editPolicy(false)
- .domain("test")
- .highestVersion(0)
- .build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
+ StdPAPPolicyParams.builder().policyName("test").description("test rule").onapName("ONAP")
+ .providerComboBox("AAF").editPolicy(false).domain("test").highestVersion(0).build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Decision_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
@@ -384,31 +276,18 @@ public class XACMLPAPTest {
matchingAttributes.put("timeUnits", "minute");
matchingAttributes.put("guardActiveStart", "05:00");
matchingAttributes.put("guardActiveEnd", "10:00");
- StdPAPPolicy newPAPPolicy =
-
- new StdPAPPolicy(StdPAPPolicyParams.builder()
- .policyName("testGuard")
- .description("test rule")
- .onapName("PDPD")
- .providerComboBox("GUARD_YAML")
- .dynamicFieldConfigAttributes(matchingAttributes)
- .editPolicy(false)
- .domain("test")
- .highestVersion(0)
- .build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
+ StdPAPPolicyParams.builder().policyName("testGuard").description("test rule").onapName("PDPD")
+ .providerComboBox("GUARD_YAML").dynamicFieldConfigAttributes(matchingAttributes)
+ .editPolicy(false).domain("test").highestVersion(0).build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Decision_testGuard.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
-
+
@Test
public void testDecisonGuardMinMaxPolicy() throws IOException, ServletException, SQLException {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
@@ -429,20 +308,15 @@ public class XACMLPAPTest {
StdPAPPolicy newPAPPolicy =
new StdPAPPolicy(
- StdPAPPolicyParams.builder().policyName("testGuard").description("test rule").onapName("PDPD")
+ StdPAPPolicyParams.builder().policyName("testGuardMinMax").description("test rule").onapName("PDPD")
.providerComboBox("GUARD_MIN_MAX").dynamicFieldConfigAttributes(matchingAttributes)
.editPolicy(false).domain("test").highestVersion(0).build());
- MockServletInputStream mockInput = new MockServletInputStream(
- PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
+ MockServletInputStream mockInput =
+ new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Decision_testGuard.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@@ -461,28 +335,16 @@ public class XACMLPAPTest {
matchingAttributes.put("guardActiveStart", "05:00");
matchingAttributes.put("guardActiveEnd", "10:00");
matchingAttributes.put("blackList", "bl1,bl2");
- StdPAPPolicy newPAPPolicy =
- new StdPAPPolicy(StdPAPPolicyParams.builder()
- .policyName("testblGuard")
- .description("test rule")
- .onapName("PDPD")
- .providerComboBox("GUARD_BL_YAML")
- .dynamicFieldConfigAttributes(matchingAttributes)
- .editPolicy(false)
- .domain("test")
- .highestVersion(0)
- .build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
+ StdPAPPolicyParams.builder().policyName("testblGuard").description("test rule").onapName("PDPD")
+ .providerComboBox("GUARD_BL_YAML").dynamicFieldConfigAttributes(matchingAttributes)
+ .editPolicy(false).domain("test").highestVersion(0).build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Decision_testblGuard.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
@Test
@@ -495,33 +357,17 @@ public class XACMLPAPTest {
Mockito.when(httpServletRequest.getParameter("policyType")).thenReturn("Config");
Map<String, String> configAttributes = new HashMap<>();
configAttributes.put("value", "test");
- StdPAPPolicy newPAPPolicy = new StdPAPPolicy(StdPAPPolicyParams.builder()
- .configPolicyType("Base")
- .policyName("test")
- .description("test rule")
- .onapName("TEST")
- .configName("config")
- .dynamicFieldConfigAttributes(configAttributes)
- .configType("OTHER")
- .configBodyData("test body")
- .editPolicy(false)
- .domain("test")
- .highestVersion(0)
- .riskLevel("5")
- .riskType("default")
- .guard("false")
- .ttlDate(null).build());
+ StdPAPPolicy newPAPPolicy = new StdPAPPolicy(
+ StdPAPPolicyParams.builder().configPolicyType("Base").policyName("test").description("test rule")
+ .onapName("TEST").configName("config").dynamicFieldConfigAttributes(configAttributes)
+ .configType("OTHER").configBodyData("test body").editPolicy(false).domain("test")
+ .highestVersion(0).riskLevel("5").riskType("default").guard("false").ttlDate(null).build());
MockServletInputStream mockInput =
new MockServletInputStream(PolicyUtils.objectToJsonString(newPAPPolicy).getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
- // set DBDao
- setDBDao();
pap.service(httpServletRequest, httpServletResponse);
-
- Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
- Mockito.verify(httpServletResponse).addHeader("successMapKey", "success");
- Mockito.verify(httpServletResponse).addHeader("policyName", "test.Config_test.1.xml");
+ Mockito.verify(httpServletResponse).addHeader("operation", "create");
}
private void setPolicyCreation() {
@@ -539,30 +385,14 @@ public class XACMLPAPTest {
BRMSParamTemplate template = new BRMSParamTemplate();
template.setRuleName("testPolicy");
template.setUserCreatedBy(userInfo);
- String rule = "package com.sample;\n"
- + "import com.sample.DroolsTest.Message;\n"
- + "declare Params\n"
- + "samPoll : int\n"
- + "value : String\n"
- + "end\n"
- + "///This Rule will be generated by the UI.\n"
- + "rule \"${policyName}.Create parameters structure\"\n"
- + "salience 1000 \n"
- + "when\n"
- + "then\n"
- + "Params params = new Params();\n"
- + "params.setSamPoll(76);\n"
- + "params.setValue(\"test\");\n"
- + "insertLogical(params);\n"
- + "end\n"
- + "rule \"Rule 1: Check parameter structure access from when/then\"\n"
- + "when\n"
- + "$param: Params()\n"
- + "Params($param.samPoll > 50)\n"
- + "then\n"
- + "System.out.println(\"Firing rule 1\");\n"
- + "System.out.println($param);\n"
- + "end\n";
+ String rule = "package com.sample;\n" + "import com.sample.DroolsTest.Message;\n" + "declare Params\n"
+ + "samPoll : int\n" + "value : String\n" + "end\n" + "///This Rule will be generated by the UI.\n"
+ + "rule \"${policyName}.Create parameters structure\"\n" + "salience 1000 \n" + "when\n" + "then\n"
+ + "Params params = new Params();\n" + "params.setSamPoll(76);\n" + "params.setValue(\"test\");\n"
+ + "insertLogical(params);\n" + "end\n"
+ + "rule \"Rule 1: Check parameter structure access from when/then\"\n" + "when\n" + "$param: Params()\n"
+ + "Params($param.samPoll > 50)\n" + "then\n" + "System.out.println(\"Firing rule 1\");\n"
+ + "System.out.println($param);\n" + "end\n";
template.setRule(rule);
Mockito.when(commonClassDao.getEntityItem(BRMSParamTemplate.class, "ruleName", "testPolicy"))
.thenReturn(template);
@@ -572,14 +402,14 @@ public class XACMLPAPTest {
@Test
public void testClosedLoopCreateDictionary() throws IOException, SQLException, ServletException {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
- // Check VSCLAction.
+ // Check VSCLAction.
String json = "{\"dictionaryFields\": {\"vsclaction\": \"testRestAPI\",\"description\": \"testing create\"}}";
dictionaryTestSetup(false, "VSCLAction", json);
// set DBDao
ClosedLoopDictionaryController.setCommonClassDao(new CommonClassDaoImpl());
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
// Check VNFType
@@ -590,34 +420,32 @@ public class XACMLPAPTest {
dictionaryTestSetup(false, "VNFType", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
// Check PEPOptions
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"pepName\":\"testRestAPI\",\"description\":\"testing create\"," +
- "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\"," +
- "\"number\":\"test\"}]}}";
+ json = "{\"dictionaryFields\":{\"pepName\":\"testRestAPI\",\"description\":\"testing create\","
+ + "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
+ + "\"number\":\"test\"}]}}";
dictionaryTestSetup(false, "PEPOptions", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
// Check Varbind
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"varbindName\":\"testRestAPI\",\"varbindDescription\":\"testing\"," +
- "\"varbindOID\":\"test\"}}";
+ json = "{\"dictionaryFields\":{\"varbindName\":\"testRestAPI\",\"varbindDescription\":\"testing\","
+ + "\"varbindOID\":\"test\"}}";
dictionaryTestSetup(false, "Varbind", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
// Check Service
@@ -628,7 +456,7 @@ public class XACMLPAPTest {
dictionaryTestSetup(false, "Service", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
// Check Site
@@ -639,21 +467,21 @@ public class XACMLPAPTest {
dictionaryTestSetup(false, "Site", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
}
@Test
public void testFirewallCreateDictionary() throws IOException, SQLException, ServletException {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
- // Check SecurityZone.
+ // Check SecurityZone.
String json = "{\"dictionaryFields\":{\"zoneName\":\"testRestAPI\",\"zoneValue\":\"testing\"}}";
dictionaryTestSetup(false, "SecurityZone", json);
// set DBDao
FirewallDictionaryController.setCommonClassDao(new CommonClassDaoImpl());
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
// Check Action List
@@ -664,10 +492,10 @@ public class XACMLPAPTest {
dictionaryTestSetup(false, "ActionList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check Protocol List.
+ // Check Protocol List.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
@@ -675,10 +503,10 @@ public class XACMLPAPTest {
dictionaryTestSetup(false, "ProtocolList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check Zone.
+ // Check Zone.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
@@ -686,81 +514,76 @@ public class XACMLPAPTest {
dictionaryTestSetup(false, "Zone", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check PrefixList.
+ // Check PrefixList.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"prefixListName\":\"testRestAPI\",\"prefixListValue\":\"127.0.0.1\"," +
- "\"description\":\"testing\"}}";
+ json = "{\"dictionaryFields\":{\"prefixListName\":\"testRestAPI\",\"prefixListValue\":\"127.0.0.1\","
+ + "\"description\":\"testing\"}}";
dictionaryTestSetup(false, "PrefixList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check AddressGroup.
+ // Check AddressGroup.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"groupName\":\"testRestAPIgroup\",\"description\":\"testing\"," +
- "\"attributes\":[{\"option\":\"testRestAPI\"}, {\"option\":\"testRestAPI\"}]}}";
+ json = "{\"dictionaryFields\":{\"groupName\":\"testRestAPIgroup\",\"description\":\"testing\","
+ + "\"attributes\":[{\"option\":\"testRestAPI\"}, {\"option\":\"testRestAPI\"}]}}";
dictionaryTestSetup(false, "AddressGroup", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check ServiceGroup.
+ // Check ServiceGroup.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"groupName\":\"testRestAPIServiceGroup\"," +
- "\"attributes\":[{\"option\":\"testRestAPIservice\"}]}}";
+ json = "{\"dictionaryFields\":{\"groupName\":\"testRestAPIServiceGroup\","
+ + "\"attributes\":[{\"option\":\"testRestAPIservice\"}]}}";
dictionaryTestSetup(false, "ServiceGroup", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check ServiceList.
+ // Check ServiceList.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"serviceName\":\"testRestAPIservice\",\"serviceDescription\":\"test\"," +
- "\"servicePorts\":\"8888\",\"transportProtocols\":[{\"option\":\"testRestAPI\"}," +
- "{\"option\":\"testRestAPI1\"}],\"appProtocols\":[{\"option\":\"testRestAPI\"}," +
- "{\"option\":\"testRestAPI1\"}]}}";
+ json = "{\"dictionaryFields\":{\"serviceName\":\"testRestAPIservice\",\"serviceDescription\":\"test\","
+ + "\"servicePorts\":\"8888\",\"transportProtocols\":[{\"option\":\"testRestAPI\"},"
+ + "{\"option\":\"testRestAPI1\"}],\"appProtocols\":[{\"option\":\"testRestAPI\"},"
+ + "{\"option\":\"testRestAPI1\"}]}}";
dictionaryTestSetup(false, "ServiceList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
//
- // Check TermList.
+ // Check TermList.
//
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"termName\":\"testRestAPIRule\",\"termDescription\":\"testing\"," +
- "\"fromZoneDatas\":[{\"option\":\"testRestAPI\"}]," +
- "\"toZoneDatas\":[{\"option\":\"testRestAPI1\"}]," +
- "\"sourceListDatas\":[{\"option\":\"Group_testportal\"}]," +
- "\"destinationListDatas\":[{\"option\":\"testRestAPI\"}]," +
- "\"sourceServiceDatas\":[{\"option\":\"testRestAPIservice\"}," +
- "{\"option\":\"testRestAPIservice1\"}]," +
- "\"destinationServiceDatas\":[{\"option\":\"testRestAPIservice1\"}," +
- "{\"option\":\"testportalservice2\"}],\"actionListDatas\":[{\"option\":\"testRestAPI\"}]}}";
+ json = "{\"dictionaryFields\":{\"termName\":\"testRestAPIRule\",\"termDescription\":\"testing\","
+ + "\"fromZoneDatas\":[{\"option\":\"testRestAPI\"}],"
+ + "\"toZoneDatas\":[{\"option\":\"testRestAPI1\"}],"
+ + "\"sourceListDatas\":[{\"option\":\"Group_testportal\"}],"
+ + "\"destinationListDatas\":[{\"option\":\"testRestAPI\"}],"
+ + "\"sourceServiceDatas\":[{\"option\":\"testRestAPIservice\"},"
+ + "{\"option\":\"testRestAPIservice1\"}],"
+ + "\"destinationServiceDatas\":[{\"option\":\"testRestAPIservice1\"},"
+ + "{\"option\":\"testportalservice2\"}],\"actionListDatas\":[{\"option\":\"testRestAPI\"}]}}";
dictionaryTestSetup(false, "TermList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
- // Verify
+ // Verify
Mockito.verify(httpServletResponse).setStatus(HttpServletResponse.SC_OK);
}
@@ -776,8 +599,8 @@ public class XACMLPAPTest {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
String json =
- "{\"dictionaryFields\": {\"onapName\": \"testMMRestAPI1\",\"description\": \"testing update response " +
- "message\"}}";
+ "{\"dictionaryFields\": {\"onapName\": \"testMMRestAPI1\",\"description\": \"testing update response "
+ + "message\"}}";
dictionaryTestSetup(false, "OnapName", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
@@ -786,11 +609,10 @@ public class XACMLPAPTest {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\": {\"xacmlId\": \"testMMRestAPI1\",\"datatypeBean\": {\"shortName\": " +
- "\"string\"}, \"description\": \"testing update\",\"priority\": \"High\"," +
- "\"userDataTypeValues\": [{\"attributeValues\": \"testAttr\"}, {\"attributeValues\": " +
- "\"testAttr2\"}, {\"attributeValues\": \"testAttr3\"}]}}";
+ json = "{\"dictionaryFields\": {\"xacmlId\": \"testMMRestAPI1\",\"datatypeBean\": {\"shortName\": "
+ + "\"string\"}, \"description\": \"testing update\",\"priority\": \"High\","
+ + "\"userDataTypeValues\": [{\"attributeValues\": \"testAttr\"}, {\"attributeValues\": "
+ + "\"testAttr2\"}, {\"attributeValues\": \"testAttr3\"}]}}";
dictionaryTestSetup(false, "Attribute", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
@@ -800,11 +622,10 @@ public class XACMLPAPTest {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"attributeName\":\"TestMMrestAPI1\",\"type\":\"REST\",\"url\":\"testsomeurl" +
- ".com\",\"method\":\"GET\",\"description\":\"test create\",\"body\":\"Testing Create\"," +
- "\"headers\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\"," +
- "\"number\":\"test\"}]}}";
+ json = "{\"dictionaryFields\":{\"attributeName\":\"TestMMrestAPI1\",\"type\":\"REST\",\"url\":\"testsomeurl"
+ + ".com\",\"method\":\"GET\",\"description\":\"test create\",\"body\":\"Testing Create\","
+ + "\"headers\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
+ + "\"number\":\"test\"}]}}";
dictionaryTestSetup(false, "Action", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
@@ -813,10 +634,9 @@ public class XACMLPAPTest {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"scopeName\":\"testMMRestAPI1\",\"description\":\"test\"," +
- "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\"," +
- "\"number\":\"test\"}]}}";
+ json = "{\"dictionaryFields\":{\"scopeName\":\"testMMRestAPI1\",\"description\":\"test\","
+ + "\"attributes\":[{\"option\":\"test1\",\"number\":\"test\"},{\"option\":\"test2\","
+ + "\"number\":\"test\"}]}}";
dictionaryTestSetup(false, "DescriptiveScope", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
@@ -834,9 +654,8 @@ public class XACMLPAPTest {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"message\":\"test\"," +
- "\"riskType\":\"testMMrestAPI1\"}}";
+ json = "{\"dictionaryFields\":{\"name\":\"testMMrestAPI1\",\"message\":\"test\","
+ + "\"riskType\":\"testMMrestAPI1\"}}";
dictionaryTestSetup(false, "SafePolicyWarning", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
@@ -850,8 +669,8 @@ public class XACMLPAPTest {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
String json =
- "{\"dictionaryFields\":{\"xacmlId\":\"testMMRestAPI1\",\"datatypeBean\":{\"shortName\":\"string\"}," +
- "\"description\":\"test\",\"priority\":\"High\"}}";
+ "{\"dictionaryFields\":{\"xacmlId\":\"testMMRestAPI1\",\"datatypeBean\":{\"shortName\":\"string\"},"
+ + "\"description\":\"test\",\"priority\":\"High\"}}";
dictionaryTestSetup(false, "Settings", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
@@ -860,9 +679,8 @@ public class XACMLPAPTest {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"bbid\":\"BB1\",\"workstep\":\"1\",\"treatments\":\"Manual Handling,Abort," +
- "Retry\"}}";
+ json = "{\"dictionaryFields\":{\"bbid\":\"BB1\",\"workstep\":\"1\",\"treatments\":\"Manual Handling,Abort,"
+ + "Retry\"}}";
dictionaryTestSetup(false, "RainyDayTreatments", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
@@ -939,10 +757,9 @@ public class XACMLPAPTest {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = Mockito.mock(MockHttpServletResponse.class);
- json =
- "{\"dictionaryFields\":{\"groupName\":\"testMMrestAPI1\",\"description\":\"testing\"}," +
- "\"groupPolicyScopeListData1\":{\"resource\":\"ANY\",\"type\":\"ANY\",\"service\":\"ANY\"," +
- "\"closedloop\":\"ANY\"}}";
+ json = "{\"dictionaryFields\":{\"groupName\":\"testMMrestAPI1\",\"description\":\"testing\"},"
+ + "\"groupPolicyScopeListData1\":{\"resource\":\"ANY\",\"type\":\"ANY\",\"service\":\"ANY\","
+ + "\"closedloop\":\"ANY\"}}";
dictionaryTestSetup(false, "GroupPolicyScopeList", json);
// send Request to PAP
pap.service(httpServletRequest, httpServletResponse);
@@ -965,8 +782,6 @@ public class XACMLPAPTest {
MockServletInputStream mockInput = new MockServletInputStream(json.getBytes());
Mockito.when(httpServletRequest.getInputStream()).thenReturn(mockInput);
Mockito.when(httpServletRequest.getReader()).thenReturn(new BufferedReader(new InputStreamReader(mockInput)));
- // set DBDao
- setDBDao();
}
public void setDBDao() throws SQLException {
@@ -995,13 +810,13 @@ public class XACMLPAPTest {
@Test
public void getDictionary() throws ServletException, IOException {
- String[] dictionarys = new String[]{"Attribute", "OnapName", "Action", "BRMSParamTemplate", "VSCLAction"
- , "VNFType", "PEPOptions", "Varbind", "Service", "Site", "Settings", "RainyDayTreatments",
- "DescriptiveScope", "ActionList", "ProtocolList", "Zone", "SecurityZone",
- "PrefixList", "AddressGroup", "ServiceGroup", "ServiceList", "TermList",
- "MicroServiceLocation", "MicroServiceConfigName", "DCAEUUID", "MicroServiceModels",
- "PolicyScopeService", "PolicyScopeResource", "PolicyScopeType", "PolicyScopeClosedLoop",
- "GroupPolicyScopeList", "RiskType", "SafePolicyWarning", "MicroServiceDictionary"};
+ String[] dictionarys = new String[] {"Attribute", "OnapName", "Action", "BRMSParamTemplate", "VSCLAction",
+ "VNFType", "PEPOptions", "Varbind", "Service", "Site", "Settings", "RainyDayTreatments",
+ "DescriptiveScope", "ActionList", "ProtocolList", "Zone", "SecurityZone", "PrefixList", "AddressGroup",
+ "ServiceGroup", "ServiceList", "TermList", "MicroServiceLocation", "MicroServiceConfigName", "DCAEUUID",
+ "MicroServiceModels", "PolicyScopeService", "PolicyScopeResource", "PolicyScopeType",
+ "PolicyScopeClosedLoop", "GroupPolicyScopeList", "RiskType", "SafePolicyWarning",
+ "MicroServiceDictionary"};
for (String dictionary : dictionarys) {
httpServletRequest = Mockito.mock(HttpServletRequest.class);
httpServletResponse = new MockHttpServletResponse();
@@ -1034,8 +849,8 @@ public class XACMLPAPTest {
}
}
- @After
- public void destroy() {
+ @AfterClass
+ public static void destroy() {
if (sessionFactory != null) {
sessionFactory.close();
}
diff --git a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicyTest.java b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicyTest.java
index 3cf3128dd..ec9229c71 100644
--- a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicyTest.java
+++ b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicyTest.java
@@ -2,14 +2,14 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,18 +17,18 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
+
package org.onap.policy.pap.xacml.rest.components;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;
-
+import com.att.research.xacml.util.XACMLProperties;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
-
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
@@ -37,8 +37,6 @@ import org.onap.policy.common.logging.flexlogger.Logger;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
import org.onap.policy.rest.adapter.RainyDayParams;
-import com.att.research.xacml.util.XACMLProperties;
-
public class DecisionPolicyTest {
private static Logger logger = FlexLogger.getLogger(DecisionPolicyTest.class);
@@ -99,7 +97,7 @@ public class DecisionPolicyTest {
policyAdapter.setRainydayMap(treatmentMap);
policyAdapter.setRainyday(rainyday);
- component = new DecisionPolicy(policyAdapter, null);
+ component = new DecisionPolicy(policyAdapter);
logger.info("setUp: exit");
}
@@ -131,7 +129,7 @@ public class DecisionPolicyTest {
public void testPrepareToSaveRainyDay() {
logger.debug("test PrepareToSave Policy: enter");
policyAdapter.setRuleProvider("Rainy_Day");
- component = new DecisionPolicy(policyAdapter, null);
+ component = new DecisionPolicy(policyAdapter);
boolean response = false;
try {
@@ -141,4 +139,4 @@ public class DecisionPolicyTest {
}
assertTrue(response);
}
-} \ No newline at end of file
+}
diff --git a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTest.java b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTest.java
index f7dd92a3e..0e89a7085 100644
--- a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTest.java
+++ b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTest.java
@@ -7,9 +7,9 @@
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -21,82 +21,65 @@
package org.onap.policy.pap.xacml.rest.components;
import static org.junit.Assert.fail;
-
+import com.att.research.xacml.api.pap.PAPException;
+import com.att.research.xacml.util.XACMLProperties;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Date;
import java.util.List;
-
-import javax.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
-import javax.persistence.Persistence;
+import java.util.Properties;
import javax.persistence.PersistenceException;
-import javax.persistence.Query;
-
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
+import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
+import org.hibernate.Query;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Assert;
-import org.junit.Before;
+import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
-import org.mockito.Mockito;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.pap.xacml.rest.DataToNotifyPdp;
import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
+import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
+import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation;
import org.onap.policy.rest.XACMLRestProperties;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
import org.onap.policy.rest.dao.PolicyDBException;
+import org.onap.policy.rest.jpa.DatabaseLockEntity;
import org.onap.policy.rest.jpa.GroupEntity;
import org.onap.policy.rest.jpa.PdpEntity;
import org.onap.policy.rest.jpa.PolicyEntity;
+import org.onap.policy.rest.jpa.UserInfo;
import org.onap.policy.xacml.api.pap.OnapPDPGroup;
import org.onap.policy.xacml.std.pap.StdEngine;
import org.onap.policy.xacml.std.pap.StdPDPGroup;
-import org.onap.policy.xacml.util.XACMLPolicyWriter;
-
-import com.att.research.xacml.api.pap.PAPException;
-import com.att.research.xacml.util.XACMLProperties;
-
+import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
-public class PolicyDBDaoTest extends Mockito{
-
+public class PolicyDBDaoTest {
private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
- PolicyDBDaoTestClass d;
- PolicyDBDao dbd;
- PolicyDBDao dbd2;
- EntityManagerFactory emf;
- private Path repository;
- StdEngine stdEngine = null;
-
- @Before
- public void init() throws PAPException, IOException{
- System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME,"src/test/resources/xacml.pap.properties");
- emf = Persistence.createEntityManagerFactory("testPapPU");
- EntityManager em = emf.createEntityManager();
- em.getTransaction().begin();
- try{
- em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
- em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
- em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
- em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
- em.createQuery("DELETE FROM PdpEntity").executeUpdate();
- em.createQuery("DELETE FROM GroupEntity").executeUpdate();
-
- em.getTransaction().commit();
- } catch(Exception e){
- logger.error("Exception Occured"+e);
- em.getTransaction().rollback();
- }
- em.close();
+ static PolicyDBDaoTestClass d;
+ static PolicyDBDao dbd;
+ static PolicyDBDao dbd2;
+ private static Path repository;
+ static StdEngine stdEngine = null;
+ static SessionFactory sessionFactory = null;
+
+ @BeforeClass
+ public static void init() throws PAPException, IOException {
+ System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
try {
- dbd = PolicyDBDao.getPolicyDBDaoInstance(emf);
- dbd2 = PolicyDBDao.getPolicyDBDaoInstance(emf);
+ sessionFactory = setupH2DbDaoImpl("testdbdao");
+ dbd = PolicyDBDao.getPolicyDBDaoInstance();
+ dbd2 = PolicyDBDao.getPolicyDBDaoInstance();
} catch (Exception e) {
Assert.fail();
}
@@ -109,41 +92,76 @@ public class PolicyDBDaoTest extends Mockito{
}
@After
- public void cleanUp(){
- PolicyDBDao.setJunit(false);
- EntityManager em = emf.createEntityManager();
- em.getTransaction().begin();
- try{
- em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
- em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
- em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
- em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
- em.createQuery("DELETE FROM PdpEntity").executeUpdate();
- em.createQuery("DELETE FROM GroupEntity").executeUpdate();
-
- em.getTransaction().commit();
- } catch(Exception e){
- em.getTransaction().rollback();
- }
- em.close();
+ public void cleanUp() {
try {
FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
} catch (IOException e) {
- //could not delete
+ // could not delete
}
}
+ public static SessionFactory setupH2DbDaoImpl(String dbName) {
+ System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME, "src/test/resources/xacml.pap.properties");
+ BasicDataSource dataSource = new BasicDataSource();
+ dataSource.setDriverClassName("org.h2.Driver");
+ dataSource.setUrl("jdbc:h2:mem:" + dbName + ";DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");
+ dataSource.setUsername("sa");
+ dataSource.setPassword("");
+ LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource);
+ sessionBuilder.scanPackages("org.onap.*");
+
+ Properties properties = new Properties();
+ properties.put("hibernate.show_sql", "false");
+ properties.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
+ properties.put("hibernate.hbm2ddl.auto", "create-drop");
+
+ sessionBuilder.addProperties(properties);
+ SessionFactory sessionFac = sessionBuilder.buildSessionFactory();
+
+ new PolicyDBDao(sessionFac);
+ new PolicyDbDaoTransactionInstance(sessionFac).isJunit = true;
+ CommonClassDaoImpl.setSessionfactory(sessionFac);
+ new DataToNotifyPdp(new CommonClassDaoImpl());
+ PolicyCreation.setCommonClassDao(new CommonClassDaoImpl());
+
+ DatabaseLockEntity lock = null;
+ Session session = sessionFac.openSession();
+ session.getTransaction().begin();
+ lock = (DatabaseLockEntity) session.get(DatabaseLockEntity.class, 1);
+ if (lock == null) {
+ lock = new DatabaseLockEntity();
+ lock.setKey(1);
+ session.persist(lock);
+ session.flush();
+ }
+ session.getTransaction().commit();
+ session.close();
+
+ UserInfo user = new UserInfo();
+ user.setUserLoginId("API");
+ user.setUserName("API");
+ Session session2 = sessionFac.openSession();
+ session2.getTransaction().begin();
+ session2.persist(user);
+
+ session2.getTransaction().commit();
+ session2.close();
+
+ return sessionFac;
+ }
+
+
@Test
- public void getConfigFileTest(){
+ public void testGetConfigFile() {
PolicyRestAdapter pra = new PolicyRestAdapter();
pra.setConfigType(ConfigPolicy.JSON_CONFIG);
String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
- //yes, we can do action files too even though they don't have configs
+ // yes, we can do action files too even though they don't have configs
configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
}
-
+
@Test
public void getPolicyNameAndVersionFromPolicyFileNameTest() throws PolicyDBException {
String policyName = "com.Decision_testname.1.xml";
@@ -153,7 +171,7 @@ public class PolicyDBDaoTest extends Mockito{
String[] actualNameAndVersion = d.getPolicyNameAndVersionFromPolicyFileName(policyName);
Assert.assertArrayEquals(expectedNameAndVersion, actualNameAndVersion);
}
-
+
@Test
public void getNameScopeAndVersionFromPdpPolicyTest() {
String fileName = "com.Decision_testname.1.xml";
@@ -161,32 +179,33 @@ public class PolicyDBDaoTest extends Mockito{
expectedArray[0] = "Decision_testname.1.xml";
expectedArray[2] = "1";
expectedArray[1] = "com";
-
+
String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
Assert.assertArrayEquals(expectedArray, returnArray);
}
-
+
@Test
public void getPdpPolicyNameTest() {
String name = "Decision_testname.1.json";
String scope = "com";
String expectedFinalname = "com.Decision_testname.1.xml";
-
+
String finalname = d.getPdpPolicyName(name, scope);
Assert.assertEquals(expectedFinalname, finalname);
}
-
+
@Test
public void getPolicySubFileTest() {
String name = "Config_testname.1.json";
String subFileType = "Config";
-
- Path path = d.getPolicySubFile(name, subFileType);
+ HandleIncomingNotifications handle = new HandleIncomingNotifications(sessionFactory);
+
+ Path path = handle.getPolicySubFile(name, subFileType);
Assert.assertNull(path);
}
@Test
- public void createFromPolicyObject(){
+ public void createFromPolicyObject() {
Policy policyObject = new ConfigPolicy();
policyObject.policyAdapter = new PolicyRestAdapter();
policyObject.policyAdapter.setConfigName("testpolicy1");
@@ -202,37 +221,45 @@ public class PolicyDBDaoTest extends Mockito{
policyObject.policyAdapter.setPolicyData(policyTypeObject);
ClassLoader classLoader = getClass().getClassLoader();
PolicyType policyConfig = new PolicyType();
- policyConfig.setVersion(Integer.toString(1));
+ policyConfig.setVersion("1");
policyConfig.setPolicyId("");
policyConfig.setTarget(new TargetType());
policyObject.policyAdapter.setData(policyConfig);
- mock(XACMLPolicyWriter.class);
try {
- policyObject.policyAdapter.setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
+ policyObject.policyAdapter
+ .setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
} catch (Exception e2) {
fail();
}
PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
- try{
+ try {
transaction.createPolicy(policyObject, "testuser1");
transaction.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
transaction.rollbackTransaction();
Assert.fail();
}
- EntityManager getData = emf.createEntityManager();
- Query getDataQuery = getData.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:name");
- getDataQuery.setParameter("scope", "com");
- getDataQuery.setParameter("name","Config_SampleTest1206.1.xml");
+ Session session = sessionFactory.openSession();
+ session.getTransaction().begin();
+ Query policyQuery =
+ session.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
+
+ policyQuery.setParameter("name", "Config_SampleTest1206.1.xml");
+ policyQuery.setParameter("scope", "com");
+
+ List<?> policyQueryList = policyQuery.list();
PolicyEntity result = null;
- try{
- result = (PolicyEntity)getDataQuery.getSingleResult();
- } catch(Exception e){
- logger.error("Exception Occured"+e);
+ try {
+ result = (PolicyEntity) policyQueryList.get(0);
+ } catch (Exception e) {
+ logger.error("Exception Occured " + e);
Assert.fail();
}
+ session.getTransaction().commit();
+ session.close();
+
String expectedData;
try {
expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
@@ -240,405 +267,428 @@ public class PolicyDBDaoTest extends Mockito{
expectedData = "";
}
Assert.assertEquals(expectedData, result.getPolicyData());
- getData.close();
result = null;
- transaction.commitTransaction();
Assert.assertFalse(transaction.isTransactionOpen());
}
@Test
- public void groupTransactions(){
+ public void groupTransactions() {
PolicyDBDaoTransaction group = dbd.getNewTransaction();
String groupName = "test group 1";
- try{
- group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group","testuser");
+ try {
+ group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group",
+ "testuser");
group.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
- EntityManager em = emf.createEntityManager();
- Query getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
+ Session session = sessionFactory.openSession();
+ session.getTransaction().begin();
+ Query getGroup =
+ session.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
getGroup.setParameter("deleted", false);
- List<?> groups = getGroup.getResultList();
- if(groups.size() != 1){
- Assert.fail();
- }
- GroupEntity groupEntity = (GroupEntity)groups.get(0);
- em.close();
+ List<?> groups = getGroup.list();
+ GroupEntity groupEntity = (GroupEntity) groups.get(0);
Assert.assertEquals(groupName, groupEntity.getgroupName());
Assert.assertEquals("this is a test group", groupEntity.getDescription());
+ session.getTransaction().commit();
+ session.close();
+
group = dbd.getNewTransaction();
- try{
- OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName),Paths.get("/"));
- group.deleteGroup(groupToDelete, null,"testuser");
+ try {
+ OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName), Paths.get("/"));
+ group.deleteGroup(groupToDelete, null, "testuser");
group.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
- em = emf.createEntityManager();
- getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
- getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
- getGroup.setParameter("deleted", false);
- groups = getGroup.getResultList();
- if(groups.size() != 0){
- System.out.println("Group size: "+groups.size());
+ Session session2 = sessionFactory.openSession();
+ session2.getTransaction().begin();
+ Query getGroup2 =
+ session2.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
+ getGroup2.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
+ getGroup2.setParameter("deleted", false);
+ List<?> groups2 = getGroup2.list();
+ groups2 = getGroup2.list();
+ if (groups2.size() != 0) {
+ System.out.println("Group size: " + groups2.size());
Assert.fail();
}
- em.close();
- //add a pdp to a group
+ session2.getTransaction().commit();
+ session2.close();
+
+
+ // add a pdp to a group
group = dbd.getNewTransaction();
- try{
+ try {
group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
group.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
+
group = dbd.getNewTransaction();
- try{
- group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary", "the main pdp", 3232, "testuser");
+ try {
+ group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary",
+ "the main pdp", 3232, "testuser");
group.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
- em = emf.createEntityManager();
- Query getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
+
+ Session session3 = sessionFactory.openSession();
+ session3.getTransaction().begin();
+ Query getPdp = session3.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
getPdp.setParameter("deleted", false);
- List<?> pdps = getPdp.getResultList();
- if(pdps.size() != 1){
- System.out.println("Group size: "+pdps.size());
+ List<?> pdps = getPdp.list();
+ if (pdps.size() != 1) {
+ System.out.println("Group size: " + pdps.size());
Assert.fail();
}
- PdpEntity pdp = (PdpEntity)pdps.get(0);
+ PdpEntity pdp = (PdpEntity) pdps.get(0);
Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
Assert.assertEquals(pdp.getPdpName(), "primary");
- em.close();
+ session3.getTransaction().commit();
+ session3.close();
+
+
group = dbd.getNewTransaction();
- try{
- group.removePdpFromGroup("http://localhost:4344/pdp/","testuser");
+ try {
+ group.removePdpFromGroup("http://localhost:4344/pdp/", "testuser");
group.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
- em = emf.createEntityManager();
- getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
- getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
- getPdp.setParameter("deleted", false);
- pdps = getPdp.getResultList();
- if(pdps.size() != 0){
- System.out.println("Group size: "+pdps.size());
+
+ Session session4 = sessionFactory.openSession();
+ session4.getTransaction().begin();
+ Query getPdp2 = session4.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
+ getPdp2.setParameter("pdpId", "http://localhost:4344/pdp/");
+ getPdp2.setParameter("deleted", false);
+ List<?> pdps2 = getPdp2.list();
+ if (pdps2.size() != 0) {
+ System.out.println("Group size: " + pdps2.size());
Assert.fail();
}
- em.close();
- //add some pdps to groups
+ session4.getTransaction().commit();
+ session4.close();
+
+ // add some pdps to groups
group = dbd.getNewTransaction();
- try{
+ try {
group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
group.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
group = dbd.getNewTransaction();
- try{
+ try {
group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
group.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
group = dbd.getNewTransaction();
- try{
- group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary", "the main pdp", 3232, "testuser");
+ try {
+ group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary",
+ "the main pdp", 3232, "testuser");
group.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
group = dbd.getNewTransaction();
- try{
- group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "secondary", "the second pdp", 3233, "testuser");
+ try {
+ group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"),
+ "secondary", "the second pdp", 3233, "testuser");
group.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
- em = emf.createEntityManager();
- getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
- getPdp.setParameter("deleted", false);
- pdps = getPdp.getResultList();
- for(Object o : pdps){
- Assert.assertEquals("testgroup1",((PdpEntity)o).getGroup().getgroupName());
+
+ Session session5 = sessionFactory.openSession();
+ session5.getTransaction().begin();
+ Query getPdp3 = session5.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
+ getPdp3.setParameter("deleted", false);
+ List<?> pdps3 = getPdp3.list();
+ for (Object obj : pdps3) {
+ Assert.assertEquals("testgroup1", ((PdpEntity) obj).getGroup().getgroupName());
}
- em.close();
+
+ session5.getTransaction().commit();
+ session5.close();
+
group = dbd.getNewTransaction();
- try{
- OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"),Paths.get("/"));
- OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
- group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
+ try {
+ OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), Paths.get("/"));
+ OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
+ group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
group.commitTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
- em = emf.createEntityManager();
- getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
- getGroup.setParameter("groupId", "testgroup1");
- getGroup.setParameter("deleted", false);
- groups = getGroup.getResultList();
- if(groups.size() != 0){
- System.out.println("Group size: "+groups.size());
+
+ Session session6 = sessionFactory.openSession();
+ session6.getTransaction().begin();
+ Query getGroup3 =
+ session6.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
+ getGroup3.setParameter("groupId", "testgroup1");
+ getGroup3.setParameter("deleted", false);
+ List<?> groups3 = getGroup3.list();
+ if (groups3.size() != 0) {
+ System.out.println("Group size: " + groups3.size());
Assert.fail();
}
- em.close();
- em = emf.createEntityManager();
- getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
- getPdp.setParameter("deleted", false);
- pdps = getPdp.getResultList();
- for(Object o : pdps){
- Assert.assertEquals("testgroup2",((PdpEntity)o).getGroup().getgroupName());
+ session6.getTransaction().commit();
+ session6.close();
+
+ Session session7 = sessionFactory.openSession();
+ session7.getTransaction().begin();
+ Query getPdp4 = session7.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
+ getPdp4.setParameter("deleted", false);
+ List<?> pdps4 = getPdp4.list();
+ for (Object obj : pdps4) {
+ Assert.assertEquals("testgroup2", ((PdpEntity) obj).getGroup().getgroupName());
}
- em.close();
+
+ session7.getTransaction().commit();
+ session7.close();
+
group = dbd.getNewTransaction();
- try{
- OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
+ try {
+ OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), Paths.get("/"));
OnapPDPGroup groupToMoveTo = null;
- group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
+ group.deleteGroup(groupToDelete, groupToMoveTo, "testuser");
group.commitTransaction();
Assert.fail();
- } catch(PolicyDBException pe){
- //good, can't delete group with pdps
+ } catch (PolicyDBException pe) {
+ // good, can't delete group with pdps
group.rollbackTransaction();
- } catch(Exception e){
+ } catch (Exception e) {
group.rollbackTransaction();
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
- //update group
- OnapPDPGroup pdpGroup = new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
+ // update group
+ OnapPDPGroup pdpGroup =
+ new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
group = dbd.getNewTransaction();
- try{
- group.updateGroup(pdpGroup, "testuser");
+ try {
+ group.updateGroup(pdpGroup, "testuser", "testuser");
group.commitTransaction();
- }catch (Exception e){
- logger.error("Exception Occured"+e);
+ } catch (Exception e) {
+ logger.error("Exception Occured" + e);
group.rollbackTransaction();
Assert.fail();
}
- em = emf.createEntityManager();
- getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
- getGroup.setParameter("groupId", "newtestgroup2");
- getGroup.setParameter("deleted", false);
- groups = getGroup.getResultList();
- if(groups.size() != 1){
- System.out.println("Group size: "+groups.size());
+
+ Session session8 = sessionFactory.openSession();
+ session8.getTransaction().begin();
+ Query getGroup4 =
+ session8.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
+ getGroup4.setParameter("groupId", "newtestgroup2");
+ getGroup4.setParameter("deleted", false);
+ List<?> groups4 = getGroup4.list();
+ if (groups4.size() != 1) {
+ System.out.println("Group size: " + groups4.size());
Assert.fail();
}
- em.close();
- em = emf.createEntityManager();
- getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
- getGroup.setParameter("groupId", "testgroup2");
- getGroup.setParameter("deleted", false);
- groups = getGroup.getResultList();
- if(groups.size() != 0){
- System.out.println("Group size: "+groups.size());
+
+ session8.getTransaction().commit();
+ session8.close();
+
+ Session session9 = sessionFactory.openSession();
+ session9.getTransaction().begin();
+ Query getGroup5 =
+ session9.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
+ getGroup5.setParameter("groupId", "testgroup2");
+ getGroup5.setParameter("deleted", false);
+ List<?> groups5 = getGroup5.list();
+ if (groups5.size() != 0) {
+ System.out.println("Group size: " + groups5.size());
Assert.fail();
}
- em.close();
+
+ session9.getTransaction().commit();
+ session9.close();
}
@Ignore
@Test
- public void threadingStabilityTest(){
- if(logger.isDebugEnabled()){
- logger.debug("\n\n****************************"
- + "threadingStabilityTest() entry"
+ public void threadingStabilityTest() {
+ if (logger.isDebugEnabled()) {
+ logger.debug("\n\n****************************" + "threadingStabilityTest() entry"
+ "******************************\n\n");
}
PolicyDBDaoTransaction t = dbd.getNewTransaction();
Assert.assertTrue(t.isTransactionOpen());
try {
- //Add 1000 ms to the timeout just to be sure it actually times out
- int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n sleepTime = " + sleepTime
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ // Add 1000 ms to the timeout just to be sure it actually times out
+ int sleepTime =
+ Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
}
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
}
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n Assert.assertFalse(t.isTransactionOpen() = " + t.isTransactionOpen() + ")"
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug(
+ "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(t.isTransactionOpen() = "
+ + t.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
}
Assert.assertFalse(t.isTransactionOpen());
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n a = dbd.getNewTransaction() "
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n a = dbd.getNewTransaction() "
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
}
PolicyDBDaoTransaction a = dbd.getNewTransaction();
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n Assert.assertTrue(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug(
+ "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(a.isTransactionOpen() = "
+ + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
}
Assert.assertTrue(a.isTransactionOpen());
try {
- //Add 1000 ms to the timeout just to be sure it actually times out
- int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n sleepTime = " + sleepTime
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ // Add 1000 ms to the timeout just to be sure it actually times out
+ int sleepTime =
+ Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n sleepTime = " + sleepTime
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
}
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
}
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n b = dbd.getNewTransaction() "
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n b = dbd.getNewTransaction() "
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
}
PolicyDBDaoTransaction b = dbd.getNewTransaction();
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n Assert.assertFalse(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug(
+ "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertFalse(a.isTransactionOpen() = "
+ + a.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
}
Assert.assertFalse(a.isTransactionOpen());
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n Assert.assertTrue(b.isTransactionOpen() = " + b.isTransactionOpen() + ")"
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug(
+ "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(b.isTransactionOpen() = "
+ + b.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
}
Assert.assertTrue(b.isTransactionOpen());
b.close();
- //Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
- System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT,"1000");
- //And let's lengthen the transaction timeout to 5000 ms
- System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT,"5000");
- //get a transacton
+ // Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
+ System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT, "1000");
+ // And let's lengthen the transaction timeout to 5000 ms
+ System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT, "5000");
+ // get a transacton
PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug(
+ "\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Assert.assertTrue(t1.isTransactionOpen() = "
+ + t1.isTransactionOpen() + ")" + "\n TimeStamp = " + date.getTime() + "\n\n");
}
Assert.assertTrue(t1.isTransactionOpen());
- //while it is open, get another from a different DB Dao so it will not collide on the synchronized code segment
- //but will collide at the DB. Remember that the wait time is only 1000 ms
+ // while it is open, get another from a different DB Dao so it will not collide on the synchronized
+ // code segment
+ // but will collide at the DB. Remember that the wait time is only 1000 ms
try {
- //Now the 2nd transaction has a wait timeout in 1000 ms
+ // Now the 2nd transaction has a wait timeout in 1000 ms
PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
/*
- * Give it plenty of time to time out the second transaction
- * It will actually hang right here until it either gets the lock from the DB or the
- * request for the DB lock times out. The timers are very sloppy so, I have given
- * this plenty of leeway.
+ * Give it plenty of time to time out the second transaction It will actually hang right here until
+ * it either gets the lock from the DB or the request for the DB lock times out. The timers are very
+ * sloppy so, I have given this plenty of leeway.
*/
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n Thread.sleep(3000)"
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() " + "\n Thread.sleep(3000)"
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
}
Thread.sleep(3000);
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
+ "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
+ "\n Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
}
- //Assert.assertTrue(t1.isTransactionOpen());
- //Assert.assertFalse(t2.isTransactionOpen());
+ // Assert.assertTrue(t1.isTransactionOpen());
+ // Assert.assertFalse(t2.isTransactionOpen());
Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
} catch (PersistenceException e) {
- //success
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
+ // success
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
- + "\n SUCCESS! Transaction Wait Timeout worked!"
- + "\n Caught PersistenceException = " + e
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ + "\n SUCCESS! Transaction Wait Timeout worked!" + "\n Caught PersistenceException = " + e
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
}
} catch (Exception e) {
// failure due to some other reason
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE"
- + "\n Caught Exception = " + e
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE" + "\n Caught Exception = " + e
+ + "\n TimeStamp = " + date.getTime() + "\n\n");
}
- logger.error("Exception Occured"+e);
+ logger.error("Exception Occured" + e);
Assert.fail();
}
- if(logger.isDebugEnabled()){
- Date date= new java.util.Date();
- logger.debug("\n\nthreadingStabilityTest() exit"
- + "\n TimeStamp = " + date.getTime()
- + "\n\n");
+ if (logger.isDebugEnabled()) {
+ Date date = new java.util.Date();
+ logger.debug("\n\nthreadingStabilityTest() exit" + "\n TimeStamp = " + date.getTime() + "\n\n");
}
}
-} \ No newline at end of file
+}
diff --git a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyControllerTest.java b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyControllerTest.java
index dbddecc51..007d02120 100644
--- a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyControllerTest.java
+++ b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyControllerTest.java
@@ -2,14 +2,14 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2018-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,11 +17,12 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
+
package org.onap.policy.pap.xacml.rest.controller;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;
-
+import com.att.research.xacml.api.pap.PAPException;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
@@ -31,32 +32,32 @@ import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-
import javax.servlet.ReadListener;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-
+import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
+import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.Mockito;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
+import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTest;
import org.onap.policy.rest.dao.CommonClassDao;
import org.onap.policy.rest.jpa.PolicyVersion;
import org.springframework.mock.web.MockServletConfig;
-import com.att.research.xacml.api.pap.PAPException;
-
public class PushPolicyControllerTest {
private static Logger logger = FlexLogger.getLogger(PushPolicyControllerTest.class);
private static CommonClassDao commonClassDao;
+ private static SessionFactory sessionFactory;
private String jsonString = null;
private HttpServletRequest request = null;
private PushPolicyController controller = null;
@@ -65,6 +66,11 @@ public class PushPolicyControllerTest {
private ServletConfig servletConfig;
private XACMLPapServlet pap;
+ @BeforeClass
+ public static void beforeClassSetup() throws ServletException {
+ sessionFactory = PolicyDBDaoTest.setupH2DbDaoImpl("pushcontrollertest");
+ }
+
@Before
public void setUp() throws Exception {
logger.info("setUp: Entering");
@@ -77,7 +83,7 @@ public class PushPolicyControllerTest {
System.setProperty("com.sun.management.jmxremote.port", "9993");
Mockito.when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(headers));
Mockito.when(servletConfig.getInitParameter("XACML_PROPERTIES_NAME")).thenReturn("src/test/resources/xacml.pap.properties");
-
+
commonClassDao = Mockito.mock(CommonClassDao.class);
controller = new PushPolicyController();
controller.setCommonClassDao(commonClassDao);
@@ -118,10 +124,11 @@ public class PushPolicyControllerTest {
}
public ServletInputStream getInputStream(byte[] body) throws IOException {
- final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body);
- ServletInputStream servletInputStream = new ServletInputStream() {
- public int read() throws IOException {
- return byteArrayInputStream.read();
+ final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body);
+ ServletInputStream servletInputStream = new ServletInputStream() {
+ @Override
+ public int read() throws IOException {
+ return byteArrayInputStream.read();
}
@Override
@@ -137,9 +144,9 @@ public class PushPolicyControllerTest {
@Override
public void setReadListener(ReadListener readListener) {
}
- };
- return servletInputStream;
- }
+ };
+ return servletInputStream;
+ }
@After
public void destroy(){
diff --git a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandlerTest.java b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandlerTest.java
index 84f36aa63..e7ab36e7a 100644
--- a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandlerTest.java
+++ b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandlerTest.java
@@ -2,14 +2,14 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2018-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -24,13 +24,22 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.when;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.when;
+import com.mockrunner.mock.web.MockHttpServletRequest;
+import com.mockrunner.mock.web.MockHttpServletResponse;
+import java.util.Collections;
+import java.util.List;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.Transaction;
+import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.onap.policy.common.logging.ONAPLoggingContext;
import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
+import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
import org.onap.policy.pap.xacml.rest.elk.client.PolicyElasticSearchController;
import org.onap.policy.rest.jpa.PolicyEntity;
import org.onap.policy.xacml.api.pap.PAPPolicyEngine;
@@ -38,15 +47,20 @@ import org.onap.policy.xacml.std.pap.StdEngine;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
-import com.mockrunner.mock.web.MockHttpServletRequest;
-import com.mockrunner.mock.web.MockHttpServletResponse;
-import java.sql.Connection;
-import java.util.Collections;
-import java.util.List;
-import javax.persistence.EntityManager;
@RunWith(PowerMockRunner.class)
public class DeleteHandlerTest {
+ @Before
+ public void setUp() {
+ SessionFactory mockedSessionFactory = Mockito.mock(SessionFactory.class);
+ Session mockedSession = Mockito.mock(Session.class);
+ Transaction mockedTransaction = Mockito.mock(Transaction.class);
+ Mockito.when(mockedSessionFactory.openSession()).thenReturn(mockedSession);
+ Mockito.when(mockedSession.beginTransaction()).thenReturn(mockedTransaction);
+ CommonClassDaoImpl.setSessionfactory(mockedSessionFactory);
+ new DeleteHandler(new CommonClassDaoImpl());
+ }
+
@Test
public void testGets() {
DeleteHandler handler = new DeleteHandler();
@@ -79,17 +93,13 @@ public class DeleteHandlerTest {
PolicyElasticSearchController controller = Mockito.mock(PolicyElasticSearchController.class);
PowerMockito.whenNew(PolicyElasticSearchController.class).withNoArguments().thenReturn(controller);
- // Mock entity manager
- EntityManager em = Mockito.mock(EntityManager.class);
-
- // Test deletion from PAP
- MockHttpServletResponse response = new MockHttpServletResponse();
- try {
- handler.doAPIDeleteFromPAP(request, response);
- }
- catch (Exception ex) {
- fail("Not expecting an exception: " + ex);
- }
+ // Test deletion from PAP
+ MockHttpServletResponse response = new MockHttpServletResponse();
+ try {
+ handler.doAPIDeleteFromPAP(request, response);
+ } catch (Exception ex) {
+ fail("Not expecting an exception: " + ex);
+ }
// Test deletion from PDP
ONAPLoggingContext loggingContext = Mockito.mock(ONAPLoggingContext.class);
@@ -100,15 +110,14 @@ public class DeleteHandlerTest {
fail("Not expecting an exception: " + ex);
}
- // Test delete entity
- PolicyEntity policyEntity = new PolicyEntity();
- policyEntity.setPolicyName("testVal");
- String result = DeleteHandler.deletePolicyEntityData(em, policyEntity);
- assertEquals(result, "success");
+ // Test delete entity
+ PolicyEntity policyEntity = new PolicyEntity();
+ policyEntity.setPolicyName("testVal");
+ String result = DeleteHandler.deletePolicyEntityData(policyEntity);
+ assertEquals(result, "success");
- // Test check entity
- Connection con = null;
- List<?> peResult = Collections.emptyList();
- assertEquals(DeleteHandler.checkPolicyGroupEntity(con, peResult), false);
- }
+ // Test check entity
+ List<?> peResult = Collections.emptyList();
+ assertEquals(DeleteHandler.checkPolicyGroupEntity(peResult), false);
+ }
}
diff --git a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandlerTest.java b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandlerTest.java
index 6971ed706..3daed2455 100644
--- a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandlerTest.java
+++ b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandlerTest.java
@@ -2,14 +2,14 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2018-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -22,54 +22,63 @@ package org.onap.policy.pap.xacml.rest.handler;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import com.mockrunner.mock.web.MockHttpServletResponse;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import javax.script.SimpleBindings;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
import org.junit.Test;
-import org.junit.runner.RunWith;
import org.mockito.Mockito;
-import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
+import org.onap.policy.rest.dao.CommonClassDao;
+import org.onap.policy.rest.jpa.PolicyVersion;
import org.onap.policy.xacml.api.pap.OnapPDPGroup;
import org.onap.policy.xacml.std.pap.StdPDPGroup;
import org.onap.policy.xacml.std.pap.StdPDPPolicy;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-import com.mockrunner.mock.web.MockHttpServletRequest;
-import com.mockrunner.mock.web.MockHttpServletResponse;
-import javax.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
-import javax.persistence.EntityTransaction;
-import javax.servlet.http.HttpServletResponse;
-import javax.persistence.Query;
-@RunWith(PowerMockRunner.class)
+
public class PushPolicyHandlerTest {
- @PrepareForTest({XACMLPapServlet.class})
@Test
public void testGetsAndChecks() {
- // Mock servlet, entity mgr, transaction, and query
- EntityManager em = Mockito.mock(EntityManager.class);
- EntityManagerFactory emf = Mockito.mock(EntityManagerFactory.class);
- PowerMockito.mockStatic(XACMLPapServlet.class);
- PowerMockito.when(XACMLPapServlet.getEmf()).thenReturn(emf);
- Mockito.when(emf.createEntityManager()).thenReturn(em);
- EntityTransaction transaction = Mockito.mock(EntityTransaction.class);
- Mockito.when(em.getTransaction()).thenReturn(transaction);
- Query query = Mockito.mock(Query.class);
- Mockito.when(em.createQuery(Mockito.anyString())).thenReturn(query);
-
+ CommonClassDao commonClassDao = Mockito.mock(CommonClassDao.class);
// Test constructor
- PushPolicyHandler handler = new PushPolicyHandler();
+ PushPolicyHandler handler = new PushPolicyHandler(commonClassDao);
assertNotNull(handler);
// Test gets
- MockHttpServletRequest request = new MockHttpServletRequest();
- MockHttpServletResponse response = new MockHttpServletResponse();
+ HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+ HttpServletResponse response = Mockito.mock(MockHttpServletResponse.class);
+ Mockito.when(request.getParameter("policyScope")).thenReturn("com");
+ Mockito.when(request.getParameter("filePrefix")).thenReturn("Config_");
+ Mockito.when(request.getParameter("policyName")).thenReturn("testPush");
+ PolicyVersion version = new PolicyVersion();
+ version.setActiveVersion(1);
+ version.setCreatedBy("API");
+ version.setHigherVersion(1);
+ version.setId(1);
+ version.setModifiedBy("API");
+ version.setPolicyName("com" + File.separator + "Config_testPush");
+ List<PolicyVersion> list = new ArrayList<>();
+ list.add(version);
+
+ doNothing().when(commonClassDao).save(any(PolicyVersion.class));
+ doReturn(list).when(commonClassDao).getDataByQuery(any(String.class), any(SimpleBindings.class));
+
handler.getActiveVersion(request, response);
- assertEquals(response.getStatusCode(), HttpServletResponse.SC_OK);
- request.setupAddParameter("gitPath", "testPath");
+
+ Mockito.verify(response).setStatus(HttpServletResponse.SC_OK);
+ Mockito.verify(response).addHeader("version", "1");
+
+ request = Mockito.mock(HttpServletRequest.class);
+ response = Mockito.mock(MockHttpServletResponse.class);
+ Mockito.when(request.getParameter("gitPath")).thenReturn("testPath");
handler.getSelectedURI(request, response);
- assertEquals(response.getStatusCode(), HttpServletResponse.SC_OK);
+ Mockito.verify(response).setStatus(HttpServletResponse.SC_OK);
- // Test check
StdPDPPolicy policy = new StdPDPPolicy();
OnapPDPGroup onapPolicy = new StdPDPGroup();
String configHome = "testVal";
diff --git a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/util/JPAUtilsTest.java b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/util/JPAUtilsTest.java
index 81b5927c1..ad8f86c59 100644
--- a/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/util/JPAUtilsTest.java
+++ b/ONAP-PAP-REST/src/test/java/org/onap/policy/pap/xacml/rest/util/JPAUtilsTest.java
@@ -2,16 +2,16 @@
* ============LICENSE_START=======================================================
* ONAP-PAP-REST
* ================================================================================
- * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2018-2019 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Modifications Copyright (C) 2019 Samsung
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -24,24 +24,23 @@ package org.onap.policy.pap.xacml.rest.util;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
-import javax.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
-import javax.persistence.Query;
+import org.junit.BeforeClass;
import org.junit.Test;
-import org.mockito.Mockito;
+import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTest;
+import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl;
public class JPAUtilsTest {
+ @BeforeClass
+ public static void beforeClassSetup() {
+ PolicyDBDaoTest.setupH2DbDaoImpl("jpautilstest");
+ new JPAUtils(new CommonClassDaoImpl());
+ }
+
@Test(expected = IllegalAccessException.class)
- public void testJPAUtils() throws IllegalAccessException {
- // Setup test data
- EntityManagerFactory emf = Mockito.mock(EntityManagerFactory.class);
- EntityManager em = Mockito.mock(EntityManager.class);
- Query query = Mockito.mock(Query.class);
- Mockito.when(emf.createEntityManager()).thenReturn(em);
- Mockito.when(em.createNamedQuery(Mockito.any())).thenReturn(query);
+ public void testJpaUtils() throws IllegalAccessException {
// Test lockdown
- JPAUtils utils = JPAUtils.getJPAUtilsInstance(emf);
+ JPAUtils utils = JPAUtils.getJPAUtilsInstance();
assertEquals(utils.dbLockdownIgnoreErrors(), false);
utils.dbLockdown();
fail("Expecting an exception");