X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=ONAP-PAP-REST%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fpolicy%2Fpap%2Fxacml%2Frest%2Fcomponents%2FPolicyDbDaoTransactionInstance.java;fp=ONAP-PAP-REST%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fpolicy%2Fpap%2Fxacml%2Frest%2Fcomponents%2FPolicyDbDaoTransactionInstance.java;h=bc6c795838fa2b18a7f2c88ed92135c5c5a66e0a;hb=2903daf20f5e473a96a36342151a26e9f2e55005;hp=0000000000000000000000000000000000000000;hpb=d71b3cf8a983a95fced20eed0cb09aea84aa1b3c;p=policy%2Fengine.git 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 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(); + 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); + 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; + } +}