/*- * ============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 oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicySetType; import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; 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.PolicyAuditlog; 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; @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"; private 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 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 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(); auditPdpOperations(username, dbpolicy.getScope() + "." + dbpolicy.getPolicyName(), "Delete"); 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 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); auditPdpOperations(username, policy.getScope() + "." + policy.getPolicyName(), "Push"); 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; } public static boolean isJunit() { return isJunit; } public static void setJunit(boolean isJunit) { PolicyDbDaoTransactionInstance.isJunit = isJunit; } /** * Audit pdp operations. * * @param username the username * @param policyID the policy ID * @param action the action */ public void auditPdpOperations(String username, String policyID, String action) { PolicyAuditlog log = new PolicyAuditlog(); log.setUserName(username); log.setActions(action); log.setPolicyName(policyID); log.setDateAndTime(new Date()); session.save(log); } }