2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.onap.policy.pap.xacml.rest.components;
23 import java.io.ByteArrayInputStream;
25 import java.io.FileInputStream;
26 import java.io.FileNotFoundException;
27 import java.io.FileWriter;
28 import java.io.IOException;
29 import java.io.InputStream;
30 import java.io.StringReader;
31 import java.net.HttpURLConnection;
32 import java.net.MalformedURLException;
33 import java.net.ProtocolException;
36 import java.nio.charset.StandardCharsets;
37 import java.nio.file.Files;
38 import java.nio.file.InvalidPathException;
39 import java.nio.file.Path;
40 import java.nio.file.Paths;
41 import java.util.Base64;
42 import java.util.Date;
43 import java.util.HashMap;
44 import java.util.HashSet;
45 import java.util.Iterator;
46 import java.util.LinkedList;
47 import java.util.List;
50 import java.util.UUID;
52 import javax.persistence.EntityManager;
53 import javax.persistence.EntityManagerFactory;
54 import javax.persistence.LockModeType;
55 import javax.persistence.PersistenceException;
56 import javax.persistence.Query;
57 import javax.persistence.RollbackException;
58 import javax.xml.parsers.DocumentBuilder;
59 import javax.xml.parsers.DocumentBuilderFactory;
60 import javax.xml.xpath.XPath;
61 import javax.xml.xpath.XPathFactory;
63 import org.apache.commons.io.FilenameUtils;
64 import org.apache.commons.io.IOUtils;
65 import org.onap.policy.common.logging.eelf.MessageCodes;
66 import org.onap.policy.common.logging.eelf.PolicyLogger;
67 import org.onap.policy.common.logging.flexlogger.FlexLogger;
68 import org.onap.policy.common.logging.flexlogger.Logger;
69 import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
70 import org.onap.policy.rest.XACMLRestProperties;
71 import org.onap.policy.rest.adapter.PolicyRestAdapter;
72 import org.onap.policy.rest.dao.PolicyDBException;
73 import org.onap.policy.rest.jpa.ActionBodyEntity;
74 import org.onap.policy.rest.jpa.ConfigurationDataEntity;
75 import org.onap.policy.rest.jpa.DatabaseLockEntity;
76 import org.onap.policy.rest.jpa.GroupEntity;
77 import org.onap.policy.rest.jpa.PdpEntity;
78 import org.onap.policy.rest.jpa.PolicyDBDaoEntity;
79 import org.onap.policy.rest.jpa.PolicyEntity;
80 import org.onap.policy.utils.CryptoUtils;
81 import org.onap.policy.xacml.api.pap.OnapPDP;
82 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
83 import org.onap.policy.xacml.api.pap.PAPPolicyEngine;
84 import org.onap.policy.xacml.std.pap.StdPDPGroup;
85 import org.onap.policy.xacml.std.pap.StdPDPPolicy;
86 import org.onap.policy.xacml.util.XACMLPolicyWriter;
87 import org.w3c.dom.Document;
88 import org.xml.sax.InputSource;
90 import com.att.research.xacml.api.pap.PAPException;
91 import com.att.research.xacml.api.pap.PDP;
92 import com.att.research.xacml.api.pap.PDPPolicy;
93 import com.att.research.xacml.util.XACMLProperties;
95 import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
97 public class PolicyDBDao {
98 private static final Logger logger = FlexLogger.getLogger(PolicyDBDao.class);
99 private List<?> otherServers;
100 private EntityManagerFactory emf;
101 private static PolicyDBDao currentInstance = null;
102 private PAPPolicyEngine papEngine;
104 public static final String JSON_CONFIG = "JSON";
105 public static final String XML_CONFIG = "XML";
106 public static final String PROPERTIES_CONFIG = "PROPERTIES";
107 public static final String OTHER_CONFIG = "OTHER";
108 public static final String AUDIT_USER = "audit";
110 //Declared to static variables which were repeating multiple times across the PolicyDBDao
111 public static final String config = "Config";
112 public static final String action = "Action";
113 public static final String groupIdVar = "groupId";
114 public static final String deletedVar = "deleted";
115 public static final String groupEntitySelectQuery = "SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted";
116 public static final String pdpEntitySelectQuery = "SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted";
117 public static final String groupCannotBeFound = "The group could not be found with id ";
118 public static final String foundInDBNotDeleted = " were found in the database that are not deleted";
119 public static final String moreThanOnePDP = "Somehow, more than one pdp with the same id ";
120 public static final String deletedStatusFound = " and deleted status were found in the database";
121 public static final String duplicateGroupId = "Somehow, more than one group with the same id ";
122 public static final String pdpIdVariable = "pdpId";
123 public static final String queryFailedToCheckExisting = "Query failed trying to check for existing group";
124 public static final String queryFailedToGetGroup = "Query failed trying to get group ";
125 public static final String scope = "scope";
126 public static final String policyDBDaoVar = "PolicyDBDao";
127 public static final String duplicatePolicyId = "Somehow, more than one policy with the id ";
128 public static final String foundInDB = " were found in the database";
130 private static boolean isJunit = false;
132 public static void setJunit(boolean isJunit) {
133 PolicyDBDao.isJunit = isJunit;
137 * Get an instance of a PolicyDBDao. It creates one if it does not exist.
138 * Only one instance is allowed to be created per server.
139 * @param emf The EntityFactoryManager to be used for database connections
140 * @return The new instance of PolicyDBDao or throw exception if the given emf is null.
141 * @throws IllegalStateException if a PolicyDBDao has already been constructed. Call getPolicyDBDaoInstance() to get this.
143 public static PolicyDBDao getPolicyDBDaoInstance(EntityManagerFactory emf){
144 logger.debug("getPolicyDBDaoInstance(EntityManagerFactory emf) as getPolicyDBDaoInstance("+emf+") called");
145 if(currentInstance == null){
147 currentInstance = new PolicyDBDao(emf);
148 return currentInstance;
150 throw new IllegalStateException("The EntityManagerFactory is Null");
152 return currentInstance;
156 * Gets the current instance of PolicyDBDao.
157 * @return The instance of PolicyDBDao or throws exception if the given instance is null.
158 * @throws IllegalStateException if a PolicyDBDao instance is null. Call createPolicyDBDaoInstance(EntityManagerFactory emf) to get this.
160 public static PolicyDBDao getPolicyDBDaoInstance(){
161 logger.debug("getPolicyDBDaoInstance() as getPolicyDBDaoInstance() called");
162 if(currentInstance != null){
163 return currentInstance;
165 throw new IllegalStateException("The PolicyDBDao.currentInstance is Null. Use getPolicyDBDao(EntityManagerFactory emf)");
168 public void setPapEngine(PAPPolicyEngine papEngine2){
169 this.papEngine = papEngine2;
172 private PolicyDBDao(EntityManagerFactory emf){
173 logger.debug("PolicyDBDao(EntityManagerFactory emf) as PolicyDBDao("+emf+") called");
176 //not needed in this release
178 PolicyLogger.error("This server's PolicyDBDao instance could not be registered and may not reveive updates");
181 otherServers = getRemotePolicyDBDaoList();
182 if(logger.isDebugEnabled()){
183 logger.debug("Number of remote PolicyDBDao instances: "+otherServers.size());
185 if(otherServers.isEmpty()){
186 logger.warn("List of PolicyDBDao servers is empty or could not be retrieved");
190 //not static because we are going to be using the instance's emf
191 //waitTime in ms to wait for lock, or -1 to wait forever (no)
192 private void startTransactionSynced(EntityManager entityMgr,int waitTime){
193 logger.debug("\n\nstartTransactionSynced(EntityManager entityMgr,int waitTime) as "
194 + "\n startTransactionSynced("+entityMgr+","+waitTime+") called\n\n");
195 DatabaseLockEntity lock = null;
197 entityMgr.setProperty("javax.persistence.query.timeout", waitTime);
198 entityMgr.getTransaction().begin();
200 if(logger.isDebugEnabled()){
201 Map<String,Object> properties = entityMgr.getProperties();
202 logger.debug("\n\nstartTransactionSynced():"
203 + "\n entityManager.getProperties() = " + properties
207 if(logger.isDebugEnabled()){
208 logger.debug("\n\nstartTransactionSynced():"
209 + "\n ATTEMPT to get the DB lock"
212 lock = entityMgr.find(DatabaseLockEntity.class, 1, LockModeType.PESSIMISTIC_WRITE);
213 if(logger.isDebugEnabled()){
214 logger.debug("\n\nstartTransactionSynced():"
215 + "\n GOT the DB lock"
218 } catch(Exception e){
219 System.out.println("Could not get lock entity");
220 logger.error("Exception Occured"+e);
223 throw new IllegalStateException("The lock row does not exist in the table. Please create a primary key with value = 1.");
228 * Gets the list of other registered PolicyDBDaos from the database
229 * @return List (type PolicyDBDaoEntity) of other PolicyDBDaos
231 private List<?> getRemotePolicyDBDaoList(){
232 logger.debug("getRemotePolicyDBDaoList() as getRemotePolicyDBDaoList() called");
233 List<?> policyDBDaoEntityList = new LinkedList<>();
234 EntityManager em = emf.createEntityManager();
235 startTransactionSynced(em, 1000);
237 Query getPolicyDBDaoEntityQuery = em.createNamedQuery("PolicyDBDaoEntity.findAll");
238 policyDBDaoEntityList = getPolicyDBDaoEntityQuery.getResultList();
240 } catch(Exception e){
241 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Exception querying for other registered PolicyDBDaos");
242 logger.warn("List of remote PolicyDBDaos will be empty", e);
245 em.getTransaction().commit();
246 } catch(Exception e){
247 logger.warn("List of remote PolicyDBDaos will be empty", e);
249 em.getTransaction().rollback();
250 } catch(Exception e2){
251 logger.debug("List of remote PolicyDBDaos will be empty", e2);
255 return policyDBDaoEntityList;
258 public PolicyDBDaoTransaction getNewTransaction(){
259 logger.debug("getNewTransaction() as getNewTransaction() called");
260 return new PolicyDBDaoTransactionInstance();
264 * Because the normal transactions are not used in audits, we can use the same transaction
265 * mechanism to get a transaction and obtain the emlock and the DB lock. We just need to
266 * provide different transaction timeout values in ms because the audit will run longer
267 * than normal transactions.
269 public PolicyDBDaoTransaction getNewAuditTransaction(){
270 logger.debug("getNewAuditTransaction() as getNewAuditTransaction() called");
271 //Use the standard transaction wait time in ms
272 int auditWaitMs = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT));
273 //Use the (extended) audit timeout time in ms
274 int auditTimeoutMs = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_AUDIT_TIMEOUT));
275 return new PolicyDBDaoTransactionInstance(auditTimeoutMs, auditWaitMs);
280 * Checks if two strings are equal. Null strings ARE allowed.
281 * @param one A String or null to compare
282 * @param two A String or null to compare
284 private static boolean stringEquals(String one, String two){
285 logger.debug("stringEquals(String one, String two) as stringEquals("+one+", "+two+") called");
286 if(one == null && two == null){
289 if(one == null || two == null){
292 return one.equals(two);
296 * Returns the url of this local pap server, removing the username and password, if they are present
297 * @return The url of this local pap server
299 private String[] getPapUrlUserPass(){
300 logger.debug("getPapUrl() as getPapUrl() called");
301 String url = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_URL);
305 return splitPapUrlUserPass(url);
308 private String[] splitPapUrlUserPass(String url){
309 String[] urlUserPass = new String[3];
310 String[] commaSplit = url.split(",");
311 urlUserPass[0] = commaSplit[0];
312 if(commaSplit.length > 2){
313 urlUserPass[1] = commaSplit[1];
314 urlUserPass[2] = commaSplit[2];
316 if(urlUserPass[1] == null || "".equals(urlUserPass[1])){
317 String usernamePropertyValue = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_USERID);
318 if(usernamePropertyValue != null){
319 urlUserPass[1] = usernamePropertyValue;
322 if(urlUserPass[2] == null || "".equals(urlUserPass[2])){
323 String passwordPropertyValue = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_PASS);
324 if(passwordPropertyValue != null){
325 urlUserPass[2] = passwordPropertyValue;
328 //if there is no comma, for some reason there is no username and password, so don't try to cut them off
333 * Register the PolicyDBDao instance in the PolicyDBDaoEntity table
334 * @return Boolean, were we able to register?
336 private boolean register(){
337 logger.debug("register() as register() called");
338 String[] url = getPapUrlUserPass();
339 //--- check URL length
340 if(url == null || url.length<3){
343 EntityManager em = emf.createEntityManager();
345 startTransactionSynced(em, 1000);
346 } catch(IllegalStateException e){
347 logger.debug ("\nPolicyDBDao.register() caught an IllegalStateException: \n" +e + "\n");
348 DatabaseLockEntity lock;
349 lock = em.find(DatabaseLockEntity.class, 1);
351 lock = new DatabaseLockEntity();
356 em.getTransaction().commit();
358 } catch(Exception e2){
359 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, policyDBDaoVar, "COULD NOT CREATE DATABASELOCK ROW. WILL TRY ONE MORE TIME");
362 em = emf.createEntityManager();
364 startTransactionSynced(em, 1000);
365 } catch(Exception e3){
366 String msg = "DATABASE LOCKING NOT WORKING. CONCURRENCY CONTROL NOT WORKING";
367 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e3, policyDBDaoVar, msg);
368 throw new IllegalStateException("msg" + "\n" + e3);
372 logger.debug("\nPolicyDBDao.register. Database locking and concurrency control is initialized\n");
373 PolicyDBDaoEntity foundPolicyDBDaoEntity = em.find(PolicyDBDaoEntity.class, url[0]);
374 Query getPolicyDBDaoEntityQuery = em.createQuery("SELECT e FROM PolicyDBDaoEntity e WHERE e.policyDBDaoUrl=:url");
375 getPolicyDBDaoEntityQuery.setParameter("url", url[0]);
376 // encrypt the password
379 txt = CryptoUtils.encryptTxt(url[2].getBytes(StandardCharsets.UTF_8));
380 } catch(Exception e){
382 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Could not encrypt PAP password");
384 if(foundPolicyDBDaoEntity == null){
385 PolicyDBDaoEntity newPolicyDBDaoEntity = new PolicyDBDaoEntity();
386 em.persist(newPolicyDBDaoEntity);
387 newPolicyDBDaoEntity.setPolicyDBDaoUrl(url[0]);
388 newPolicyDBDaoEntity.setDescription("PAP server at "+url[0]);
389 newPolicyDBDaoEntity.setUsername(url[1]);
390 newPolicyDBDaoEntity.setPassword(txt);
392 em.getTransaction().commit();
393 } catch(Exception e){
396 em.getTransaction().rollback();
397 } catch(Exception e2){
399 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, policyDBDaoVar, "Could not add new PolicyDBDao to the database");
403 //just want to update in order to change modified date
404 if(url[1] != null && !stringEquals(url[1], foundPolicyDBDaoEntity.getUsername())){
405 foundPolicyDBDaoEntity.setUsername(url[1]);
407 if(txt != null && !stringEquals(txt, foundPolicyDBDaoEntity.getPassword())){
408 foundPolicyDBDaoEntity.setPassword(txt);
410 foundPolicyDBDaoEntity.preUpdate();
412 em.getTransaction().commit();
413 } catch(Exception e){
416 em.getTransaction().rollback();
417 } catch(Exception e2){
419 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, policyDBDaoVar, "Could not update PolicyDBDao in the database");
424 logger.debug("\nPolicyDBDao.register(). Success!!\n");
428 public void notifyOthers(long entityId,String entityType){
429 notifyOthers(entityId,entityType,null);
432 public void notifyOthers(long entityId, String entityType, String newGroupId){
433 logger.debug("notifyOthers(long entityId, String entityType, long newGroupId) as notifyOthers("+entityId+","+entityType+","+newGroupId+") called");
434 LinkedList<Thread> notifyThreads = new LinkedList<>();
436 //we're going to run notifications in parallel threads to speed things up
437 for(Object obj : otherServers){
438 Thread newNotifyThread = new Thread(new NotifyOtherThread(obj, entityId, entityType, newGroupId));
439 newNotifyThread.start();
440 notifyThreads.add(newNotifyThread);
442 //we want to wait for all notifications to complete or timeout before we unlock the interface and allow more changes
443 for(Thread t : notifyThreads){
446 } catch (Exception e) {
447 logger.warn("Could not join a notifcation thread" + e);
452 private class NotifyOtherThread implements Runnable {
453 public NotifyOtherThread(Object obj, long entityId, String entityType, String newGroupId){
455 this.entityId = entityId;
456 this.entityType = entityType;
457 this.newGroupId = newGroupId;
460 private long entityId;
461 private String entityType;
462 private String newGroupId;
465 //naming of 'o' is for backwards compatibility with the rest of the function
466 PolicyDBDaoEntity dbdEntity = (PolicyDBDaoEntity)obj;
467 String o = dbdEntity.getPolicyDBDaoUrl();
468 String username = dbdEntity.getUsername();
471 txt = new String(CryptoUtils.decryptTxt(dbdEntity.getPassword()), StandardCharsets.UTF_8);
472 } catch(Exception e){
474 //if we can't decrypt, might as well try it anyway
475 txt = dbdEntity.getPassword();
477 Base64.Encoder encoder = Base64.getEncoder();
478 String encoding = encoder.encodeToString((username+":"+txt).getBytes(StandardCharsets.UTF_8));
479 HttpURLConnection connection = null;
480 UUID requestID = UUID.randomUUID();
484 String[] papUrlUserPass = getPapUrlUserPass();
485 if(papUrlUserPass == null ){
486 papUrl = "undefined";
488 papUrl = papUrlUserPass[0];
490 logger.debug("We are going to try to notify "+o);
491 //is this our own url?
494 ourUrl = splitPapUrlUserPass((String)o)[0];
502 if(papUrl.equals(ourUrl)){
503 logger.debug(o+" is our url, skipping notify");
506 if(newGroupId == null){
507 url = new URL(o+"?policydbdaourl="+papUrl+"&entityid="+entityId+"&entitytype="+entityType);
509 url = new URL(o+"?policydbdaourl="+papUrl+"&entityid="+entityId+"&entitytype="+entityType+"&extradata="+newGroupId);
511 } catch (MalformedURLException e) {
512 logger.warn("Caught MalformedURLException on: new URL()", e);
516 // Open up the connection
518 logger.info("PolicyDBDao: NotifyOtherThread: notifying other PAPs of an update");
519 logger.info("Connecting with url: "+url);
521 connection = (HttpURLConnection)url.openConnection();
522 } catch (Exception e) {
523 logger.warn("Caught exception on: url.openConnection()",e);
527 // Setup our method and headers
530 connection.setRequestMethod("PUT");
531 } catch (ProtocolException e) {
532 //why would this error ever occur?
533 logger.warn("Caught ProtocolException on connection.setRequestMethod(\"PUT\");",e);
536 connection.setRequestProperty("Authorization", "Basic " + encoding);
537 connection.setRequestProperty("Accept", "text/x-java-properties");
538 connection.setRequestProperty("Content-Type", "text/x-java-properties");
539 connection.setRequestProperty("requestID", requestID.toString());
542 readTimeout = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_NOTIFY_TIMEOUT));
543 } catch(Exception e){
544 logger.error("xacml.rest.pap.notify.timeoutms property not set, using a default.", e);
547 connection.setReadTimeout(readTimeout);
548 connection.setConnectTimeout(readTimeout);
549 connection.setUseCaches(false);
551 // Adding this in. It seems the HttpUrlConnection class does NOT
552 // properly forward our headers for POST re-direction. It does so
553 // for a GET re-direction.
555 // So we need to handle this ourselves.
557 connection.setInstanceFollowRedirects(false);
558 connection.setDoOutput(true);
559 connection.setDoInput(true);
561 connection.connect();
562 } catch (Exception e) {
563 logger.warn("Caught exception on: connection.connect()",e);
567 if (connection.getResponseCode() == 200) {
568 logger.info("PolicyDBDao: NotifyOtherThread received response 200 from pap server on notify");
570 logger.warn("PolicyDBDao: NotifyOtherThread connection response code not 200, received: "+connection.getResponseCode());
572 } catch (Exception e) {
573 logger.warn("Caught Exception on: connection.getResponseCode() ", e);
576 connection.disconnect();
580 private static String evaluateXPath(String expression, String xml) {
581 InputSource source = new InputSource(new StringReader(xml));
583 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
584 String description = "";
586 DocumentBuilder db = dbf.newDocumentBuilder();
587 Document document = db.parse(source);
589 XPathFactory xpathFactory = XPathFactory.newInstance();
590 XPath xpath = xpathFactory.newXPath();
592 description = xpath.evaluate(expression, document);
594 logger.error("Exception Occured while evaluating path"+e);
599 private static final String POLICY_NOTIFICATION = "policy";
600 private static final String PDP_NOTIFICATION = "pdp";
601 private static final String GROUP_NOTIFICATION = "group";
602 public void handleIncomingHttpNotification(String url, String entityId, String entityType, String extraData, XACMLPapServlet xacmlPapServlet){
603 logger.info("DBDao url: " + url + " has reported an update on "+entityType+" entity "+entityId);
604 PolicyDBDaoTransaction transaction = this.getNewTransaction();
605 //although its named retries, this is the total number of tries
608 retries = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_INCOMINGNOTIFICATION_TRIES));
609 } catch(Exception e){
610 logger.error("xacml.rest.pap.incomingnotification.tries property not set, using a default of 3."+e);
613 //if someone sets it to some dumb value, we need to make sure it will try at least once
617 int pauseBetweenRetries = 1000;
620 case POLICY_NOTIFICATION:
621 for(int i=0; i<retries;i++){
623 handleIncomingPolicyChange(entityId);
625 } catch(Exception e){
627 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught exception on handleIncomingPolicyChange("+url+", "+entityId+", "+extraData+")");
630 Thread.sleep(pauseBetweenRetries);
631 }catch(InterruptedException ie){
632 Thread.currentThread().interrupt();
637 case PDP_NOTIFICATION:
638 for(int i=0; i<retries;i++){
640 handleIncomingPdpChange(entityId, transaction);
642 } catch(Exception e){
644 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught exception on handleIncomingPdpChange("+url+", "+entityId+", "+transaction+")");
647 Thread.sleep(pauseBetweenRetries);
648 }catch(InterruptedException ie){
649 Thread.currentThread().interrupt();
654 case GROUP_NOTIFICATION:
655 for(int i=0; i<retries;i++){
657 handleIncomingGroupChange(entityId, extraData, transaction);
661 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught exception on handleIncomingGroupChange("+url+", "+entityId+", "+extraData+", "+transaction+", "+xacmlPapServlet+")");
664 Thread.sleep(pauseBetweenRetries);
665 }catch(InterruptedException ie){
666 Thread.currentThread().interrupt();
672 //no changes should be being made in this function, we still need to close
673 transaction.rollbackTransaction();
676 private void handleIncomingGroupChange(String groupId, String extraData,PolicyDBDaoTransaction transaction) throws PAPException, PolicyDBException{
677 GroupEntity groupRecord = null;
678 long groupIdLong = -1;
680 groupIdLong = Long.parseLong(groupId);
681 } catch(NumberFormatException e){
682 throw new IllegalArgumentException("groupId "+groupId+" cannot be parsed into a long");
685 groupRecord = transaction.getGroup(groupIdLong);
686 } catch(Exception e){
687 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to get pdp group record with transaction.getGroup("+groupIdLong+");");
688 throw new PAPException("Could not get local group "+groupIdLong);
690 if(groupRecord == null){
691 throw new PersistenceException("The group record returned is null");
693 //compare to local fs
694 //does group folder exist
695 OnapPDPGroup localGroup = null;
697 localGroup = papEngine.getGroup(groupRecord.getGroupId());
698 } catch (Exception e) {
699 logger.warn("Caught PAPException trying to get local pdp group with papEngine.getGroup("+groupId+");",e);
701 if(localGroup == null && extraData != null){
702 //here we can try to load an old group id from the extraData
704 localGroup = papEngine.getGroup(extraData);
706 logger.warn("Caught PAPException trying to get local pdp group with papEngine.getGroup("+extraData+");",e);
709 if(localGroup != null && groupRecord.isDeleted()){
710 OnapPDPGroup newLocalGroup = null;
711 if(extraData != null){
713 newLocalGroup = papEngine.getGroup(extraData);
714 } catch (PAPException e) {
715 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to get new pdp group with papEngine.getGroup("+extraData+");");
719 papEngine.removeGroup(localGroup, newLocalGroup);
720 } catch (NullPointerException | PAPException e) {
721 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to get remove pdp group with papEngine.removeGroup("+localGroup+", "+newLocalGroup+");");
722 throw new PAPException("Could not remove group "+groupId);
725 else if(localGroup == null){
726 //creating a new group
728 papEngine.newGroup(groupRecord.getgroupName(), groupRecord.getDescription());
729 } catch (NullPointerException | PAPException e) {
730 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to create pdp group with papEngine.newGroup(groupRecord.getgroupName(), groupRecord.getDescription());");
731 throw new PAPException("Could not create group "+groupRecord);
734 localGroup = papEngine.getGroup(groupRecord.getGroupId());
735 } catch (PAPException e1) {
736 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, policyDBDaoVar, "Caught PAPException trying to get pdp group we just created with papEngine.getGroup(groupRecord.getGroupId());\nAny PDPs or policies in the new group may not have been added");
739 //add possible pdps to group
740 List<?> pdpsInGroup = transaction.getPdpsInGroup(Long.parseLong(groupRecord.getGroupId()));
741 for(Object pdpO : pdpsInGroup){
742 PdpEntity pdp = (PdpEntity)pdpO;
744 papEngine.newPDP(pdp.getPdpId(), localGroup, pdp.getPdpName(), pdp.getDescription(), pdp.getJmxPort());
745 } catch (NullPointerException | PAPException e) {
746 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to get create pdp with papEngine.newPDP(pdp.getPdpId(), localGroup, pdp.getPdpName(), pdp.getDescription(), pdp.getJmxPort());");
747 throw new PAPException("Could not create pdp "+pdp);
750 //add possible policies to group (filesystem only, apparently)
752 if(!(localGroup instanceof StdPDPGroup)){
753 throw new PAPException("group is not a StdPDPGroup");
756 //because it will be comparing the new group to its own version
757 StdPDPGroup localGroupClone = new StdPDPGroup(localGroup.getId(),localGroup.isDefaultGroup(),localGroup.getName(),localGroup.getDescription(),((StdPDPGroup)localGroup).getDirectory());
758 localGroupClone.setOnapPdps(localGroup.getOnapPdps());
759 localGroupClone.setPipConfigs(localGroup.getPipConfigs());
760 localGroupClone.setStatus(localGroup.getStatus());
761 //we are updating a group or adding a policy or changing default
762 //set default if it should be
763 if(!localGroupClone.isDefaultGroup() && groupRecord.isDefaultGroup()){
765 papEngine.setDefaultGroup(localGroup);
767 } catch (PAPException e) {
768 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to set default group with papEngine.SetDefaultGroup("+localGroupClone+");");
769 throw new PAPException("Could not set default group to "+localGroupClone);
772 boolean needToUpdate = false;
773 if(updateGroupPoliciesInFileSystem(localGroupClone,localGroup, groupRecord, transaction)){
776 if(!stringEquals(localGroupClone.getId(),groupRecord.getGroupId()) || !stringEquals(localGroupClone.getName(),groupRecord.getgroupName())){
778 //we do not want to change the id, the papEngine will do this for us, it needs to know the old id
779 localGroupClone.setName(groupRecord.getgroupName());
782 if(!stringEquals(localGroupClone.getDescription(),groupRecord.getDescription())){
783 localGroupClone.setDescription(groupRecord.getDescription());
788 papEngine.updateGroup(localGroupClone);
789 } catch (PAPException e) {
790 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to update group with papEngine.updateGroup("+localGroupClone+");");
791 throw new PAPException("Could not update group "+localGroupClone);
797 //this will also handle removes, since incoming pdpGroup has no policies internally, we are just going to add them all in from the db
798 private boolean updateGroupPoliciesInFileSystem(OnapPDPGroup pdpGroup,OnapPDPGroup oldPdpGroup, GroupEntity groupRecord, PolicyDBDaoTransaction transaction) throws PAPException, PolicyDBException{
799 if(!(pdpGroup instanceof StdPDPGroup)){
800 throw new PAPException("group is not a StdPDPGroup");
802 StdPDPGroup group = (StdPDPGroup)pdpGroup;
803 //this must always be true since we don't explicitly know when a delete is occuring
804 boolean didUpdate = true;
805 HashMap<String,PDPPolicy> currentPolicySet = new HashMap<>(oldPdpGroup.getPolicies().size());
806 HashSet<PDPPolicy> newPolicySet = new HashSet<>();
807 for(PDPPolicy pdpPolicy : oldPdpGroup.getPolicies()){
808 currentPolicySet.put(pdpPolicy.getId(), pdpPolicy);
810 for(PolicyEntity policy : groupRecord.getPolicies()){
811 String pdpPolicyName = getPdpPolicyName(policy.getPolicyName(), policy.getScope());
812 if(group.getPolicy(pdpPolicyName) == null){
814 if(currentPolicySet.containsKey(pdpPolicyName)){
815 newPolicySet.add(currentPolicySet.get(pdpPolicyName));
817 logger.info("PolicyDBDao: Adding the new policy to the PDP group after notification: " + pdpPolicyName);
818 InputStream policyStream = new ByteArrayInputStream(policy.getPolicyData().getBytes());
819 group.copyPolicyToFile(pdpPolicyName,policyStream);
820 ((StdPDPPolicy)(group.getPolicy(pdpPolicyName))).setName(removeExtensionAndVersionFromPolicyName(pdpPolicyName));
822 policyStream.close();
823 } catch (IOException e) {
825 PolicyLogger.error(e.getMessage() +e);
830 logger.info("PolicyDBDao: Adding updated policies to group after notification.");
832 newPolicySet.addAll(group.getPolicies());
833 group.setPolicies(newPolicySet);
839 * This method is called during all pushPolicy transactions and makes sure the file system
840 * group is in sync with the database groupentity
842 private StdPDPGroup synchronizeGroupPoliciesInFileSystem(StdPDPGroup pdpGroup, GroupEntity groupentity) throws PAPException, PolicyDBException{
844 HashMap<String,PDPPolicy> currentPolicyMap = new HashMap<>();
845 HashSet<String> newPolicyIdSet = new HashSet<>();
846 HashSet<PDPPolicy> newPolicySet = new HashSet<>();
848 for(PDPPolicy pdpPolicy : pdpGroup.getPolicies()){
849 currentPolicyMap.put(pdpPolicy.getId(), pdpPolicy);
852 for(PolicyEntity policy : groupentity.getPolicies()){
853 String pdpPolicyId = getPdpPolicyName(policy.getPolicyName(), policy.getScope());
854 newPolicyIdSet.add(pdpPolicyId);
856 if(currentPolicyMap.containsKey(pdpPolicyId)){
857 newPolicySet.add(currentPolicyMap.get(pdpPolicyId));
859 //convert PolicyEntity object to PDPPolicy
860 String name = pdpPolicyId.replace(".xml", "");
861 name = name.substring(0, name.lastIndexOf('.'));
862 InputStream policyStream = new ByteArrayInputStream(policy.getPolicyData().getBytes());
863 pdpGroup.copyPolicyToFile(pdpPolicyId,name,policyStream);
864 URI location = Paths.get(pdpGroup.getDirectory().toAbsolutePath().toString(), pdpPolicyId).toUri();
865 StdPDPPolicy newPolicy = null;
867 newPolicy = new StdPDPPolicy(pdpPolicyId, true, removeExtensionAndVersionFromPolicyName(pdpPolicyId),location);
868 newPolicySet.add(newPolicy);
869 } catch (Exception e) {
871 PolicyLogger.error("PolicyDBDao: Exception occurred while creating the StdPDPPolicy newPolicy object " + e.getMessage());
876 for(String id : currentPolicyMap.keySet()) {
877 if(!newPolicyIdSet.contains(id)){
879 Files.delete(Paths.get(currentPolicyMap.get(id).getLocation()));
880 } catch (Exception e) {
882 PolicyLogger.error("PolicyDBDao: Exception occurred while attempting to delete the old version of the policy file from the group. " + e.getMessage());
887 logger.info("PolicyDBDao: Adding new policy set to group to keep filesystem and DB in sync");
888 pdpGroup.setPolicies(newPolicySet);
893 private String removeExtensionAndVersionFromPolicyName(String originalPolicyName) throws PolicyDBException{
894 return getPolicyNameAndVersionFromPolicyFileName(originalPolicyName)[0];
898 * Splits apart the policy name and version from a policy file path
899 * @param originalPolicyName: a policy file name ex: Config_policy.2.xml
900 * @return An array [0]: The policy name, [1]: the policy version, as a string
902 private String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName) throws PolicyDBException{
903 String policyName = originalPolicyName;
904 String[] nameAndVersion = new String[2];
906 policyName = removeFileExtension(policyName);
907 nameAndVersion[0] = policyName.substring(0,policyName.lastIndexOf('.'));
908 if(isNullOrEmpty(nameAndVersion[0])){
909 throw new PolicyDBException();
911 } catch(Exception e){
912 nameAndVersion[0] = originalPolicyName;
916 nameAndVersion[1] = policyName.substring(policyName.lastIndexOf('.')+1);
917 if(isNullOrEmpty(nameAndVersion[1])){
918 throw new PolicyDBException();
920 } catch(Exception e){
921 nameAndVersion[1] = "1";
924 return nameAndVersion;
927 private void handleIncomingPdpChange(String pdpId, PolicyDBDaoTransaction transaction) throws PAPException{
931 pdpIdLong = Long.parseLong(pdpId);
932 }catch(NumberFormatException e){
933 throw new IllegalArgumentException("pdpId "+pdpId+" cannot be parsed into a long");
935 PdpEntity pdpRecord = null;
937 pdpRecord = transaction.getPdp(pdpIdLong);
939 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to get pdp record with transaction.getPdp("+pdpIdLong+");");
940 throw new PAPException("Could not get local pdp "+pdpIdLong);
942 if(pdpRecord == null){
943 throw new PersistenceException("The pdpRecord returned is null");
947 localPdp = papEngine.getPDP(pdpRecord.getPdpId());
948 } catch (PAPException e) {
949 logger.warn("Caught PAPException trying to get local pdp with papEngine.getPDP("+pdpId+");",e);
951 if(localPdp != null && pdpRecord.isDeleted()){
953 papEngine.removePDP((OnapPDP) localPdp);
954 } catch (PAPException e) {
955 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to get remove pdp with papEngine.removePDP("+localPdp+");");
956 throw new PAPException("Could not remove pdp "+pdpId);
959 else if(localPdp == null){
962 OnapPDPGroup localGroup = null;
964 localGroup = papEngine.getGroup(pdpRecord.getGroup().getGroupId());
965 } catch (PAPException e1) {
966 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, policyDBDaoVar, "Caught PAPException trying to get local group to add pdp to with papEngine.getGroup(pdpRecord.getGroup().getGroupId());");
967 throw new PAPException("Could not get local group");
970 papEngine.newPDP(pdpRecord.getPdpId(), localGroup, pdpRecord.getPdpName(), pdpRecord.getDescription(), pdpRecord.getJmxPort());
971 } catch (NullPointerException | PAPException e) {
972 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to create pdp with papEngine.newPDP("+pdpRecord.getPdpId()+", "+localGroup+", "+pdpRecord.getPdpName()+", "+pdpRecord.getDescription()+", "+pdpRecord.getJmxPort()+");");
973 throw new PAPException("Could not create pdp "+pdpRecord);
976 boolean needToUpdate = false;
977 if(!stringEquals(localPdp.getId(),pdpRecord.getPdpId()) || !stringEquals(localPdp.getName(),pdpRecord.getPdpName())){
978 //again, we don't want to change the id, the papEngine will do this
979 localPdp.setName(pdpRecord.getPdpName());
982 if(!stringEquals(localPdp.getDescription(),pdpRecord.getDescription())){
983 localPdp.setDescription(pdpRecord.getDescription());
986 String localPdpGroupId = null;
988 localPdpGroupId = papEngine.getPDPGroup((OnapPDP) localPdp).getId();
989 } catch(PAPException e){
990 //could be null or something, just warn at this point
991 logger.warn("Caught PAPException trying to get id of local group that pdp is in with localPdpGroupId = papEngine.getPDPGroup(localPdp).getId();",e);
993 if(!stringEquals(localPdpGroupId,pdpRecord.getGroup().getGroupId())){
994 OnapPDPGroup newPdpGroup = null;
996 newPdpGroup = papEngine.getGroup(pdpRecord.getGroup().getGroupId());
997 }catch(PAPException e){
998 //ok, now we have an issue. Time to stop things
999 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to get id of local group to move pdp to with papEngine.getGroup(pdpRecord.getGroup().getGroupId());");
1000 throw new PAPException("Could not get local group");
1003 papEngine.movePDP((OnapPDP) localPdp, newPdpGroup);
1004 }catch(PAPException e){
1005 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to move pdp with papEngine.movePDP(localPdp, newPdpGroup);");
1006 throw new PAPException("Could not move pdp "+localPdp);
1009 if(((PdpEntity) localPdp).getJmxPort() != pdpRecord.getJmxPort()){
1010 ((PdpEntity) localPdp).setJmxPort(pdpRecord.getJmxPort());
1011 needToUpdate = true;
1015 papEngine.updatePDP((OnapPDP) localPdp);
1016 } catch (PAPException e) {
1017 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PAPException trying to update pdp with papEngine.updatePdp("+localPdp+");");
1018 throw new PAPException("Could not update pdp "+localPdp);
1022 //compare to local situation
1023 //call command to update
1025 private void handleIncomingPolicyChange(String policyId){
1026 String policyName = null;
1027 EntityManager em = emf.createEntityManager();
1028 Query getPolicyEntityQuery = em.createNamedQuery("PolicyEntity.FindById");
1029 getPolicyEntityQuery.setParameter("id", Long.valueOf(policyId));
1031 @SuppressWarnings("unchecked")
1032 List<PolicyEntity> policies = getPolicyEntityQuery.getResultList();
1033 PolicyEntity policy = null;
1034 if (!policies.isEmpty()){
1035 policy = policies.get(0);
1037 String action = "unknown action";
1040 policyName = policy.getPolicyName();
1041 logger.info("Deleting old Policy Config File for " + policy.getPolicyName());
1043 Path subFile = null;
1045 if (policy.getConfigurationData()!= null){
1046 subFile = getPolicySubFile(policy.getConfigurationData().getConfigurationName(), config);
1047 }else if(policy.getActionBodyEntity()!= null){
1048 subFile = getPolicySubFile(policy.getActionBodyEntity().getActionBodyName(), action);
1051 if(subFile != null){
1052 Files.deleteIfExists(subFile);
1054 if (policy.getConfigurationData()!= null){
1055 writePolicySubFile(policy, config);
1056 }else if(policy.getActionBodyEntity()!= null){
1057 writePolicySubFile(policy, action);
1060 } catch (IOException e1) {
1061 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, policyDBDaoVar, "Error occurred while performing [" + action + "] of Policy File: " + policyName);
1065 private String getPdpPolicyName(String name, String scope){
1066 String finalName = "";
1069 finalName += removeFileExtension(name);
1070 finalName += ".xml";
1073 private String removeFileExtension(String fileName){
1074 return fileName.substring(0, fileName.lastIndexOf('.'));
1077 private Path getPolicySubFile(String inputFileName, String subFileType){
1078 String filename = inputFileName;
1079 logger.info("getPolicySubFile(" + filename + ", " + subFileType + ")");
1080 Path filePath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS), subFileType);
1083 filename = FilenameUtils.removeExtension(filename);
1085 for(File tmpFile : filePath.toFile().listFiles()){
1086 if (FilenameUtils.removeExtension(tmpFile.getName()).equals(filename)){
1091 Path finalPath = null;
1093 finalPath = Paths.get(file.getAbsolutePath());
1096 logger.info("end of getPolicySubFile: " + finalPath);
1100 private boolean writePolicySubFile(PolicyEntity policy, String policyType){
1101 logger.info("writePolicySubFile with policyName[" + policy.getPolicyName() + "] and policyType[" + policyType + "]");
1103 String subTypeName = null;
1104 String subTypeBody = null;
1105 if (config.equalsIgnoreCase(policyType)){
1107 subTypeName = FilenameUtils.removeExtension(policy.getConfigurationData().getConfigurationName());
1108 subTypeBody = policy.getConfigurationData().getConfigBody();
1110 String configType = policy.getConfigurationData().getConfigType();
1112 if (configType != null) {
1113 if (configType.equals(JSON_CONFIG)) {
1114 subTypeName = subTypeName + ".json";
1116 if (configType.equals(XML_CONFIG)) {
1117 subTypeName = subTypeName + ".xml";
1119 if (configType.equals(PROPERTIES_CONFIG)) {
1120 subTypeName = subTypeName + ".properties";
1122 if (configType.equals(OTHER_CONFIG)) {
1123 subTypeName = subTypeName + ".txt";
1126 }else if (action.equalsIgnoreCase(policyType)){
1128 subTypeName = policy.getActionBodyEntity().getActionBodyName();
1129 subTypeBody = policy.getActionBodyEntity().getActionBody();
1131 Path filePath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS).toString(), type);
1133 if(subTypeBody == null){
1136 boolean success = false;
1138 Files.deleteIfExists(Paths.get(filePath.toString(), subTypeName));
1139 File file = Paths.get(filePath.toString(),subTypeName).toFile();
1140 boolean value = file.createNewFile();
1141 logger.debug("New file created successfully"+value);
1142 try(FileWriter fileWriter = new FileWriter(file, false)){
1143 // false to overwrite
1144 fileWriter.write(subTypeBody);
1148 } catch (Exception e) {
1149 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Exception occured while creating Configuration File for Policy : " + policy.getPolicyName());
1154 public void auditLocalDatabase(PAPPolicyEngine papEngine2){
1155 logger.debug("PolicyDBDao.auditLocalDatabase() is called");
1157 deleteAllGroupTables();
1158 auditGroups(papEngine2);
1159 } catch(Exception e){
1160 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "auditLocalDatabase() error");
1161 logger.error("Exception Occured"+e);
1166 public StdPDPGroup auditLocalFileSystem(StdPDPGroup group){
1168 logger.info("Starting Local File System group audit");
1169 EntityManager em = emf.createEntityManager();
1170 em.getTransaction().begin();
1172 StdPDPGroup updatedGroup = null;
1174 Query groupQuery = em.createQuery(groupEntitySelectQuery);
1175 groupQuery.setParameter(groupIdVar, group.getId());
1176 groupQuery.setParameter(deletedVar, false);
1177 List<?> groupQueryList = groupQuery.getResultList();
1178 if(groupQueryList!=null && !groupQueryList.isEmpty()){
1179 GroupEntity dbgroup = (GroupEntity)groupQueryList.get(0);
1180 updatedGroup = synchronizeGroupPoliciesInFileSystem(group, dbgroup);
1181 logger.info("Group was updated during file system audit: " + updatedGroup.toString());
1183 } catch (PAPException | PolicyDBException e) {
1185 } catch (Exception e) {
1187 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to check if group exists groupQuery.getResultList()");
1188 throw new PersistenceException("Query failed trying to check if group "+group.getId()+" exists");
1191 em.getTransaction().commit();
1194 return updatedGroup;
1198 public void deleteAllGroupTables(){
1199 logger.debug("PolicyDBDao.deleteAllGroupTables() called");
1200 EntityManager em = emf.createEntityManager();
1201 em.getTransaction().begin();
1203 Query deletePdpEntityEntityTableUpdate = em.createNamedQuery("PdpEntity.deleteAll");
1204 deletePdpEntityEntityTableUpdate.executeUpdate();
1206 Query deleteGroupEntityTableUpdate = em.createNamedQuery("GroupEntity.deleteAll");
1207 deleteGroupEntityTableUpdate.executeUpdate();
1209 em.getTransaction().commit();
1213 @SuppressWarnings("unchecked")
1214 public void auditGroups(PAPPolicyEngine papEngine2){
1215 logger.debug("PolicyDBDao.auditGroups() called");
1217 EntityManager em = emf.createEntityManager();
1218 em.getTransaction().begin();
1219 final String AUDIT_STR = "Audit";
1222 Set<OnapPDPGroup> groups = papEngine2.getOnapPDPGroups();
1224 for (OnapPDPGroup grp : groups){
1226 GroupEntity groupEntity = new GroupEntity();
1227 em.persist(groupEntity);
1228 groupEntity.setGroupName(grp.getName());
1229 groupEntity.setDescription(grp.getDescription());
1230 groupEntity.setDefaultGroup(grp.isDefaultGroup());
1231 groupEntity.setCreatedBy(AUDIT_STR);
1232 groupEntity.setGroupId(createNewPDPGroupId(grp.getId()));
1233 groupEntity.setModifiedBy(AUDIT_STR);
1234 Set<OnapPDP> pdps = grp.getOnapPdps();
1236 for(OnapPDP pdp : pdps){
1237 PdpEntity pdpEntity = new PdpEntity();
1238 em.persist(pdpEntity);
1239 pdpEntity.setGroup(groupEntity);
1240 pdpEntity.setJmxPort(pdp.getJmxPort());
1241 pdpEntity.setPdpId(pdp.getId());
1242 pdpEntity.setPdpName(pdp.getName());
1243 pdpEntity.setModifiedBy(AUDIT_STR);
1244 pdpEntity.setCreatedBy(AUDIT_STR);
1248 Set<PDPPolicy> policies = grp.getPolicies();
1250 for(PDPPolicy policy : policies){
1252 String[] stringArray = getNameScopeAndVersionFromPdpPolicy(policy.getId());
1253 if(stringArray == null) {
1254 throw new IllegalArgumentException("Invalid input - policyID must contain name, scope and version");
1256 List<PolicyEntity> policyEntityList;
1257 Query getPolicyEntitiesQuery = em.createNamedQuery("PolicyEntity.findByNameAndScope");
1258 getPolicyEntitiesQuery.setParameter("name", stringArray[0]);
1259 getPolicyEntitiesQuery.setParameter(scope, stringArray[1]);
1261 policyEntityList = getPolicyEntitiesQuery.getResultList();
1262 PolicyEntity policyEntity = null;
1263 if(!policyEntityList.isEmpty()){
1264 policyEntity = policyEntityList.get(0);
1266 if(policyEntity != null){
1267 groupEntity.addPolicyToGroup(policyEntity);
1269 }catch(Exception e2){
1270 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, policyDBDaoVar, "Exception auditGroups inner catch");
1273 }catch(Exception e1){
1274 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, policyDBDaoVar, "Exception auditGroups middle catch");
1277 }catch(Exception e){
1278 em.getTransaction().rollback();
1279 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Exception auditGroups outer catch");
1284 em.getTransaction().commit();
1289 private String getConfigFile(String filename, PolicyRestAdapter policy){
1291 return getConfigFile(filename, (String)null);
1293 return getConfigFile(filename, policy.getConfigType());
1295 //copied from ConfigPolicy.java and modified
1296 // Here we are adding the extension for the configurations file based on the
1297 // config type selection for saving.
1298 private String getConfigFile(String inputFilename, String configType) {
1299 String filename = inputFilename;
1300 logger.debug("getConfigFile(String filename, String scope, String configType) as getConfigFile("+filename+", "+configType+") called");
1301 filename = FilenameUtils.removeExtension(filename);
1302 String id = configType;
1305 if (id.equals(ConfigPolicy.JSON_CONFIG) || id.contains("Firewall")) {
1306 filename = filename + ".json";
1308 if (id.equals(ConfigPolicy.XML_CONFIG)) {
1309 filename = filename + ".xml";
1311 if (id.equals(ConfigPolicy.PROPERTIES_CONFIG)) {
1312 filename = filename + ".properties";
1314 if (id.equals(ConfigPolicy.OTHER_CONFIG)) {
1315 filename = filename + ".txt";
1321 private String[] getNameScopeAndVersionFromPdpPolicy(String fileName){
1322 String[] splitByDots = fileName.split("\\.");
1323 if(splitByDots.length < 3){
1326 String policyName = splitByDots[splitByDots.length-3];
1327 String version = splitByDots[splitByDots.length-2];
1328 //policy names now include version
1330 for(int i=0;i<splitByDots.length-3;i++){
1331 scope += ".".concat(splitByDots[i]);
1333 //remove the first dot
1334 if(scope.length() > 0){
1335 scope = scope.substring(1);
1337 String[] returnArray = new String[3];
1338 returnArray[0] = policyName + "." + version + ".xml";
1339 returnArray[2] = version;
1340 returnArray[1] = scope;
1344 //copied from StdEngine.java
1345 public static String createNewPDPGroupId(String name) {
1347 // replace "bad" characters with sequences that will be ok for file names and properties keys.
1348 id = id.replace(" ", "_sp_");
1349 id = id.replace("\t", "_tab_");
1350 id = id.replace("\\", "_bksl_");
1351 id = id.replace("/", "_sl_");
1352 id = id.replace(":", "_col_");
1353 id = id.replace("*", "_ast_");
1354 id = id.replace("?", "_q_");
1355 id = id.replace("\"", "_quo_");
1356 id = id.replace("<", "_lt_");
1357 id = id.replace(">", "_gt_");
1358 id = id.replace("|", "_bar_");
1359 id = id.replace("=", "_eq_");
1360 id = id.replace(",", "_com_");
1361 id = id.replace(";", "_scom_");
1367 * Checks if any of the given strings are empty or null
1368 * @param strings One or more Strings (or nulls) to check if they are null or empty
1369 * @return true if one or more of the given strings are empty or null
1371 private static boolean isNullOrEmpty(String... strings){
1372 for(String s : strings){
1373 if(s == null || "".equals(s)){
1381 private class PolicyDBDaoTransactionInstance implements PolicyDBDaoTransaction {
1382 private EntityManager em;
1383 private final Object emLock = new Object();
1388 private boolean operationRun = false;
1389 private final Thread transactionTimer;
1391 private PolicyDBDaoTransactionInstance(){
1392 //call the constructor with arguments
1393 this(Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)),
1394 Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT)));
1396 //timeout is how long the transaction can sit before rolling back
1397 //wait time is how long to wait for the transaction to start before throwing an exception
1398 private PolicyDBDaoTransactionInstance(int transactionTimeout, int transactionWaitTime){
1399 if(logger.isDebugEnabled()){
1400 logger.debug("\n\nPolicyDBDaoTransactionInstance() as PolicyDBDaoTransactionInstance() called:"
1401 + "\n transactionTimeout = " + transactionTimeout
1402 + "\n transactionWaitTime = " + transactionWaitTime + "\n\n");
1404 this.em = emf.createEntityManager();
1409 synchronized(emLock){
1411 startTransactionSynced(this.em,transactionWaitTime);
1412 } catch(Exception e){
1414 throw new PersistenceException("Could not lock transaction within "+transactionWaitTime+" milliseconds");
1417 class TransactionTimer implements Runnable {
1419 private int sleepTime;
1420 public TransactionTimer(int timeout){
1421 this.sleepTime = timeout;
1425 if(logger.isDebugEnabled()){
1426 Date date= new java.util.Date();
1427 logger.debug("\n\nTransactionTimer.run() - SLEEPING: "
1428 + "\n sleepTime (ms) = " + sleepTime
1429 + "\n TimeStamp = " + date.getTime()
1433 Thread.sleep(sleepTime);
1434 } catch (InterruptedException e) {
1435 //probably, the transaction was completed, the last thing we want to do is roll back
1436 if(logger.isDebugEnabled()){
1437 Date date= new java.util.Date();
1438 logger.debug("\n\nTransactionTimer.run() - WAKE Interrupt: "
1439 + "\n TimeStamp = " + date.getTime()
1442 Thread.currentThread().interrupt();
1445 if(logger.isDebugEnabled()){
1446 Date date= new java.util.Date();
1447 logger.debug("\n\nTransactionTimer.run() - WAKE Timeout: "
1448 + "\n TimeStamp = " + date.getTime()
1451 rollbackTransaction();
1456 transactionTimer = new Thread(new TransactionTimer(transactionTimeout),"transactionTimerThread");
1457 transactionTimer.start();
1462 private void checkBeforeOperationRun(){
1463 checkBeforeOperationRun(false);
1465 private void checkBeforeOperationRun(boolean justCheckOpen){
1466 if(!isTransactionOpen()){
1467 PolicyLogger.error("There is no transaction currently open");
1468 throw new IllegalStateException("There is no transaction currently open");
1470 if(operationRun && !justCheckOpen){
1471 PolicyLogger.error("An operation has already been performed and the current transaction should be committed");
1472 throw new IllegalStateException("An operation has already been performed and the current transaction should be committed");
1474 operationRun = true;
1477 public void commitTransaction() {
1478 synchronized(emLock){
1479 logger.debug("commitTransaction() as commitTransaction() called");
1480 if(!isTransactionOpen()){
1481 logger.warn("There is no open transaction to commit");
1484 } catch(Exception e){
1485 logger.error("Exception Occured"+e);
1490 em.getTransaction().commit();
1491 } catch(RollbackException e){
1492 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught RollbackException on em.getTransaction().commit()");
1493 throw new PersistenceException("The commit failed. Message:\n"+e.getMessage());
1498 if(newGroupId != null){
1500 notifyOthers(policyId,POLICY_NOTIFICATION,newGroupId);
1501 } catch(Exception e){
1502 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on notifyOthers("+policyId+","+POLICY_NOTIFICATION+","+newGroupId+")");
1506 notifyOthers(policyId,POLICY_NOTIFICATION);
1507 } catch(Exception e){
1508 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on notifyOthers("+policyId+","+POLICY_NOTIFICATION+")");
1513 //we don't want commit to fail just because this does
1514 if(newGroupId != null){
1516 notifyOthers(groupId,GROUP_NOTIFICATION,newGroupId);
1517 } catch(Exception e){
1518 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on notifyOthers("+groupId+","+GROUP_NOTIFICATION+","+newGroupId+")");
1522 notifyOthers(groupId,GROUP_NOTIFICATION);
1523 } catch(Exception e){
1524 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on notifyOthers("+groupId+","+GROUP_NOTIFICATION+")");
1529 //we don't want commit to fail just because this does
1531 notifyOthers(pdpId,PDP_NOTIFICATION);
1532 } catch(Exception e){
1533 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on notifyOthers("+pdpId+","+PDP_NOTIFICATION+")");
1537 if(transactionTimer != null){
1538 transactionTimer.interrupt();
1543 public void rollbackTransaction() {
1544 logger.debug("rollbackTransaction() as rollbackTransaction() called");
1545 synchronized(emLock){
1546 if(isTransactionOpen()){
1549 em.getTransaction().rollback();
1550 } catch(Exception e){
1551 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Could not rollback transaction");
1555 }catch(Exception e){
1556 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Could not close EntityManager");
1562 }catch(Exception e){
1563 logger.warn("Could not close already closed transaction", e);
1568 if(transactionTimer != null){
1569 transactionTimer.interrupt();
1573 private void createPolicy(PolicyRestAdapter policy, String username, String policyScope, String inputPolicyName, String policyDataString) {
1574 String policyName = inputPolicyName;
1575 logger.debug("createPolicy(PolicyRestAdapter policy, String username, String policyScope, String policyName, String policyDataString) as createPolicy("+policy+", "+username+", "+policyScope+", "+policyName+", "+policyDataString+") called");
1576 synchronized(emLock){
1577 checkBeforeOperationRun();
1578 String configName = policyName;
1579 if(policyName.contains("Config_")){
1580 policyName = policyName.replace(".Config_", ":Config_");
1581 }else if(policyName.contains("Action_")){
1582 policyName = policyName.replace(".Action_", ":Action_");
1583 }else if(policyName.contains("Decision_")){
1584 policyName = policyName.replace(".Decision_", ":Decision_");
1586 policyName = policyName.split(":")[1];
1587 Query createPolicyQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName");
1588 createPolicyQuery.setParameter(scope, policyScope);
1589 createPolicyQuery.setParameter("policyName", policyName);
1590 List<?> createPolicyQueryList = createPolicyQuery.getResultList();
1591 PolicyEntity newPolicyEntity;
1593 if(createPolicyQueryList.isEmpty()){
1594 newPolicyEntity = new PolicyEntity();
1596 } else if(createPolicyQueryList.size() > 1){
1597 PolicyLogger.error("Somehow, more than one policy with the same scope, name, and deleted status were found in the database");
1598 throw new PersistenceException("Somehow, more than one policy with the same scope, name, and deleted status were found in the database");
1600 newPolicyEntity = (PolicyEntity)createPolicyQueryList.get(0);
1604 ActionBodyEntity newActionBodyEntity = null;
1605 if(policy.getPolicyType().equals(action)){
1606 boolean abupdate = false;
1607 if(newPolicyEntity.getActionBodyEntity() == null){
1608 newActionBodyEntity = new ActionBodyEntity();
1610 newActionBodyEntity = em.find(ActionBodyEntity.class, newPolicyEntity.getActionBodyEntity().getActionBodyId());
1614 if(newActionBodyEntity != null){
1616 em.persist(newActionBodyEntity);
1618 //build the file path
1619 //trim the .xml off the end
1620 String policyNameClean = FilenameUtils.removeExtension(configName);
1621 String actionBodyName = policyNameClean + ".json";
1623 //get the action body
1624 String actionBodyString = policy.getActionBody();
1625 if(actionBodyString == null){
1626 actionBodyString = "{}";
1628 newActionBodyEntity.setActionBody(actionBodyString);
1629 newActionBodyEntity.setActionBodyName(actionBodyName);
1630 newActionBodyEntity.setModifiedBy("PolicyDBDao.createPolicy()");
1631 newActionBodyEntity.setDeleted(false);
1633 newActionBodyEntity.setCreatedBy("PolicyDBDao.createPolicy()");
1635 if(logger.isDebugEnabled()){
1636 logger.debug("\nPolicyDBDao.createPolicy"
1637 + "\n newActionBodyEntity.getActionBody() = " + newActionBodyEntity.getActionBody()
1638 + "\n newActionBodyEntity.getActionBodyName() = " + newActionBodyEntity.getActionBodyName()
1639 + "\n newActionBodyEntity.getModifiedBy() = " + newActionBodyEntity.getModifiedBy()
1640 + "\n newActionBodyEntity.getCreatedBy() = " + newActionBodyEntity.getCreatedBy()
1641 + "\n newActionBodyEntity.isDeleted() = " + newActionBodyEntity.isDeleted()
1642 + "\n FLUSHING to DB");
1644 //push the actionBodyEntity to the DB
1647 //newActionBodyEntity == null
1648 //We have a actionBody in the policy but we found no actionBody in the DB
1649 String msg = "\n\nPolicyDBDao.createPolicy - Incoming Action policy had an "
1650 + "actionBody, but it could not be found in the DB for update."
1651 + "\n policyScope = " + policyScope
1652 + "\n policyName = " + policyName + "\n\n";
1653 PolicyLogger.error("PolicyDBDao.createPolicy - Incoming Action policy had an actionBody, but it could not be found in the DB for update: policyName = " + policyName);
1654 throw new IllegalArgumentException(msg);
1658 ConfigurationDataEntity newConfigurationDataEntity;
1659 if(policy.getPolicyType().equals(config)){
1660 boolean configUpdate;
1661 if(newPolicyEntity.getConfigurationData() == null){
1662 newConfigurationDataEntity = new ConfigurationDataEntity();
1663 configUpdate = false;
1665 newConfigurationDataEntity = em.find(ConfigurationDataEntity.class, newPolicyEntity.getConfigurationData().getConfigurationDataId());
1666 configUpdate = true;
1669 if(newConfigurationDataEntity != null){
1671 em.persist(newConfigurationDataEntity);
1673 if(!stringEquals(newConfigurationDataEntity.getConfigurationName(),getConfigFile(configName,policy))){
1674 newConfigurationDataEntity.setConfigurationName(getConfigFile(configName,policy));
1676 if(newConfigurationDataEntity.getConfigType() == null || !newConfigurationDataEntity.getConfigType().equals(policy.getConfigType())){
1677 newConfigurationDataEntity.setConfigType(policy.getConfigType());
1680 newConfigurationDataEntity.setCreatedBy(username);
1682 if(newConfigurationDataEntity.getModifiedBy() == null || !newConfigurationDataEntity.getModifiedBy().equals(username)){
1683 newConfigurationDataEntity.setModifiedBy(username);
1685 if(newConfigurationDataEntity.getDescription() == null || !newConfigurationDataEntity.getDescription().equals("")){
1686 newConfigurationDataEntity.setDescription("");
1688 if(newConfigurationDataEntity.getConfigBody() == null || newConfigurationDataEntity.getConfigBody().isEmpty() ||
1689 (!newConfigurationDataEntity.getConfigBody().equals(policy.getConfigBodyData()))){
1690 //hopefully one of these won't be null
1691 if(policy.getConfigBodyData() == null || policy.getConfigBodyData().isEmpty()){
1692 newConfigurationDataEntity.setConfigBody(policy.getJsonBody());
1694 newConfigurationDataEntity.setConfigBody(policy.getConfigBodyData());
1697 if(newConfigurationDataEntity.isDeleted()){
1698 newConfigurationDataEntity.setDeleted(false);
1703 //We have a configurationData body in the policy but we found no configurationData body in the DB
1704 String msg = "\n\nPolicyDBDao.createPolicy - Incoming Config policy had a "
1705 + "configurationData body, but it could not be found in the DB for update."
1706 + "\n policyScope = " + policyScope
1707 + "\n policyName = " + policyName + "\n\n";
1708 PolicyLogger.error("PolicyDBDao.createPolicy - Incoming Config policy had a configurationData body, but it could not be found in the DB for update: policyName = " + policyName);
1709 throw new IllegalArgumentException(msg);
1713 newConfigurationDataEntity = null;
1716 em.persist(newPolicyEntity);
1719 policyId = newPolicyEntity.getPolicyId();
1721 if(!stringEquals(newPolicyEntity.getPolicyName(),policyName)){
1722 newPolicyEntity.setPolicyName(policyName);
1724 if(!stringEquals(newPolicyEntity.getCreatedBy(),username)){
1725 newPolicyEntity.setCreatedBy(username);
1727 if(!stringEquals(newPolicyEntity.getDescription(),policy.getPolicyDescription())){
1728 newPolicyEntity.setDescription(policy.getPolicyDescription());
1730 if(!stringEquals(newPolicyEntity.getModifiedBy(),username)){
1731 newPolicyEntity.setModifiedBy(username);
1733 if(!stringEquals(newPolicyEntity.getPolicyData(),policyDataString)){
1734 newPolicyEntity.setPolicyData(policyDataString);
1736 if(!stringEquals(newPolicyEntity.getScope(),policyScope)){
1737 newPolicyEntity.setScope(policyScope);
1739 if(newPolicyEntity.isDeleted() == true){
1740 newPolicyEntity.setDeleted(false);
1742 newPolicyEntity.setConfigurationData(newConfigurationDataEntity);
1743 newPolicyEntity.setActionBodyEntity(newActionBodyEntity);
1746 this.policyId = newPolicyEntity.getPolicyId();
1751 @SuppressWarnings("unused")
1752 public PolicyEntity getPolicy(int policyID){
1753 return getPolicy(policyID,null,null);
1755 public PolicyEntity getPolicy(String policyName,String scope){
1756 return getPolicy(-1,policyName,scope);
1758 private PolicyEntity getPolicy(int policyID, String policyName,String scope){
1759 logger.debug("getPolicy(int policyId, String policyName) as getPolicy("+policyID+","+policyName+") called");
1760 if(policyID < 0 && isNullOrEmpty(policyName,scope)){
1761 throw new IllegalArgumentException("policyID must be at least 0 or policyName must be not null or blank");
1764 synchronized(emLock){
1765 checkBeforeOperationRun(true);
1766 //check if group exists
1769 if(!isNullOrEmpty(policyName,scope)){
1770 policyId = policyName;
1771 policyQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope");
1772 policyQuery.setParameter("name", policyId);
1773 policyQuery.setParameter("scope", scope);
1775 policyId = String.valueOf(policyID);
1776 policyQuery = em.createNamedQuery("PolicyEntity.FindById");
1777 policyQuery.setParameter("id", policyId);
1779 List<?> policyQueryList;
1781 policyQueryList = policyQuery.getResultList();
1782 }catch(Exception e){
1783 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to get policy with policyQuery.getResultList()");
1784 throw new PersistenceException("Query failed trying to get policy "+policyId);
1786 if(policyQueryList.isEmpty()){
1787 PolicyLogger.error("Policy does not exist with id "+policyId);
1788 throw new PersistenceException("Group policy is being added to does not exist with id "+policyId);
1789 } else if(policyQueryList.size() > 1){
1790 PolicyLogger.error(duplicatePolicyId+policyId+foundInDB);
1791 throw new PersistenceException(duplicatePolicyId+policyId+foundInDB);
1793 return (PolicyEntity)policyQueryList.get(0);
1798 public GroupEntity getGroup(long groupKey){
1799 logger.debug("getGroup(int groupKey) as getGroup("+groupKey+") called");
1801 throw new IllegalArgumentException("groupKey must be at least 0");
1803 synchronized(emLock){
1804 checkBeforeOperationRun(true);
1805 //check if group exists
1806 Query groupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupKey=:groupKey");
1807 groupQuery.setParameter("groupKey", groupKey);
1808 List<?> groupQueryList;
1810 groupQueryList = groupQuery.getResultList();
1811 }catch(Exception e){
1812 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to get group with groupQuery.getResultList()");
1813 throw new PersistenceException(queryFailedToGetGroup+groupKey);
1815 if(groupQueryList.isEmpty()){
1816 PolicyLogger.error("Group does not exist with groupKey "+groupKey);
1817 throw new PersistenceException("Group does not exist with groupKey "+groupKey);
1818 } else if(groupQueryList.size() > 1){
1819 PolicyLogger.error("Somehow, more than one group with the groupKey "+groupKey+foundInDB);
1820 throw new PersistenceException("Somehow, more than one group with the groupKey "+groupKey+foundInDB);
1822 return (GroupEntity)groupQueryList.get(0);
1827 public GroupEntity getGroup(String groupId){
1828 logger.debug("getGroup(String groupId) as getGroup("+groupId+") called");
1829 if(isNullOrEmpty(groupId)){
1830 throw new IllegalArgumentException("groupId must not be null or empty");
1832 synchronized(emLock){
1833 checkBeforeOperationRun(true);
1834 //check if group exists
1835 Query groupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId");
1836 groupQuery.setParameter(groupIdVar, groupId);
1837 List<?> groupQueryList;
1839 groupQueryList = groupQuery.getResultList();
1840 }catch(Exception e){
1841 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to get group with groupQuery.getResultList()");
1842 throw new PersistenceException(queryFailedToGetGroup+groupId);
1844 if(groupQueryList.isEmpty()){
1845 PolicyLogger.error("Group does not exist with id "+groupId);
1846 throw new PersistenceException("Group does not exist with id "+groupId);
1847 } else if(groupQueryList.size() > 1){
1848 PolicyLogger.error(duplicateGroupId +groupId+foundInDB);
1849 throw new PersistenceException(duplicateGroupId+groupId+foundInDB);
1851 return (GroupEntity)groupQueryList.get(0);
1856 public List<?> getPdpsInGroup(long groupKey){
1857 logger.debug("getPdpsInGroup(int groupKey) as getPdpsInGroup("+groupKey+") called");
1859 throw new IllegalArgumentException("groupId must not be < 0");
1861 synchronized(emLock){
1862 checkBeforeOperationRun(true);
1863 Query pdpsQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.groupEntity=:group");
1864 pdpsQuery.setParameter("group", getGroup(groupKey));
1865 return pdpsQuery.getResultList();
1870 public PdpEntity getPdp(long pdpKey){
1871 logger.debug("getPdp(int pdpKey) as getPdp("+pdpKey+") called");
1873 throw new IllegalArgumentException("pdpKey must be at least 0");
1875 synchronized(emLock){
1876 checkBeforeOperationRun(true);
1877 //check if group exists
1878 Query pdpQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpKey=:pdpKey");
1879 pdpQuery.setParameter("pdpKey", pdpKey);
1880 List<?> pdpQueryList;
1882 pdpQueryList = pdpQuery.getResultList();
1883 }catch(Exception e){
1884 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to get pdp with pdpQuery.getResultList()");
1885 throw new PersistenceException("Query failed trying to get pdp "+pdpKey);
1887 if(pdpQueryList.isEmpty()){
1888 PolicyLogger.error("Pdp does not exist with pdpKey "+pdpKey);
1889 throw new PersistenceException("Pdp does not exist with pdpKey "+pdpKey);
1890 } else if(pdpQueryList.size() > 1){
1891 PolicyLogger.error("Somehow, more than one pdp with the pdpKey "+pdpKey+foundInDB);
1892 throw new PersistenceException("Somehow, more than one pdp with the pdpKey "+pdpKey+foundInDB);
1894 return (PdpEntity)pdpQueryList.get(0);
1899 public boolean isTransactionOpen() {
1900 logger.debug("isTransactionOpen() as isTransactionOpen() called");
1901 synchronized(emLock){
1902 return em.isOpen() && em.getTransaction().isActive();
1906 private String processConfigPath(String inputConfigPath){
1907 String configPath = inputConfigPath;
1908 String webappsPath = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS);
1909 if(webappsPath == null){
1910 logger.error("Webapps property does not exist");
1911 throw new IllegalArgumentException("Webapps property does not exist");
1913 configPath = configPath.replace("$URL", webappsPath);
1914 //make sure the correct slashes are in
1916 configPath = Paths.get(configPath).toString();
1917 } catch(InvalidPathException e){
1918 logger.error("Invalid config path: "+configPath, e);
1919 throw new IllegalArgumentException("Invalid config path: "+configPath);
1924 private String readConfigFile(String configPath){
1925 String configDataString = null;
1927 try(InputStream configContentStream = new FileInputStream(configPath)) {
1928 configDataString = IOUtils.toString(configContentStream);
1929 } catch (FileNotFoundException e) {
1930 logger.error("Caught FileNotFoundException on new FileInputStream("+configPath+")",e);
1931 throw new IllegalArgumentException("The config file path does not exist");
1932 } catch(IOException e2){
1933 logger.error("Caught IOException on newIOUtils.toString(configContentStream)",e2);
1934 throw new IllegalArgumentException("The config file path cannot be read");
1936 if(configDataString == null){
1937 throw new IllegalArgumentException("The config file path cannot be read");
1939 return configDataString;
1943 public void createPolicy(Policy policy, String username){
1944 InputStream policyXmlStream = null;
1946 logger.debug("createPolicy(PolicyRestAdapter policy, String username) as createPolicy("+policy+","+username+") called");
1947 String policyScope = policy.policyAdapter.getDomainDir().replace(File.separator, ".");
1948 //Does not need to be XACMLPolicyWriterWithPapNotify since it is already in the PAP
1949 //and this transaction is intercepted up stream.
1950 String policyDataString;
1952 policyXmlStream = XACMLPolicyWriter.getXmlAsInputStream((PolicyType)policy.getCorrectPolicyDataObject());
1953 policyDataString = IOUtils.toString(policyXmlStream);
1954 } catch (IOException e) {
1955 policyDataString = "could not read";
1956 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught IOException on IOUtils.toString("+policyXmlStream+")");
1957 throw new IllegalArgumentException("Cannot parse the policy xml from the PolicyRestAdapter.");
1959 IOUtils.closeQuietly(policyXmlStream);
1961 //Using parentPath object to set policy data.
1962 policyDataString = policy.policyAdapter.getParentPath();
1964 String configPath = "";
1965 if (policy.policyAdapter.getPolicyType().equalsIgnoreCase(config)) {
1966 configPath = evaluateXPath("/Policy/Rule/AdviceExpressions/AdviceExpression[contains(@AdviceId,'ID')]/AttributeAssignmentExpression[@AttributeId='URLID']/AttributeValue/text()", policyDataString);
1967 } else if (policy.policyAdapter.getPolicyType().equalsIgnoreCase(action)) {
1968 configPath = evaluateXPath("/Policy/Rule/ObligationExpressions/ObligationExpression[contains(@ObligationId, " +policy.policyAdapter.getActionAttribute()+ ")]/AttributeAssignmentExpression[@AttributeId='body']/AttributeValue/text()", policyDataString);
1971 String prefix = null;
1972 if (policy.policyAdapter.getPolicyType().equalsIgnoreCase(config)) {
1974 prefix = configPath.substring(configPath.indexOf(policyScope+".")+policyScope.concat(".").length(), configPath.lastIndexOf(policy.policyAdapter.getPolicyName()));
1975 if(isNullOrEmpty(policy.policyAdapter.getConfigBodyData())){
1976 String configData = "";
1978 String newConfigPath = configPath;
1980 newConfigPath = processConfigPath(newConfigPath);
1981 }catch(Exception e2){
1982 logger.error("Could not process config path: "+newConfigPath,e2);
1984 configData = readConfigFile(newConfigPath);
1985 }catch(Exception e){
1986 logger.error("Could not read config body data for "+configPath,e);
1988 policy.policyAdapter.setConfigBodyData(configData);
1990 } else if (action.equalsIgnoreCase(policy.policyAdapter.getPolicyType())) {
1992 } else if ("Decision".equalsIgnoreCase(policy.policyAdapter.getPolicyType())) {
1993 prefix = "Decision_";
1996 if(!(policy.policyAdapter.getData() instanceof PolicyType)){
1997 PolicyLogger.error("The data field is not an instance of PolicyType");
1998 throw new IllegalArgumentException("The data field is not an instance of PolicyType");
2000 String finalName = policyScope + "." + prefix+policy.policyAdapter.getPolicyName()+"."+((PolicyType)policy.policyAdapter.getData()).getVersion()+".xml";
2001 if(policy.policyAdapter.getConfigType() == null || "".equals(policy.policyAdapter.getConfigType())){
2002 //get the config file extension
2004 if (configPath != null && !"".equalsIgnoreCase(configPath)) {
2005 ext = configPath.substring(configPath.lastIndexOf('.'), configPath.length());;
2008 if(ext.contains("txt")){
2009 policy.policyAdapter.setConfigType(OTHER_CONFIG);
2010 } else if(ext.contains("json")){
2011 policy.policyAdapter.setConfigType(JSON_CONFIG);
2012 } else if(ext.contains("xml")){
2013 policy.policyAdapter.setConfigType(XML_CONFIG);
2014 } else if(ext.contains("properties")){
2015 policy.policyAdapter.setConfigType(PROPERTIES_CONFIG);
2017 if (policy.policyAdapter.getPolicyType().equalsIgnoreCase(action)){
2018 policy.policyAdapter.setConfigType(JSON_CONFIG);
2023 createPolicy(policy.policyAdapter, username, policyScope,finalName,policyDataString);
2025 if(policyXmlStream != null){
2027 policyXmlStream.close();
2028 } catch (IOException e) {
2029 logger.error("Exception Occured while closing input stream"+e);
2036 public void close(){
2037 synchronized(emLock){
2039 if(em.getTransaction().isActive()){
2040 em.getTransaction().rollback();
2044 if(transactionTimer != null){
2045 transactionTimer.interrupt();
2051 public void createGroup(String groupId, String groupName, String inputGroupDescription, String username) {
2052 String groupDescription = inputGroupDescription;
2053 logger.debug("deletePolicy(String policyToDeletes) as createGroup("+groupId+", "+groupName+", "+groupDescription+") called");
2054 if(isNullOrEmpty(groupId, groupName, username)){
2055 throw new IllegalArgumentException("groupId, groupName, and username must not be null or empty");
2057 if(groupDescription == null){
2058 groupDescription = "";
2061 synchronized(emLock){
2062 checkBeforeOperationRun();
2063 Query checkGroupQuery = em.createQuery(groupEntitySelectQuery);
2064 checkGroupQuery.setParameter(groupIdVar, groupId);
2065 checkGroupQuery.setParameter(deletedVar, false);
2066 List<?> checkGroupQueryList;
2068 checkGroupQueryList = checkGroupQuery.getResultList();
2069 } catch(Exception e){
2070 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on checkGroupQuery.getResultList()");
2071 throw new PersistenceException(queryFailedToCheckExisting);
2073 if(!checkGroupQueryList.isEmpty()){
2074 PolicyLogger.error("The group being added already exists with id "+groupId);
2075 throw new PersistenceException("The group being added already exists with id "+groupId);
2077 GroupEntity newGroup = new GroupEntity();
2078 em.persist(newGroup);
2079 newGroup.setCreatedBy(username);
2080 newGroup.setModifiedBy(username);
2081 newGroup.setGroupName(groupName);
2082 newGroup.setGroupId(groupId);
2083 newGroup.setDescription(groupDescription);
2086 this.groupId = newGroup.getGroupKey();
2091 public void updateGroup(OnapPDPGroup group, String username){
2092 logger.info("PolicyDBDao: updateGroup(PDPGroup group) as updateGroup("+group+","+username+") called");
2094 throw new IllegalArgumentException("PDPGroup group must not be null");
2096 if(isNullOrEmpty(group.getId(), username)){
2097 throw new IllegalArgumentException("group.getId() and username must not be null or empty");
2100 synchronized(emLock){
2101 checkBeforeOperationRun();
2102 Query getGroupQuery = em.createQuery(groupEntitySelectQuery);
2103 getGroupQuery.setParameter(groupIdVar, group.getId());
2104 getGroupQuery.setParameter(deletedVar, false);
2105 List<?> getGroupQueryList;
2107 getGroupQueryList = getGroupQuery.getResultList();
2108 } catch(Exception e){
2109 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on getGroupQuery.getResultList()");
2110 throw new PersistenceException(queryFailedToGetGroup+group.getId()+" for editing");
2112 if(getGroupQueryList.isEmpty()){
2113 PolicyLogger.error("The group cannot be found to update with id "+group.getId());
2114 throw new PersistenceException("The group cannot be found to update with id "+group.getId());
2115 } else if(getGroupQueryList.size() > 1){
2116 PolicyLogger.error(duplicateGroupId+group.getId()+deletedStatusFound);
2117 throw new PersistenceException(duplicateGroupId+group.getId()+deletedStatusFound);
2119 GroupEntity groupToUpdateInDB = (GroupEntity)getGroupQueryList.get(0);
2120 if(!stringEquals(groupToUpdateInDB.getModifiedBy(), username)){
2121 groupToUpdateInDB.setModifiedBy(username);
2123 if(group.getDescription() != null && !stringEquals(group.getDescription(),groupToUpdateInDB.getDescription())){
2124 groupToUpdateInDB.setDescription(group.getDescription());
2126 //let's find out what policies have been deleted
2127 StdPDPGroup oldGroup = null;
2129 oldGroup = (StdPDPGroup) papEngine.getGroup(group.getId());
2130 } catch (PAPException e1) {
2131 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, policyDBDaoVar, "We cannot get the group from the papEngine to delete policies");
2133 if(oldGroup == null){
2134 PolicyLogger.error("We cannot get the group from the papEngine to delete policies");
2136 Set<String> newPolicySet = new HashSet<>(group.getPolicies().size());
2137 //a multiple of n runtime is faster than n^2, so I am using a hashset to do the comparison
2138 for(PDPPolicy pol: group.getPolicies()){
2139 newPolicySet.add(pol.getId());
2141 for(PDPPolicy pol : oldGroup.getPolicies()){
2142 //should be fast since getPolicies uses a HashSet in StdPDPGroup
2143 if(!newPolicySet.contains(pol.getId())){
2144 String[] scopeAndName = getNameScopeAndVersionFromPdpPolicy(pol.getId());
2145 PolicyEntity policyToDelete = null;
2147 if(scopeAndName!=null){
2148 policyToDelete = getPolicy(scopeAndName[0],scopeAndName[1]);
2149 if ("XACMLPapServlet.doDelete".equals(username)) {
2150 Iterator<PolicyEntity> dbPolicyIt = groupToUpdateInDB.getPolicies().iterator();
2151 String policyName = getPolicyNameAndVersionFromPolicyFileName(policyToDelete.getPolicyName())[0];
2153 logger.info("PolicyDBDao: delete policy from GroupEntity");
2155 while(dbPolicyIt.hasNext()){
2156 PolicyEntity dbpolicy = dbPolicyIt.next();
2157 if(policyToDelete.getScope().equals(dbpolicy.getScope()) &&
2158 getPolicyNameAndVersionFromPolicyFileName(dbpolicy.getPolicyName())[0].equals(policyName)) {
2159 dbPolicyIt.remove();
2161 logger.info("PolicyDBDao: deleting policy from the existing group:\n "
2162 + "policyName is " + policyToDelete.getScope()+"."+policyToDelete.getPolicyName() + "\n"
2163 + "group is " + groupToUpdateInDB.getGroupId());
2166 }catch(Exception e){
2168 PolicyLogger.error("Could not delete policy with name: "+ policyToDelete.getScope()+"."+policyToDelete.getPolicyName()+"\n ID: "+ policyToDelete.getPolicyId());
2172 }catch(Exception e){
2173 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Could not get policy to remove: "+pol.getId());
2174 throw new PersistenceException("Could not get policy to remove: "+pol.getId());
2180 if(group.getName() != null && !stringEquals(group.getName(),groupToUpdateInDB.getgroupName())){
2181 //we need to check if the new id exists in the database
2182 String newGroupId = createNewPDPGroupId(group.getName());
2183 Query checkGroupQuery = em.createQuery(groupEntitySelectQuery);
2184 checkGroupQuery.setParameter(groupIdVar, newGroupId);
2185 checkGroupQuery.setParameter(deletedVar, false);
2186 List<?> checkGroupQueryList;
2188 checkGroupQueryList = checkGroupQuery.getResultList();
2189 } catch(Exception e){
2190 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on checkGroupQuery.getResultList()");
2191 throw new PersistenceException(queryFailedToCheckExisting);
2193 if(!checkGroupQueryList.isEmpty()){
2194 PolicyLogger.error("The new group name already exists, group id "+newGroupId);
2195 throw new PersistenceException("The new group name already exists, group id "+newGroupId);
2197 groupToUpdateInDB.setGroupId(newGroupId);
2198 groupToUpdateInDB.setGroupName(group.getName());
2199 this.newGroupId = group.getId();
2202 this.groupId = groupToUpdateInDB.getGroupKey();
2207 public void addPdpToGroup(String pdpID, String groupID, String pdpName, String pdpDescription, int pdpJmxPort, String username) {
2208 logger.debug("addPdpToGroup(String pdpID, String groupID, String pdpName, String pdpDescription, int pdpJmxPort, String username) as addPdpToGroup("+pdpID+", "+groupID+", "+pdpName+", "+pdpDescription+", "+pdpJmxPort+", "+username+") called");
2209 if(isNullOrEmpty(pdpID, groupID,pdpName,username)){
2210 throw new IllegalArgumentException("pdpID, groupID, pdpName, and username must not be null or empty");
2212 synchronized(emLock){
2213 checkBeforeOperationRun();
2214 Query checkGroupQuery = em.createQuery(groupEntitySelectQuery);
2215 checkGroupQuery.setParameter(groupIdVar, groupID);
2216 checkGroupQuery.setParameter(deletedVar, false);
2217 List<?> checkGroupQueryList;
2219 checkGroupQueryList = checkGroupQuery.getResultList();
2220 } catch(Exception e){
2221 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to check for existing group on checkGroupQuery.getResultList()");
2222 throw new PersistenceException(queryFailedToCheckExisting);
2224 if(checkGroupQueryList.size() != 1){
2225 PolicyLogger.error("The group does not exist");
2226 throw new PersistenceException("The group does not exist");
2228 Query checkDuplicateQuery = em.createQuery(pdpEntitySelectQuery);
2229 checkDuplicateQuery.setParameter(pdpIdVariable, pdpID);
2230 checkDuplicateQuery.setParameter(deletedVar, false);
2231 List<?> checkDuplicateList;
2233 checkDuplicateList = checkDuplicateQuery.getResultList();
2234 } catch(Exception e){
2235 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to check for duplicate PDP "+pdpID+" on checkDuplicateQuery.getResultList()");
2236 throw new PersistenceException("Query failed trying to check for duplicate PDP "+pdpID);
2239 if(!checkDuplicateList.isEmpty()){
2240 logger.warn("PDP already exists with id "+pdpID);
2241 newPdp = (PdpEntity)checkDuplicateList.get(0);
2243 newPdp = new PdpEntity();
2247 newPdp.setCreatedBy(username);
2248 newPdp.setDeleted(false);
2249 newPdp.setDescription(pdpDescription);
2250 newPdp.setGroup((GroupEntity)checkGroupQueryList.get(0));
2251 newPdp.setJmxPort(pdpJmxPort);
2252 newPdp.setModifiedBy(username);
2253 newPdp.setPdpId(pdpID);
2254 newPdp.setPdpName(pdpName);
2257 this.pdpId = newPdp.getPdpKey();
2263 public void updatePdp(OnapPDP pdp, String username){
2264 logger.debug("updatePdp(PDP pdp, String username) as updatePdp("+pdp+","+username+") called");
2266 throw new IllegalArgumentException("PDP pdp must not be null");
2268 if(isNullOrEmpty(pdp.getId(),username)){
2269 throw new IllegalArgumentException("pdp.getId() and username must not be null or empty");
2272 synchronized(emLock){
2273 checkBeforeOperationRun();
2274 Query getPdpQuery = em.createQuery(pdpEntitySelectQuery);
2275 getPdpQuery.setParameter(pdpIdVariable, pdp.getId());
2276 getPdpQuery.setParameter(deletedVar, false);
2277 List<?> getPdpQueryList;
2279 getPdpQueryList = getPdpQuery.getResultList();
2280 } catch(Exception e){
2281 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on getPdpQuery.getResultList()");
2282 throw new PersistenceException("Query failed trying to get PDP "+pdp.getId());
2284 if(getPdpQueryList.isEmpty()){
2285 PolicyLogger.error("The pdp cannot be found to update with id "+pdp.getId());
2286 throw new PersistenceException("The pdp cannot be found to update with id "+pdp.getId());
2287 } else if(getPdpQueryList.size() > 1){
2288 PolicyLogger.error(moreThanOnePDP+pdp.getId()+deletedStatusFound);
2289 throw new PersistenceException(moreThanOnePDP+pdp.getId()+deletedStatusFound);
2291 PdpEntity pdpToUpdate = (PdpEntity)getPdpQueryList.get(0);
2292 if(!stringEquals(pdpToUpdate.getModifiedBy(), username)){
2293 pdpToUpdate.setModifiedBy(username);
2295 if(pdp.getDescription() != null && !stringEquals(pdp.getDescription(),pdpToUpdate.getDescription())){
2296 pdpToUpdate.setDescription(pdp.getDescription());
2298 if(pdp.getName() != null && !stringEquals(pdp.getName(),pdpToUpdate.getPdpName())){
2299 pdpToUpdate.setPdpName(pdp.getName());
2301 if(pdp.getJmxPort() != null && !pdp.getJmxPort().equals(pdpToUpdate.getJmxPort())){
2302 pdpToUpdate.setJmxPort(pdp.getJmxPort());
2306 this.pdpId = pdpToUpdate.getPdpKey();
2311 public void movePdp(OnapPDP pdp, OnapPDPGroup group, String username){
2312 logger.debug("movePdp(PDP pdp, PDPGroup group, String username) as movePdp("+pdp+","+group+","+username+") called");
2313 if(pdp == null || group == null){
2314 throw new IllegalArgumentException("PDP pdp and PDPGroup group must not be null");
2316 if(isNullOrEmpty(username,pdp.getId(),group.getId())){
2317 throw new IllegalArgumentException("pdp.getId(), group.getId(), and username must not be null or empty");
2320 synchronized(emLock){
2321 checkBeforeOperationRun();
2322 //check if pdp exists
2323 Query getPdpQuery = em.createQuery(pdpEntitySelectQuery);
2324 getPdpQuery.setParameter(pdpIdVariable, pdp.getId());
2325 getPdpQuery.setParameter(deletedVar, false);
2326 List<?> getPdpQueryList;
2328 getPdpQueryList = getPdpQuery.getResultList();
2329 } catch(Exception e){
2330 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on getPdpQuery.getResultList()");
2331 throw new PersistenceException("Query failed trying to get pdp to move with id "+pdp.getId());
2333 if(getPdpQueryList.isEmpty()){
2334 PolicyLogger.error("The pdp cannot be found to move with id "+pdp.getId());
2335 throw new PersistenceException("The pdp cannot be found to move with id "+pdp.getId());
2336 } else if(getPdpQueryList.size() > 1){
2337 PolicyLogger.error(moreThanOnePDP+pdp.getId()+deletedStatusFound);
2338 throw new PersistenceException(moreThanOnePDP+pdp.getId()+deletedStatusFound);
2341 //check if new group exists
2342 Query checkGroupQuery = em.createQuery(groupEntitySelectQuery);
2343 checkGroupQuery.setParameter(groupIdVar, group.getId());
2344 checkGroupQuery.setParameter(deletedVar, false);
2345 List<?> checkGroupQueryList;
2347 checkGroupQueryList = checkGroupQuery.getResultList();
2348 } catch(Exception e){
2349 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to get group on checkGroupQuery.getResultList()");
2350 throw new PersistenceException("Query failed trying to get new group "+group.getId());
2352 if(checkGroupQueryList.size() != 1){
2353 PolicyLogger.error("The group "+group.getId()+" does not exist");
2354 throw new PersistenceException("The group "+group.getId()+" does not exist");
2356 GroupEntity groupToMoveInto = (GroupEntity)checkGroupQueryList.get(0);
2357 PdpEntity pdpToUpdate = (PdpEntity)getPdpQueryList.get(0);
2358 pdpToUpdate.setGroup(groupToMoveInto);
2359 if(!stringEquals(pdpToUpdate.getModifiedBy(), username)){
2360 pdpToUpdate.setModifiedBy(username);
2364 this.pdpId = pdpToUpdate.getPdpKey();
2369 public void changeDefaultGroup(OnapPDPGroup group, String username){
2370 logger.debug("changeDefaultGroup(PDPGroup group, String username) as changeDefaultGroup("+group+","+username+") called");
2372 throw new IllegalArgumentException("PDPGroup group must not be null");
2374 if(isNullOrEmpty(group.getId(),username)){
2375 throw new IllegalArgumentException("group.getId() and username must not be null or empty");
2378 synchronized(emLock){
2379 checkBeforeOperationRun();
2380 Query getGroupQuery = em.createQuery(groupEntitySelectQuery);
2381 getGroupQuery.setParameter(groupIdVar, group.getId());
2382 getGroupQuery.setParameter(deletedVar, false);
2383 List<?> getGroupQueryList;
2385 getGroupQueryList = getGroupQuery.getResultList();
2386 } catch(Exception e){
2387 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on getGroupQuery.getResultList()");
2388 throw new PersistenceException(queryFailedToGetGroup+group.getId());
2390 if(getGroupQueryList.isEmpty()){
2391 PolicyLogger.error("The group cannot be found to set default with id "+group.getId());
2392 throw new PersistenceException("The group cannot be found to set default with id "+group.getId());
2393 } else if(getGroupQueryList.size() > 1){
2394 PolicyLogger.error(duplicateGroupId+group.getId()+deletedStatusFound);
2395 throw new PersistenceException(duplicateGroupId+group.getId()+deletedStatusFound);
2397 GroupEntity newDefaultGroup = (GroupEntity)getGroupQueryList.get(0);
2398 newDefaultGroup.setDefaultGroup(true);
2399 if(!stringEquals(newDefaultGroup.getModifiedBy(), username)){
2400 newDefaultGroup.setModifiedBy(username);
2404 this.groupId = newDefaultGroup.getGroupKey();
2405 Query setAllGroupsNotDefault = em.createQuery("UPDATE GroupEntity g SET g.defaultGroup=:defaultGroup WHERE g.deleted=:deleted AND g.groupKey<>:groupKey");
2406 //not going to set modified by for all groups
2407 setAllGroupsNotDefault.setParameter("defaultGroup", false);
2408 setAllGroupsNotDefault.setParameter(deletedVar, false);
2409 setAllGroupsNotDefault.setParameter("groupKey", newDefaultGroup.getGroupKey());
2411 logger.info("set " + setAllGroupsNotDefault.executeUpdate() + " groups as not default");
2412 } catch(Exception e){
2413 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception on setAllGroupsNotDefault.executeUpdate()");
2414 throw new PersistenceException("Could not set all other groups default to false");
2422 public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username) throws PolicyDBException {
2423 logger.debug("deleteGroup(PDPGroup group, PDPGroup moveToGroup, String username) as deleteGroup("+group+", "+moveToGroup+","+username+") called");
2425 throw new IllegalArgumentException("PDPGroup group cannot be null");
2427 if(isNullOrEmpty(username,group.getId())){
2428 throw new IllegalArgumentException("group.getId() and and username must not be null or empty");
2431 if(group.isDefaultGroup()){
2432 PolicyLogger.error("The default group "+group.getId()+" was attempted to be deleted. It cannot be.");
2433 throw new PolicyDBException("You cannot delete the default group.");
2435 synchronized(emLock){
2436 checkBeforeOperationRun();
2437 Query deleteGroupQuery = em.createQuery(groupEntitySelectQuery);
2438 deleteGroupQuery.setParameter(groupIdVar, group.getId());
2439 deleteGroupQuery.setParameter(deletedVar, false);
2440 List<?> deleteGroupQueryList;
2442 deleteGroupQueryList = deleteGroupQuery.getResultList();
2443 } catch(Exception e){
2444 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to check if group exists deleteGroupQuery.getResultList()");
2445 throw new PersistenceException("Query failed trying to check if group exists");
2447 if(deleteGroupQueryList.isEmpty()){
2448 logger.warn(groupCannotBeFound + group.getId());
2450 } else if(deleteGroupQueryList.size() > 1){
2451 PolicyLogger.error(duplicateGroupId+group.getId()+foundInDBNotDeleted);
2452 throw new PersistenceException(duplicateGroupId+group.getId()+foundInDBNotDeleted);
2455 Query pdpsInGroupQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.groupEntity=:group and p.deleted=:deleted");
2456 pdpsInGroupQuery.setParameter("group", ((GroupEntity)deleteGroupQueryList.get(0)));
2457 pdpsInGroupQuery.setParameter(deletedVar, false);
2458 List<?> pdpsInGroupList;
2460 pdpsInGroupList = pdpsInGroupQuery.getResultList();
2461 } catch(Exception e){
2462 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to get PDPs in group on pdpsInGroupQuery.getResultList()");
2463 throw new PersistenceException("Query failed trying to get PDPs in group");
2465 if(!pdpsInGroupList.isEmpty()){
2466 if(moveToGroup != null){
2467 Query checkMoveToGroupQuery = em.createQuery("SELECT o FROM GroupEntity o WHERE o.groupId=:groupId AND o.deleted=:deleted");
2468 checkMoveToGroupQuery.setParameter(groupIdVar, moveToGroup.getId());
2469 checkMoveToGroupQuery.setParameter(deletedVar, false);
2470 List<?> checkMoveToGroupList;
2472 checkMoveToGroupList = checkMoveToGroupQuery.getResultList();
2473 } catch(Exception e){
2474 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to check if group exists checkMoveToGroupQuery.getResultList()");
2475 throw new PersistenceException("Query failed trying to check if group exists");
2477 if(checkMoveToGroupList.isEmpty()){
2478 PolicyLogger.error(groupCannotBeFound + moveToGroup.getId());
2479 throw new PersistenceException(groupCannotBeFound + moveToGroup.getId());
2480 } else if(checkMoveToGroupList.size() > 1){
2481 PolicyLogger.error(duplicateGroupId+moveToGroup.getId()+foundInDBNotDeleted);
2482 throw new PersistenceException(duplicateGroupId+moveToGroup.getId()+foundInDBNotDeleted);
2484 GroupEntity newGroup = (GroupEntity)checkMoveToGroupList.get(0);
2485 for(Object pdpObject : pdpsInGroupList){
2486 PdpEntity pdp = (PdpEntity)pdpObject;
2487 pdp.setGroup(newGroup);
2488 if(!stringEquals(pdp.getModifiedBy(),username)){
2489 pdp.setModifiedBy(username);
2493 this.newGroupId = newGroup.getGroupId();
2494 } catch(PersistenceException e){
2495 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught PersistenceException trying to set pdp group to null on em.flush()");
2496 throw new PersistenceException("Query failed trying to set pdp group to ");
2501 PolicyLogger.error("Group "+group.getId()+" is trying to be delted with PDPs. No group was provided to move them to");
2502 throw new PolicyDBException("Group has PDPs. Must provide a group for them to move to");
2507 GroupEntity groupToDelete = (GroupEntity)deleteGroupQueryList.get(0);
2508 groupToDelete.setDeleted(true);
2509 if(!stringEquals(groupToDelete.getModifiedBy(), username)){
2510 groupToDelete.setModifiedBy(username);
2513 this.groupId = groupToDelete.getGroupKey();
2518 public StdPDPGroup addPolicyToGroup(String groupID, String policyID, String username) throws PolicyDBException {
2519 logger.info("PolicyDBDao: addPolicyToGroup(String groupID, String policyID, String username) as addPolicyToGroup("+groupID+", "+policyID+","+username+") called");
2520 if(isNullOrEmpty(groupID, policyID, username)){
2521 throw new IllegalArgumentException("groupID, policyID, and username must not be null or empty");
2523 synchronized(emLock){
2524 checkBeforeOperationRun();
2525 //check if group exists
2526 Query groupQuery = em.createQuery(groupEntitySelectQuery);
2527 groupQuery.setParameter(groupIdVar, groupID);
2528 groupQuery.setParameter(deletedVar, false);
2529 List<?> groupQueryList;
2531 groupQueryList = groupQuery.getResultList();
2532 }catch(Exception e){
2533 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to check if group exists groupQuery.getResultList()");
2534 throw new PersistenceException("Query failed trying to check if group "+groupID+" exists");
2536 if(groupQueryList.isEmpty()){
2537 PolicyLogger.error("Group policy is being added to does not exist with id "+groupID);
2538 throw new PersistenceException("Group policy is being added to does not exist with id "+groupID);
2539 } else if(groupQueryList.size() > 1){
2540 PolicyLogger.error(duplicateGroupId+groupID+foundInDBNotDeleted);
2541 throw new PersistenceException(duplicateGroupId+groupID+foundInDBNotDeleted);
2544 //we need to convert the form of the policy id that is used groups into the form that is used
2545 //for the database. (com.Config_mypol.1.xml) to (Config_mypol.xml)
2546 String[] policyNameScopeAndVersion = getNameScopeAndVersionFromPdpPolicy(policyID);
2547 if(policyNameScopeAndVersion == null) {
2548 throw new IllegalArgumentException("Invalid input - policyID must contain name, scope and version");
2550 Query policyQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:policyName AND p.scope=:scope AND p.deleted=:deleted");
2551 policyQuery.setParameter("policyName", policyNameScopeAndVersion[0]);
2552 policyQuery.setParameter(scope, policyNameScopeAndVersion[1]);
2553 policyQuery.setParameter(deletedVar, false);
2554 List<?> policyQueryList;
2556 policyQueryList = policyQuery.getResultList();
2557 } catch(Exception e){
2559 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to check if policy exists policyQuery.getResultList()");
2560 throw new PersistenceException("Query failed trying to check if policy "+policyNameScopeAndVersion[0]+" exists");
2562 if(policyQueryList.isEmpty()){
2563 PolicyLogger.error("Policy being added to the group does not exist with policy id "+policyNameScopeAndVersion[0]);
2564 throw new PersistenceException("Policy being added to the group does not exist with policy id "+policyNameScopeAndVersion[0]);
2565 } else if(policyQueryList.size() > 1){
2566 PolicyLogger.error(duplicatePolicyId+policyNameScopeAndVersion[0]+foundInDBNotDeleted);
2567 throw new PersistenceException(duplicateGroupId+policyNameScopeAndVersion[0]+foundInDBNotDeleted);
2569 logger.info("PolicyDBDao: Getting group and policy from database");
2570 GroupEntity group = (GroupEntity)groupQueryList.get(0);
2571 PolicyEntity policy = (PolicyEntity)policyQueryList.get(0);
2572 Iterator<PolicyEntity> policyIt = group.getPolicies().iterator();
2573 String policyName = getPolicyNameAndVersionFromPolicyFileName(policy.getPolicyName())[0];
2575 logger.info("PolicyDBDao: policyName retrieved is " + policyName);
2577 while(policyIt.hasNext()){
2578 PolicyEntity pol = policyIt.next();
2579 if(policy.getScope().equals(pol.getScope()) &&
2580 getPolicyNameAndVersionFromPolicyFileName(pol.getPolicyName())[0].equals(policyName)) {
2584 }catch(Exception e){
2586 PolicyLogger.error("Could not delete old versions for policy "+policy.getPolicyName()+", ID: "+policy.getPolicyId());
2588 group.addPolicyToGroup(policy);
2591 // After adding policy to the db group we need to make sure the filesytem group is in sync with the db group
2593 StdPDPGroup pdpGroup = (StdPDPGroup) papEngine.getGroup(group.getGroupId());
2594 return synchronizeGroupPoliciesInFileSystem(pdpGroup, group);
2595 } catch (PAPException e) {
2597 PolicyLogger.error("PolicyDBDao: Could not synchronize the filesystem group with the database group. " + e.getMessage());
2603 //this means delete pdp not just remove from group
2605 public void removePdpFromGroup(String pdpID, String username) {
2606 logger.debug("removePdpFromGroup(String pdpID, String username) as removePdpFromGroup("+pdpID+","+username+") called");
2607 if(isNullOrEmpty(pdpID,username)){
2608 throw new IllegalArgumentException("pdpID and username must not be null or empty");
2610 synchronized(emLock){
2611 checkBeforeOperationRun();
2612 Query pdpQuery = em.createQuery(pdpEntitySelectQuery);
2613 pdpQuery.setParameter(pdpIdVariable, pdpID);
2614 pdpQuery.setParameter(deletedVar, false);
2617 pdpList = pdpQuery.getResultList();
2618 } catch(Exception e){
2619 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar, "Caught Exception trying to check if pdp exists pdpQuery.getResultList()");
2620 throw new PersistenceException("Query failed trying to check if pdp "+pdpID+" exists");
2622 if(pdpList.size() > 1){
2623 PolicyLogger.error("Somehow, more than one pdp with the id "+pdpID+foundInDBNotDeleted);
2624 throw new PersistenceException("Somehow, more than one pdp with the id "+pdpID+foundInDBNotDeleted);
2625 } else if(pdpList.isEmpty()){
2626 PolicyLogger.error("Pdp being removed does not exist with id "+pdpID);
2629 PdpEntity pdp = (PdpEntity)pdpList.get(0);
2631 if(!stringEquals(pdp.getModifiedBy(),username)){
2632 pdp.setModifiedBy(username);
2634 pdp.setDeleted(true);
2637 this.pdpId = pdp.getPdpKey();
2642 private PolicyDBDao(){
2646 public static PolicyDBDaoTestClass getPolicyDBDaoTestClass(){
2647 return new PolicyDBDao().new PolicyDBDaoTestClass();
2650 final class PolicyDBDaoTestClass {
2651 String getConfigFile(String filename, String scope, PolicyRestAdapter policy){
2652 return scope + "." + PolicyDBDao.this.getConfigFile(filename, policy);
2654 String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName) throws PolicyDBException{
2655 return PolicyDBDao.this.getPolicyNameAndVersionFromPolicyFileName(originalPolicyName);