Fixes to the sonar issues along with some cleanup code to remove warnings.
Issue-Id: POLICY-113
Change-Id: I826562f7509c346210ac865cc6b31bce26bee2cf
Signed-off-by: Tej, Tarun <tt3868@att.com>
// Additional Check due to Limitations from Nexus API to check if the artifact is the latest.
private NexusArtifact additionalNexusLatestCheck(String selectedName, NexusArtifact result) {
+ if(result==null){
+ return result;
+ }
String nextVersion = incrementVersion(result.getVersion());
List<NexusArtifact> artifact = getArtifactFromNexus(selectedName, nextVersion);
return artifact.isEmpty() ? result : additionalNexusLatestCheck(selectedName, artifact.get(0));
private static boolean processLine(Path debugfilePath, String dataFileName, int lastNmRead, LOGTYPE logType){
// log4jlogger must use .info
- Stream<String> lines = null;
- try {
- lines = Files.lines(debugfilePath, Charset.defaultCharset()).onClose(() -> log4jlogger.info(last+dataFileName+ lineRead + lastNmRead)).skip(lastNmRead);
+ try(Stream<String> lines = Files.lines(debugfilePath, Charset.defaultCharset()).onClose(() -> log4jlogger.info(last+dataFileName+ lineRead + lastNmRead)).skip(lastNmRead)){
lines.forEachOrdered(line -> process(line, type, logType));
} catch (IOException e) {
logger.error(loggingProcess + dataFileName, e);
logger.error(breakLoop);
return true;
- }finally{
- if(lines != null){
- lines.close();
- }
}
-
return false;
}
private static void processDebugLogParser(File debugfile, Path debugfilePath, String dataFileName){
import org.onap.policy.pap.xacml.restAuth.CheckPDP;
import org.onap.policy.rest.XACMLRest;
import org.onap.policy.rest.XACMLRestProperties;
+import org.onap.policy.rest.dao.PolicyDBException;
import org.onap.policy.utils.PolicyUtils;
import org.onap.policy.xacml.api.XACMLErrorConstants;
import org.onap.policy.xacml.api.pap.ONAPPapEngineFactory;
})
public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeListener, Runnable {
private static final long serialVersionUID = 1L;
- private static final String localIp = "127.0.0.1";
private static final Logger LOGGER = FlexLogger.getLogger(XACMLPapServlet.class);
// audit (transaction) LOGGER
private static final Logger auditLogger = FlexLogger.getLogger("auditLogger");
* This thread may be invoked upon startup to initiate sending PDP policy/pip configuration when
* this servlet starts. Its configurable by the admin.
*/
- private transient static Thread initiateThread = null;
+ private static transient Thread initiateThread = null;
private transient ONAPLoggingContext baseLoggingContext = null;
/**
// The factory knows how to go about creating a PAP Engine
setPAPEngine((PAPPolicyEngine) factory.newEngine());
PolicyDBDaoTransaction addNewGroup = null;
- try{
- if(((org.onap.policy.xacml.std.pap.StdEngine)papEngine).wasDefaultGroupJustAdded){
- addNewGroup = policyDBDao.getNewTransaction();
- OnapPDPGroup group = papEngine.getDefaultGroup();
- addNewGroup.createGroup(group.getId(), group.getName(), group.getDescription(), "automaticallyAdded");
- addNewGroup.commitTransaction();
- addNewGroup = policyDBDao.getNewTransaction();
- addNewGroup.changeDefaultGroup(group, "automaticallyAdded");
- addNewGroup.commitTransaction();
- }
- } catch(Exception e){
- PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet", " Error creating new default group in the database");
- if(addNewGroup != null){
- addNewGroup.rollbackTransaction();
- }
- }
+ if (((org.onap.policy.xacml.std.pap.StdEngine) papEngine).wasDefaultGroupJustAdded) {
+ try {
+ addNewGroup = policyDBDao.getNewTransaction();
+ OnapPDPGroup group = papEngine.getDefaultGroup();
+ addNewGroup.createGroup(group.getId(), group.getName(), group.getDescription(),
+ "automaticallyAdded");
+ addNewGroup.commitTransaction();
+ addNewGroup = policyDBDao.getNewTransaction();
+ addNewGroup.changeDefaultGroup(group, "automaticallyAdded");
+ addNewGroup.commitTransaction();
+ } catch (Exception e) {
+ PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet",
+ " Error creating new default group in the database");
+ if (addNewGroup != null) {
+ addNewGroup.rollbackTransaction();
+ }
+ }
+ }
policyDBDao.setPapEngine((PAPPolicyEngine) XACMLPapServlet.papEngine);
if (Boolean.parseBoolean(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_RUN_AUDIT_FLAG))){
//get an AuditTransaction to lock out all other transactions
try {
pdpTransaction.addPdpToGroup(id, XACMLPapServlet.papEngine.getDefaultGroup().getId(), id, "Registered on first startup", Integer.parseInt(jmxport), "PDP autoregister");
XACMLPapServlet.papEngine.newPDP(id, XACMLPapServlet.papEngine.getDefaultGroup(), id, "Registered on first startup", Integer.parseInt(jmxport));
- } catch (NullPointerException | PAPException | IllegalArgumentException | IllegalStateException | PersistenceException e) {
+ } catch (NullPointerException | PAPException | IllegalArgumentException | IllegalStateException | PersistenceException | PolicyDBException e) {
pdpTransaction.rollbackTransaction();
String message = "Failed to create new PDP for id: " + id;
PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " " + message);
return;
}
// get the PDP we just created
- pdp = XACMLPapServlet.papEngine.getPDP(id);
+ try{
+ pdp = XACMLPapServlet.papEngine.getPDP(id);
+ }catch(PAPException e){
+ LOGGER.error(e);
+ }
if (pdp == null) {
if(pdpTransaction != null){
pdpTransaction.rollbackTransaction();
}
}
if (jmxport != null && jmxport != ""){
- ((StdPDP) pdp).setJmxPort(Integer.valueOf(jmxport));
+ try{
+ ((StdPDP) pdp).setJmxPort(Integer.valueOf(jmxport));
+ }catch(NumberFormatException e){
+ LOGGER.error(e);
+ }
}
// Get the PDP's Group
- OnapPDPGroup group = XACMLPapServlet.papEngine.getPDPGroup((OnapPDP) pdp);
+ OnapPDPGroup group =null;
+ try{
+ group= XACMLPapServlet.papEngine.getPDPGroup((OnapPDP) pdp);
+ }catch(PAPException e){
+ LOGGER.error(e);
+ }
if (group == null) {
PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " PDP not associated with any group, even the default");
loggingContext.transactionEnded();
Properties pipconfig = group.getPipConfigProperties();
// Get the current policy/pip configuration that the PDP has
Properties pdpProperties = new Properties();
- pdpProperties.load(request.getInputStream());
+ try{
+ pdpProperties.load(request.getInputStream());
+ }catch(IOException e){
+ LOGGER.error(e);
+ }
LOGGER.info("PDP Current Properties: " + pdpProperties.toString());
LOGGER.info("Policies: " + (policies != null ? policies.toString() : "null"));
LOGGER.info("Pip config: " + (pipconfig != null ? pipconfig.toString() : "null"));
// retrieve them.
this.populatePolicyURL(request.getRequestURL(), policies);
// Copy the properties to the output stream
- policies.store(response.getOutputStream(), "");
+ try{
+ policies.store(response.getOutputStream(), "");
+ }catch(IOException e){
+ LOGGER.error(e);
+ }
}
if (pipconfig != null) {
// Copy the properties to the output stream
- pipconfig.store(response.getOutputStream(), "");
+ try{
+ pipconfig.store(response.getOutputStream(), "");
+ }catch(IOException e){
+ LOGGER.error(e);
+ }
}
// We are good - and we are sending them information
response.setStatus(HttpServletResponse.SC_OK);
- setPDPSummaryStatus(pdp, PDPStatus.Status.OUT_OF_SYNCH);
+ try{
+ setPDPSummaryStatus(pdp, PDPStatus.Status.OUT_OF_SYNCH);
+ }catch(PAPException e){
+ LOGGER.error(e);
+ }
} else {
// Tell them they are good
response.setStatus(HttpServletResponse.SC_NO_CONTENT);
- setPDPSummaryStatus(pdp, PDPStatus.Status.UP_TO_DATE);
+ try{
+ setPDPSummaryStatus(pdp, PDPStatus.Status.UP_TO_DATE);
+ }catch(PAPException e){
+ LOGGER.error(e);
+ }
}
// tell the AC that something changed
notifyAC();
String id = this.getPDPID(request);
LOGGER.info("doGet from: " + id);
// Get the PDP Object
- OnapPDP pdp = XACMLPapServlet.papEngine.getPDP(id);
+ OnapPDP pdp = null;
+ try{
+ pdp = XACMLPapServlet.papEngine.getPDP(id);
+ }catch(PAPException e){
+ LOGGER.error(e);
+ }
// Is it known?
if (pdp == null) {
// Check if request came from localhost
if (request.getRemoteHost().equals("localhost") ||
- request.getRemoteHost().equals(localIp) ||
request.getRemoteHost().equals(request.getLocalAddr())) {
// Return status information - basically all the groups
loggingContext.setServiceName("PAP.getGroups");
} catch(Exception e){
PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " Error while updating group in the database: "
+"group="+group.getId());
+ LOGGER.error(e);
throw new PAPException(e.getMessage());
}
try{
policyToDelete = URLDecoder.decode(policyToDelete,"UTF-8");
} catch(UnsupportedEncodingException e){
- PolicyLogger.error("Unsupported URL encoding of policyToDelete (UTF-8");
+ LOGGER.error("Unsupported URL encoding of policyToDelete (UTF-8", e);
setResponseError(response,HttpServletResponse.SC_INTERNAL_SERVER_ERROR,"policyToDelete encoding not supported");
return;
}
try{
removePdpOrGroupTransaction.removePdpFromGroup(pdp.getId(),"XACMLPapServlet.doACDelete");
} catch(Exception e){
- throw new PAPException();
+ throw new PAPException(e);
}
papEngine.removePDP((OnapPDP) pdp);
// adjust the status of the group, which may have changed when we removed this PDP
groups = papEngine.getOnapPDPGroups();
} catch (PAPException e) {
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " getPDPGroups failed");
- throw new RuntimeException(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "Unable to get Groups: " + e);
+ throw new IllegalAccessError(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "Unable to get Groups: " + e);
}
for (OnapPDPGroup group : groups) {
groupChanged(group);
}
String message = "GET:/pap/test called and PAP " + papResourceName + " has had a subsystem failure."
+ " Exception Message: " + eMsg;
- LOGGER.info(message);
+ LOGGER.info(message, e);
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message);
loggingContext.transactionEnded();
PolicyLogger.audit("Transaction Failed - See Error.log");
try {
Files.createDirectories(webappsPathConfig);
} catch (IOException e) {
- PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " Failed to create config directory: "
+ PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", "Failed to create config directory: "
+ webappsPathConfig.toAbsolutePath().toString());
}
}
try {
Files.createDirectories(webappsPathAction);
} catch (IOException e) {
- LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Failed to create config directory: "
+ LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Failed to create action directory: "
+ webappsPathAction.toAbsolutePath().toString(), e);
}
}
import org.onap.policy.rest.jpa.Datatype;
import org.onap.policy.rest.jpa.FunctionDefinition;
import org.onap.policy.xacml.api.XACMLErrorConstants;
+
+import com.att.research.xacml.api.pap.PAPException;
+
import org.onap.policy.common.logging.eelf.MessageCodes;
import org.onap.policy.common.logging.eelf.PolicyLogger;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
protected Map<String, String> dropDownMap = new HashMap<>();
private static boolean isAttribute = false;
- private static synchronized boolean getAttribute () {
+ private synchronized static boolean getAttribute () {
return isAttribute;
}
}
@Override
- public Map<String, String> savePolicies() throws Exception {
+ public Map<String, String> savePolicies() throws PAPException {
Map<String, String> successMap = new HashMap<>();
if(isPolicyExists()){
//This is the method for preparing the policy for saving. We have broken it out
//separately because the fully configured policy is used for multiple things
@Override
- public boolean prepareToSave() throws Exception{
+ public boolean prepareToSave() throws PAPException{
if(isPreparedToSave()){
//we have already done this
import org.onap.policy.common.logging.flexlogger.Logger;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
+import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.std.IdentifierImpl;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType;
}
@Override
- public Map<String, String> savePolicies() throws Exception {
+ public Map<String, String> savePolicies() throws PAPException {
Map<String, String> successMap = new HashMap<>();
if(isPolicyExists()){
//This is the method for preparing the policy for saving. We have broken it out
//separately because the fully configured policy is used for multiple things
@Override
- public boolean prepareToSave() throws Exception{
+ public boolean prepareToSave() throws PAPException{
if(isPreparedToSave()){
//we have already done this
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
+import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.std.IdentifierImpl;
public class ConfigPolicy extends Policy {
}
@Override
- public Map<String, String> savePolicies() throws Exception {
+ public Map<String, String> savePolicies() throws PAPException {
Map<String, String> successMap = new HashMap<>();
if(isPolicyExists()){
//This is the method for preparing the policy for saving. We have broken it out
//separately because the fully configured policy is used for multiple things
@Override
- public boolean prepareToSave() throws Exception{
+ public boolean prepareToSave() throws PAPException{
if(isPreparedToSave()){
return true;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
import org.onap.policy.rest.jpa.BRMSParamTemplate;
+import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.std.IdentifierImpl;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType;
}
@Override
- public Map<String, String> savePolicies() throws Exception {
+ public Map<String, String> savePolicies() throws PAPException {
Map<String, String> successMap = new HashMap<>();
if(isPolicyExists()){
// separately because the fully configured policy is used for multiple
// things
@Override
- public boolean prepareToSave() throws Exception {
+ public boolean prepareToSave() throws PAPException {
if (isPreparedToSave()) {
// we have already done this
import org.onap.policy.pap.xacml.rest.controller.BRMSDictionaryController;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
+import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.std.IdentifierImpl;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType;
}
@Override
- public Map<String, String> savePolicies() throws Exception {
+ public Map<String, String> savePolicies() throws PAPException {
Map<String, String> successMap = new HashMap<>();
if(isPolicyExists()){
// separately because the fully configured policy is used for multiple
// things
@Override
- public boolean prepareToSave() throws Exception {
+ public boolean prepareToSave() throws PAPException {
if (isPreparedToSave()) {
// we have already done this
import org.onap.policy.common.logging.flexlogger.Logger;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
+import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.std.IdentifierImpl;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType;
}
@Override
- public Map<String, String> savePolicies() throws Exception {
+ public Map<String, String> savePolicies() throws PAPException {
Map<String, String> successMap = new HashMap<>();
if(isPolicyExists()){
//This is the method for preparing the policy for saving. We have broken it out
//separately because the fully configured policy is used for multiple things
@Override
- public boolean prepareToSave() throws Exception{
+ public boolean prepareToSave() throws PAPException{
if(isPreparedToSave()){
//we have already done this
import org.onap.policy.xacml.std.pip.engines.aaf.AAFEngine;
import org.onap.policy.xacml.util.XACMLPolicyScanner;
+import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.std.IdentifierImpl;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType;
}
@Override
- public Map<String, String> savePolicies() throws Exception {
+ public Map<String, String> savePolicies() throws PAPException {
Map<String, String> successMap = new HashMap<>();
if(isPolicyExists()){
//This is the method for preparing the policy for saving. We have broken it out
//separately because the fully configured policy is used for multiple things
@Override
- public boolean prepareToSave() throws Exception{
+ public boolean prepareToSave() throws PAPException{
if(isPreparedToSave()){
//we have already done this
yamlParams.put(ONAPNAME, policyAdapter.getOnapName());
Map<String, String> params = policyAdapter.getDynamicFieldConfigAttributes();
yamlParams.putAll(params);
- // Call YAML to XACML
- PolicyType decisionPolicy = getGuardPolicy(yamlParams, policyAdapter.getRuleProvider());
- decisionPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId());
- decisionPolicy.setVersion(Integer.toString(version));
- policyAdapter.setPolicyData(decisionPolicy);
- policyAdapter.setData(decisionPolicy);
+ // Call YAML to XACML
+ try {
+ PolicyType decisionPolicy = getGuardPolicy(yamlParams, policyAdapter.getRuleProvider());
+ decisionPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId());
+ decisionPolicy.setVersion(Integer.toString(version));
+ policyAdapter.setPolicyData(decisionPolicy);
+ policyAdapter.setData(decisionPolicy);
+ } catch (BuilderException e) {
+ LOGGER.error(e);
+ throw new PAPException(e);
+ }
}else if (policyAdapter.getData() != null) {
PolicyType decisionPolicy = (PolicyType) policyAdapter.getData();
import org.onap.policy.rest.jpa.TermList;
import org.onap.policy.rest.jpa.UserInfo;
+import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.std.IdentifierImpl;
import com.fasterxml.jackson.databind.JsonNode;
import com.github.fge.jackson.JsonLoader;
}
@Override
- public Map<String, String> savePolicies() throws Exception {
+ public Map<String, String> savePolicies() throws PAPException {
Map<String, String> successMap = new HashMap<>();
if(isPolicyExists()){
successMap.put("EXISTS", "This Policy already exist on the PAP");
if (policyAdapter.isEditPolicy()) {
dbIsUpdated = updateFirewallDictionaryData(policyAdapter.getJsonBody(), policyAdapter.getPrevJsonBody());
} else {
- dbIsUpdated = insertFirewallDicionaryData(policyAdapter.getJsonBody());
+ try {
+ dbIsUpdated = insertFirewallDicionaryData(policyAdapter.getJsonBody());
+ } catch (SQLException e) {
+ throw new PAPException(e);
+ }
}
} else {
dbIsUpdated = true;
//This is the method for preparing the policy for saving. We have broken it out
//separately because the fully configured policy is used for multiple things
@Override
- public boolean prepareToSave() throws Exception{
+ public boolean prepareToSave() throws PAPException{
if(isPreparedToSave()){
//we have already done this
package org.onap.policy.pap.xacml.rest.components;
import java.io.File;
+import java.io.IOException;
import java.io.PrintWriter;
import java.net.URI;
import java.net.URISyntaxException;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
import org.onap.policy.rest.jpa.MicroServiceModels;
+import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.std.IdentifierImpl;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
@Override
- public Map<String, String> savePolicies() throws Exception {
+ public Map<String, String> savePolicies() throws PAPException {
Map<String, String> successMap = new HashMap<>();
if(isPolicyExists()){
//This is the method for preparing the policy for saving. We have broken it out
//separately because the fully configured policy is used for multiple things
@Override
- public boolean prepareToSave() throws Exception{
+ public boolean prepareToSave() throws PAPException{
if(isPreparedToSave()){
//we have already done this
//setup values for pulling out matching attributes
ObjectMapper mapper = new ObjectMapper();
- JsonNode rootNode = mapper.readTree(policyAdapter.getJsonBody());
String matching = null;
-
- if (policyAdapter.getTtlDate()==null){
- policyAdapter.setTtlDate("NA");
- }
- if (policyAdapter.getServiceType().contains("-v")){
- matching = getValueFromDictionary(policyAdapter.getServiceType());
- } else {
- String jsonVersion = StringUtils.replaceEach(rootNode.get("version").toString(), new String[]{"\""}, new String[]{""});
- matching = getValueFromDictionary(policyAdapter.getServiceType() + "-v" + jsonVersion);
- }
-
Map<String, String> matchMap = null;
- if (matching != null && !matching.isEmpty()){
- matchMap = Splitter.on(",").withKeyValueSeparator("=").split(matching);
- setMatchMap(matchMap);
- if(policyAdapter.getJsonBody() != null){
- pullMatchValue(rootNode);
+ try {
+ JsonNode rootNode = mapper.readTree(policyAdapter.getJsonBody());
+ if (policyAdapter.getTtlDate()==null){
+ policyAdapter.setTtlDate("NA");
+ }
+ if (policyAdapter.getServiceType().contains("-v")){
+ matching = getValueFromDictionary(policyAdapter.getServiceType());
+ } else {
+ String jsonVersion = StringUtils.replaceEach(rootNode.get("version").toString(), new String[]{"\""}, new String[]{""});
+ matching = getValueFromDictionary(policyAdapter.getServiceType() + "-v" + jsonVersion);
+ }
+ if (matching != null && !matching.isEmpty()){
+ matchMap = Splitter.on(",").withKeyValueSeparator("=").split(matching);
+ setMatchMap(matchMap);
+ if(policyAdapter.getJsonBody() != null){
+ pullMatchValue(rootNode);
+ }
}
+ } catch (IOException e1) {
+ throw new PAPException(e1);
}
// Match for policyName
import org.onap.policy.rest.adapter.PolicyRestAdapter;
import org.onap.policy.xacml.util.XACMLPolicyWriter;
+import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.std.IdentifierImpl;
import com.att.research.xacml.util.XACMLProperties;
import com.att.research.xacmlatt.pdp.policy.PolicyDef;
* @return Either the PolicyAdapter.getData() or PolicyAdapter.getPolicyData()
*/
public abstract Object getCorrectPolicyDataObject();
- public abstract Map<String, String> savePolicies() throws Exception;
+ public abstract Map<String, String> savePolicies() throws PAPException;
//This is the method for preparing the policy for saving. We have broken it out
//separately because the fully configured policy is used for multiple things
- public abstract boolean prepareToSave() throws Exception;
+ public abstract boolean prepareToSave() throws PAPException;
// create match for onap and config name
protected static boolean isJSONValid(String data) {
JsonReader jsonReader = null;
try {
- JSONObject j = new JSONObject(data);
+ new JSONObject(data);
InputStream stream = new ByteArrayInputStream(data.getBytes(StandardCharsets.UTF_8));
jsonReader = Json.createReader(stream);
LOGGER.info("Json Value is: " + jsonReader.read().toString() );
return actionHome;
}
- private static void loadWebapps() throws Exception{
+ private static void loadWebapps() throws PAPException{
if(actionHome == null || configHome == null){
Path webappsPath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS));
//Sanity Check
if (webappsPath == null) {
PolicyLogger.error("Invalid Webapps Path Location property : " + XACMLRestProperties.PROP_PAP_WEBAPPS);
- throw new Exception("Invalid Webapps Path Location property : " + XACMLRestProperties.PROP_PAP_WEBAPPS);
+ throw new PAPException("Invalid Webapps Path Location property : " + XACMLRestProperties.PROP_PAP_WEBAPPS);
}
Path webappsPathConfig;
Path webappsPathAction;
webappsPathConfig = Paths.get(webappsPath.toString()+"/Config");
webappsPathAction = Paths.get(webappsPath.toString()+"/Action");
}
- if(Files.notExists(webappsPathConfig)){
+ if(!webappsPathConfig.toFile().exists()){
try {
Files.createDirectories(webappsPathConfig);
} catch (IOException e) {
PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "Policy", "Failed to create config directory");
}
}
- if(Files.notExists(webappsPathAction)){
+ if(!webappsPathAction.toFile().exists()){
try {
Files.createDirectories(webappsPathAction);
} catch (IOException e) {
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
+import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.nio.file.InvalidPathException;
import java.nio.file.Path;
import java.nio.file.Paths;
+import java.security.InvalidKeyException;
import java.security.Key;
+import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.Date;
import java.util.HashMap;
import java.util.Set;
import java.util.UUID;
+import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
import org.onap.policy.rest.XACMLRestProperties;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
+import org.onap.policy.rest.dao.PolicyDBException;
import org.onap.policy.rest.jpa.ActionBodyEntity;
import org.onap.policy.rest.jpa.ConfigurationDataEntity;
import org.onap.policy.rest.jpa.DatabaseLockEntity;
* @return The new instance of PolicyDBDao or throw exception if the given emf is null.
* @throws IllegalStateException if a PolicyDBDao has already been constructed. Call getPolicyDBDaoInstance() to get this.
*/
- public static PolicyDBDao getPolicyDBDaoInstance(EntityManagerFactory emf) throws Exception{
+ public static PolicyDBDao getPolicyDBDaoInstance(EntityManagerFactory emf){
logger.debug("getPolicyDBDaoInstance(EntityManagerFactory emf) as getPolicyDBDaoInstance("+emf+") called");
if(currentInstance == null){
if(emf != null){
* @return The instance of PolicyDBDao or throws exception if the given instance is null.
* @throws IllegalStateException if a PolicyDBDao instance is null. Call createPolicyDBDaoInstance(EntityManagerFactory emf) to get this.
*/
- public static PolicyDBDao getPolicyDBDaoInstance() throws Exception{
+ public static PolicyDBDao getPolicyDBDaoInstance(){
logger.debug("getPolicyDBDaoInstance() as getPolicyDBDaoInstance() called");
if(currentInstance != null){
return currentInstance;
return urlUserPass;
}
- private static String encryptPassword(String password) throws Exception{
+ private static String encryptPassword(String password) throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, aesKey());
byte[] encryption = cipher.doFinal(password.getBytes("UTF-8"));
- System.out.println(encryption);
+ logger.debug("Encryption value is " + encryption);
return new String(Base64.getMimeEncoder().encode(encryption),"UTF-8");
}
- private static String decryptPassword(String encryptedPassword) throws Exception{
+ private static String decryptPassword(String encryptedPassword) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException{
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, aesKey());
byte[] password = cipher.doFinal(Base64.getDecoder().decode(encryptedPassword.getBytes("UTF-8")));
//no changes should be being made in this function, we still need to close
transaction.rollbackTransaction();
}
- private void handleIncomingGroupChange(String url, String groupId, String extraData,PolicyDBDaoTransaction transaction,XACMLPapServlet xacmlPapServlet) throws PAPException{
+ private void handleIncomingGroupChange(String url, String groupId, String extraData,PolicyDBDaoTransaction transaction,XACMLPapServlet xacmlPapServlet) throws PAPException, PolicyDBException{
GroupEntity groupRecord = null;
long groupIdLong = -1;
try{
//call command that corresponds to the change that was made
}
//this will also handle removes, since incoming pdpGroup has no policies internally, we are just going to add them all in from the db
- private boolean updateGroupPoliciesInFileSystem(OnapPDPGroup pdpGroup,OnapPDPGroup oldPdpGroup, GroupEntity groupRecord, PolicyDBDaoTransaction transaction) throws PAPException{
+ private boolean updateGroupPoliciesInFileSystem(OnapPDPGroup pdpGroup,OnapPDPGroup oldPdpGroup, GroupEntity groupRecord, PolicyDBDaoTransaction transaction) throws PAPException, PolicyDBException{
if(!(pdpGroup instanceof StdPDPGroup)){
throw new PAPException("group is not a StdPDPGroup");
}
return didUpdate;
}
- private String removeExtensionAndVersionFromPolicyName(String originalPolicyName){
+ private String removeExtensionAndVersionFromPolicyName(String originalPolicyName) throws PolicyDBException{
return getPolicyNameAndVersionFromPolicyFileName(originalPolicyName)[0];
}
* @param originalPolicyName: a policy file name ex: Config_policy.2.xml
* @return An array [0]: The policy name, [1]: the policy version, as a string
*/
- private String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName){
+ private String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName) throws PolicyDBException{
String policyName = originalPolicyName;
String[] nameAndVersion = new String[2];
try{
policyName = removeFileExtension(policyName);
nameAndVersion[0] = policyName.substring(0,policyName.lastIndexOf('.'));
if(isNullOrEmpty(nameAndVersion[0])){
- throw new Exception();
+ throw new PolicyDBException();
}
} catch(Exception e){
nameAndVersion[0] = originalPolicyName;
try{
nameAndVersion[1] = policyName.substring(policyName.lastIndexOf('.')+1);
if(isNullOrEmpty(nameAndVersion[1])){
- throw new Exception();
+ throw new PolicyDBException();
}
} catch(Exception e){
nameAndVersion[1] = "1";
@Override
- public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username) throws PAPException {
+ public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username) throws PolicyDBException {
logger.debug("deleteGroup(PDPGroup group, PDPGroup moveToGroup, String username) as deleteGroup("+group+", "+moveToGroup+","+username+") called");
if(group == null){
throw new IllegalArgumentException("PDPGroup group cannot be null");
if(group.isDefaultGroup()){
PolicyLogger.error("The default group "+group.getId()+" was attempted to be deleted. It cannot be.");
- throw new PAPException("You cannot delete the default group.");
+ throw new PolicyDBException("You cannot delete the default group.");
}
synchronized(emLock){
checkBeforeOperationRun();
}
} else {
PolicyLogger.error("Group "+group.getId()+" is trying to be delted with PDPs. No group was provided to move them to");
- throw new PAPException("Group has PDPs. Must provide a group for them to move to");
+ throw new PolicyDBException("Group has PDPs. Must provide a group for them to move to");
}
}
}
@Override
- public void addPolicyToGroup(String groupID, String policyID, String username) {
+ public void addPolicyToGroup(String groupID, String policyID, String username) throws PolicyDBException {
logger.debug("addPolicyToGroup(String groupID, String policyID, String username) as addPolicyToGroup("+groupID+", "+policyID+","+username+") called");
if(isNullOrEmpty(groupID, policyID, username)){
throw new IllegalArgumentException("groupID, policyID, and username must not be null or empty");
String computeScope(String fullPath, String pathToExclude){
return PolicyDBDao.computeScope(fullPath, pathToExclude);
}
- String encryptPassword(String password) throws Exception{
+ String encryptPassword(String password) throws InvalidKeyException, UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException{
return PolicyDBDao.encryptPassword(password);
}
- String decryptPassword(String password) throws Exception{
+ String decryptPassword(String password) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException{
return PolicyDBDao.decryptPassword(password);
}
String getDescriptionFromXacml(String xacmlData){
return PolicyDBDao.getDescriptionFromXacml(xacmlData);
}
- String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName){
+ String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName) throws PolicyDBException{
return PolicyDBDao.this.getPolicyNameAndVersionFromPolicyFileName(originalPolicyName);
}
}
import javax.persistence.PersistenceException;
+import org.onap.policy.rest.dao.PolicyDBException;
import org.onap.policy.rest.jpa.GroupEntity;
import org.onap.policy.rest.jpa.PdpEntity;
import org.onap.policy.xacml.api.pap.OnapPDP;
* @throws PersistenceException If a database error occurs
* @throws IllegalArgumentException If the Policy's PolicyRestAdapter contains incorrect data.
*/
- public void createPolicy(Policy policy, String username) throws IllegalStateException, PersistenceException, IllegalArgumentException;
+ public void createPolicy(Policy policy, String username) throws PolicyDBException;
/**
* Check if the PolicyDBDaoTransaction is currently open
* @param policyToDelete The file path of the policy to delete
* @throws IllegalArgumentException If the file path given can not be parsed
* @throws IllegalStateException If a transaction is open that has not yet been committed
- * @throws PersistenceException If a database error occurs
+ * @throws PolicyDBException If a database error occurs
*/
- public void deletePolicy(String policyToDelete) throws IllegalStateException, PersistenceException, IllegalArgumentException;
+ public void deletePolicy(String policyToDelete) throws PolicyDBException;
/**
* Rollback (undo) the current transaction.
* @throws IllegalStateException If a transaction is already open
* @throws PersistenceException If a database error occurs
*/
- public void createGroup(String groupID, String groupName, String groupDescription, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException;
+ public void createGroup(String groupID, String groupName, String groupDescription, String username) throws PolicyDBException;
/**
* Updates a group in the database with a new name of description
* @throws IllegalStateException If a transaction is already open
* @throws PersistenceException If a database error occurs or if the group can not be found
*/
- public void updateGroup(OnapPDPGroup group, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException;
+ public void updateGroup(OnapPDPGroup group, String username) throws PolicyDBException;
/**
* Updates a PDP in the database with new information
* @throws IllegalStateException If a transaction is already open
* @throws PersistenceException If a database error occurs or if the pdp can not be found
*/
- public void updatePdp(OnapPDP pdp, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException;
+ public void updatePdp(OnapPDP pdp, String username) throws PolicyDBException;
/**
* Change the default group in the database to the group provided.
* @throws IllegalStateException If a transaction is already open
* @throws PersistenceException If a database error occurs
*/
- public void changeDefaultGroup(OnapPDPGroup group, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException;
+ public void changeDefaultGroup(OnapPDPGroup group, String username) throws PolicyDBException;
/**
* Moves a PDP to a new group.
* @throws IllegalStateException If a transaction is already open
* @throws PersistenceException If a database error occurs
*/
- public void movePdp(OnapPDP pdp, OnapPDPGroup group, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException;
+ public void movePdp(OnapPDP pdp, OnapPDPGroup group, String username) throws PolicyDBException;
/**
* Add a new PDP to an existing group
* @throws IllegalStateException If a transaction is already open
* @throws PersistenceException If a database error occurs
*/
- public void addPdpToGroup(String pdpID, String groupID, String pdpName, String pdpDescription, int pdpJmxPort, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException;
+ public void addPdpToGroup(String pdpID, String groupID, String pdpName, String pdpDescription, int pdpJmxPort, String username) throws PolicyDBException;
/**
* Add an existing policy to an existing group
* @throws IllegalArgumentException If non-optional parameters are null or empty strings
* @throws IllegalStateException If a transaction is already open
* @throws PersistenceException If a database error occurs
+ * @throws PolicyDBException
*/
- public void addPolicyToGroup(String group, String policyID, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException;
+ public void addPolicyToGroup(String group, String policyID, String username) throws PolicyDBException;
/**
- * Delete an existing PDP group
+ * Delete an existing PDP groupPolicyDBException
* @param group A PDPGroup object representing the group to delete
* @param moveToGroup A PDPGroup object representing another existing group which PDPs in the group being deleted should be moved to
* @throws IllegalArgumentException If non-optional parameters are null or empty strings
* @throws PersistenceException If a database error occurs
* @throws PAPException If an error relating to how groups are handled occurs
*/
- public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username)throws IllegalArgumentException, IllegalStateException, PersistenceException, PAPException;
+ public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username)throws PolicyDBException;
/**
* Removes an existing PDP from its group and deletes it.
* @throws IllegalStateException If a transaction is already open
* @throws PersistenceException If a database error occurs
*/
- public void removePdpFromGroup(String pdpID, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException;
+ public void removePdpFromGroup(String pdpID, String username) throws PolicyDBException;
public GroupEntity getGroup(long groupKey);
public GroupEntity getGroup(String groupId);
import java.io.IOException;
import java.io.PrintWriter;
-import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.io.IOException;
import java.io.PrintWriter;
-import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;
-import java.io.UnsupportedEncodingException;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
import org.apache.commons.compress.utils.IOUtils;
import org.onap.policy.rest.dao.CommonClassDao;
import org.onap.policy.rest.jpa.Datatype;
import org.onap.policy.rest.jpa.DecisionSettings;
import org.onap.policy.rest.jpa.DescriptiveScope;
-import org.onap.policy.rest.jpa.OnapName;
import org.onap.policy.rest.jpa.GroupServiceList;
+import org.onap.policy.rest.jpa.OnapName;
import org.onap.policy.rest.jpa.PEPOptions;
import org.onap.policy.rest.jpa.PrefixList;
import org.onap.policy.rest.jpa.ProtocolList;
private static final long serialVersionUID = 1L;
};
- public static CommonClassDao commonClassDao;
+ private static CommonClassDao commonClassDao;
@Autowired
public PolicyElasticSearchController(CommonClassDao commonClassDao) {
/**
* List of the string identifiers for the available properties.
*/
- public static Collection<String> PDPPOLICY_PROPERTIES;
+ private static Collection<String> pdpPolicyProperties;
- private final Object data;
- private List<PDPPolicy> policies;
+ private final transient Object data;
+ private
transient List<PDPPolicy> policies;
@SuppressWarnings("unchecked")
public PDPPolicyContainer(Object data) {
super();
this.data = data;
if (this.data instanceof PDPGroup) {
- policies = new ArrayList<PDPPolicy> (((PDPGroup) this.data).getPolicies());
+ policies = new ArrayList<> (((PDPGroup) this.data).getPolicies());
}
if (this.data instanceof PDP) {
- policies = new ArrayList<PDPPolicy> (((PDP) this.data).getPolicies());
+ policies = new ArrayList<> (((PDP) this.data).getPolicies());
}
if (this.data instanceof Set) {
- policies = new ArrayList<
PDPPolicy> ((Set<PDPPolicy>)data);
+ policies = new ArrayList<> ((Set<PDPPolicy>)data);
}
if (this.policies == null) {
logger.info("NULL policies");
}
@Override
- public Object addItemAfter(Object previousItemId)
- throws UnsupportedOperationException {
+ public Object addItemAfter(Object previousItemId){
return null;
}
@Override
public Collection<?> getContainerPropertyIds() {
- return PDPPOLICY_PROPERTIES;
+ return pdpPolicyProperties;
}
@Override
}
@Override
- public Object addItem() throws UnsupportedOperationException {
+ public Object addItem(){
throw new UnsupportedOperationException("Cannot add an empty policy.");
}
@Override
- public boolean removeItem(Object itemId)
- throws UnsupportedOperationException {
+ public boolean removeItem(Object itemId){
if (logger.isTraceEnabled()) {
logger.trace("removeItem: " + itemId);
}
@Override
public boolean addContainerProperty(Object propertyId, Class<?> type,
- Object defaultValue) throws UnsupportedOperationException {
+ Object defaultValue){
return false;
}
@Override
- public boolean removeContainerProperty(Object propertyId)
- throws UnsupportedOperationException {
+ public boolean removeContainerProperty(Object propertyId){
return false;
}
@Override
- public boolean removeAllItems() throws UnsupportedOperationException {
+ public boolean removeAllItems(){
return false;
}
}
@Override
- public Object addItemAt(int index) throws UnsupportedOperationException {
+ public Object addItemAt(int index) {
if (logger.isTraceEnabled()) {
logger.trace("addItemAt: " + index);
}
//Container from where we are fetching the policies
private static PDPPolicyContainer policyContainer;
- private final RemoveGroupPolicy self = this;
+ private RemoveGroupPolicy self = this;
private StdPDPGroup updatedObject;
private final StdPDPGroup group;
private boolean isSaved = false;
if (this.group == null) {
return;
}
-
- RemoveGroupPolicy.policyContainer = new PDPPolicyContainer(group);
+ setRemoveGroupPolicy(new PDPPolicyContainer(group));
RemoveGroupPolicy.policyContainer.removeItem(policy);
}
- @SuppressWarnings("unchecked")
+ private static void setRemoveGroupPolicy(PDPPolicyContainer pdpPolicyContainer) {
+ RemoveGroupPolicy.policyContainer = pdpPolicyContainer;
+ }
+
+ @SuppressWarnings("unchecked")
protected void doSave() {
if (this.group == null) {
return;
}
- //StdPDPGroup pdpGroup = (StdPDPGroup) group;
StdPDPGroup updatedGroupObject = new StdPDPGroup(
group.getId(),
group.isDefaultGroup(),
@RequestMapping(value="/policycreation/save_policy", method = RequestMethod.POST)
@ResponseBody
- public ResponseEntity<String> savePolicy(@RequestBody PolicyRestAdapter policyData, HttpServletResponse response) throws Exception{
+ public ResponseEntity<String> savePolicy(@RequestBody PolicyRestAdapter policyData, HttpServletResponse response){
String body = null;
HttpStatus status = HttpStatus.BAD_REQUEST;
Map<String, String> successMap = new HashMap<>();
import java.util.Set;
import javax.persistence.EntityManager;
-import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.json.JSONObject;
import org.onap.policy.pap.xacml.rest.XACMLPapServlet;
import org.onap.policy.xacml.api.XACMLErrorConstants;
+import com.att.research.xacml.api.pap.PAPException;
+
public class CheckPDP {
private static Path pdpPath = null;
return false;
}
- private static void readFile() throws Exception {
+ private static void readFile() throws PAPException {
String pdpFile = XACMLPapServlet.getPDPFile();
if (pdpFile == null) {
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + "PDP File name is undefined");
- throw new Exception(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"PDP File name not Valid : " + pdpFile);
+ throw new PAPException(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"PDP File name not Valid : " + pdpFile);
}
if (pdpPath == null) {
pdpPath = Paths.get(pdpFile);
if (Files.notExists(pdpPath)) {
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + "File doesn't exist in the specified Path");
- throw new Exception(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"File doesn't exist in the specified Path : "+ pdpPath.toString());
+ throw new PAPException(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"File doesn't exist in the specified Path : "+ pdpPath.toString());
}
if (pdpPath.toString().endsWith(".properties")) {
readProps();
} else {
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + "Not a .properties file");
- throw new Exception(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"Not a .properties file");
+ throw new PAPException(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"Not a .properties file");
}
}
// Check if File is updated recently
}
@SuppressWarnings({ "rawtypes", "unchecked" })
- private static void readProps() throws Exception {
+ private static void readProps() throws PAPException {
InputStream in;
pdpProp = new Properties();
try {
pdpProp.load(in);
} catch (IOException e) {
PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "CheckPDP", "Cannot load the Properties file");
- throw new Exception("Cannot Load the Properties file", e);
+ throw new PAPException("Cannot Load the Properties file", e);
}
// Read the Properties and Load the PDPs and encoding.
pdpMap = new HashMap<>();
if (propKey.startsWith("PDP_URL")) {
String check_val = pdpProp.getProperty(propKey);
if (check_val == null) {
- throw new Exception("Properties file doesn't have the PDP_URL parameter");
+ throw new PAPException("Properties file doesn't have the PDP_URL parameter");
}
if (check_val.contains(";")) {
List<String> pdp_default = new ArrayList<>(Arrays.asList(check_val.split("\\s*;\\s*")));
}
if (pdpMap == null || pdpMap.isEmpty()) {
logger.debug(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "Cannot Proceed without PDP_URLs");
- throw new Exception(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"Cannot Proceed without PDP_URLs");
+ throw new PAPException(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"Cannot Proceed without PDP_URLs");
}
}
- private static void readPDPParam(String pdpVal) throws Exception{
+ private static void readPDPParam(String pdpVal) throws PAPException{
if(pdpVal.contains(",")){
List<String> pdpValues = new ArrayList<>(Arrays.asList(pdpVal.split("\\s*,\\s*")));
if(pdpValues.size()==3){
pdpMap.put(pdpValues.get(0), encoder.encodeToString((userID+":"+pass).getBytes(StandardCharsets.UTF_8)));
}else{
PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + "No Credentials to send Request");
- throw new Exception(XACMLErrorConstants.ERROR_PERMISSIONS + "No enough Credentials to send Request. " + pdpValues);
+ throw new PAPException(XACMLErrorConstants.ERROR_PERMISSIONS + "No enough Credentials to send Request. " + pdpValues);
}
}else{
PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + "No Credentials to send Request: " + pdpVal);
- throw new Exception(XACMLErrorConstants.ERROR_PERMISSIONS +"No enough Credentials to send Request.");
+ throw new PAPException(XACMLErrorConstants.ERROR_PERMISSIONS +"No enough Credentials to send Request.");
}
}
import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
import org.onap.policy.rest.XACMLRestProperties;
import org.onap.policy.rest.adapter.PolicyRestAdapter;
+import org.onap.policy.rest.dao.PolicyDBException;
import org.onap.policy.rest.jpa.GroupEntity;
import org.onap.policy.rest.jpa.PdpEntity;
import org.onap.policy.rest.jpa.PolicyEntity;
import org.onap.policy.xacml.std.pap.StdPDPGroup;
import org.onap.policy.xacml.util.XACMLPolicyWriter;
-import com.att.research.xacml.api.pap.PAPException;
import com.att.research.xacml.util.XACMLProperties;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
group.commitTransaction();
Assert.fail();
- } catch(PAPException pe){
+ } catch(PolicyDBException pe){
//good, can't delete group with pdps
group.rollbackTransaction();
} catch(Exception e){
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP-REST
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.rest.dao;
+
+/**
+ * PolicyDBException extends <code>Exception</code> to implement exceptions thrown by Policy Database transactions.
+ *
+ * @version 0.1
+ */
+public class PolicyDBException extends Exception {
+ private static final long serialVersionUID = -6162444281003852781L;
+
+ public PolicyDBException() {
+ }
+
+ public PolicyDBException(String message) {
+ super(message);
+ }
+
+ public PolicyDBException(Throwable cause){
+ super(cause);
+ }
+
+ public PolicyDBException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public PolicyDBException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+ super(message, cause, enableSuppression, writableStackTrace);
+ }
+}
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-site-plugin</artifactId>
- <version>3.6</version>
<dependencies>
<dependency>
<groupId>org.apache.maven.wagon</groupId>
Code Review / policy / engine.git / commitdiff