return;
         }
         if (isProxyServer()) {
-            try {
-                super.doGet(req, resp);
-            } catch (IOException ioe) {
-                eventlogger.error("IOException" + ioe.getMessage());
-            }
+            super.doGet(req, resp);
             return;
         }
         String bhdr = req.getHeader(BEHALF_HEADER);
             return;
         }
         if (isProxyServer()) {
-            try {
-                super.doPost(req, resp);
-            } catch (IOException ioe) {
-                eventlogger.error("IOException" + ioe.getMessage());
-            }
+            super.doPost(req, resp);
             return;
         }
         String bhdr = req.getHeader(BEHALF_HEADER);
 
             return;
         }
         if (isProxyServer()) {
-            try {
-                super.doDelete(req, resp);
-            } catch (IOException ioe) {
-                eventlogger.error("IOException" + ioe.getMessage());
-            }
+            super.doDelete(req, resp);
             return;
         }
         String bhdr = req.getHeader(BEHALF_HEADER);
             return;
         }
         if (isProxyServer()) {
-            try {
-                super.doGet(req, resp);
-            } catch (IOException ioe) {
-                eventlogger.error("IOException" + ioe.getMessage());
-            }
+            super.doGet(req, resp);
             return;
         }
         String bhdr = req.getHeader(BEHALF_HEADER);
             return;
         }
         if (isProxyServer()) {
-            try {
-                super.doPut(req, resp);
-            } catch (IOException ioe) {
-                eventlogger.error("IOException" + ioe.getMessage());
-            }
+            super.doPut(req, resp);
             return;
         }
         String bhdr = req.getHeader(BEHALF_HEADER);
 
             return;
         }
         if (isProxyServer()) {
-            try {
-                super.doGet(req, resp);
-            } catch (IOException ioe) {
-                eventlogger.error("IOException" + ioe.getMessage());
-            }
+            super.doGet(req, resp);
             return;
         }
         String bhdr = req.getHeader(BEHALF_HEADER);
             return;
         }
         if (isProxyServer()) {
-            try {
-                super.doPut(req, resp);
-            } catch (IOException ioe) {
-                eventlogger.error("IOException" + ioe.getMessage());
-            }
+            super.doPut(req, resp);
             return;
         }
         String bhdr = req.getHeader(BEHALF_HEADER);
             return;
         }
         if (isProxyServer()) {
-            try {
-                super.doPost(req, resp);
-            } catch (IOException ioe) {
-                eventlogger.error("IOException" + ioe.getMessage());
-            }
+            super.doPost(req, resp);
             return;
         }
         String bhdr = req.getHeader(BEHALF_HEADER);
 
         String path = req.getPathInfo();
         if (path.startsWith("/api/")) {
             if (isProxyOK(req) && isProxyServer()) {
-                try {
-                    super.doDelete(req, resp);
-                } catch (IOException ioe) {
-                    intlogger.error("IOException" + ioe.getMessage());
-                }
+                super.doDelete(req, resp);
                 return;
             }
             String key = path.substring(5);
         }
         if (path.equals("/prov")) {
             if (isProxyOK(req) && isProxyServer()) {
-                try {
-                    if (super.doGetWithFallback(req, resp)) {
-                        return;
-                    }
-                } catch (IOException ioe) {
-                    intlogger.error("IOException" + ioe.getMessage());
+                if (super.doGetWithFallback(req, resp)) {
+                    return;
                 }
                 // fall back to returning the local data if the remote is unreachable
                 intlogger.info("Active server unavailable; falling back to local copy.");
         }
         if (path.startsWith("/api/")) {
             if (isProxyOK(req) && isProxyServer()) {
-                try {
-                    super.doGet(req, resp);
-                } catch (IOException ioe) {
-                    intlogger.error("IOException" + ioe.getMessage());
-                }
+                super.doGet(req, resp);
                 return;
             }
             String key = path.substring(5);
         String path = req.getPathInfo();
         if (path.startsWith("/api/")) {
             if (isProxyOK(req) && isProxyServer()) {
-                try {
-                    super.doPut(req, resp);
-                } catch (IOException ioe) {
-                    intlogger.error("IOException" + ioe.getMessage());
-                }
+                super.doPut(req, resp);
                 return;
             }
             String key = path.substring(5);
         String path = req.getPathInfo();
         if (path.startsWith("/api/")) {
             if (isProxyOK(req) && isProxyServer()) {
-                try {
-                    super.doPost(req, resp);
-                } catch (IOException ioe) {
-                    intlogger.error("IOException" + ioe.getMessage());
-                }
+                super.doPost(req, resp);
                 return;
             }
             String key = path.substring(5);
 
     public static final String DEFAULT_TRUSTSTORE = "/opt/java/jdk/jdk180/jre/lib/security/cacerts";
     public static final String KEYSTORE_TYPE_PROPERTY = "org.onap.dmaap.datarouter.provserver.keystore.type";
     public static final String KEYSTORE_PATH_PROPERTY = "org.onap.dmaap.datarouter.provserver.keystore.path";
-    public static final String KEYSTORE_PASSWORD_PROPERTY = "org.onap.dmaap.datarouter.provserver.keystore.password";
+    public static final String KEYSTORE_PASS_PROPERTY = "org.onap.dmaap.datarouter.provserver.keystore.password";
     public static final String TRUSTSTORE_PATH_PROPERTY = "org.onap.dmaap.datarouter.provserver.truststore.path";
-    public static final String TRUSTSTORE_PASSWORD_PROPERTY = "org.onap.dmaap.datarouter.provserver.truststore.password";
+    public static final String TRUSTSTORE_PASS_PROPERTY = "org.onap.dmaap.datarouter.provserver.truststore.password";
 
     /**
      * The one and only {@link Server} instance in this JVM
         Logger logger = Logger.getLogger("org.onap.dmaap.datarouter.provisioning.internal");
 
         // Check DB is accessible and contains the expected tables
-        if (!checkDatabase(logger)) {
+        if (!checkDatabase()) {
             System.exit(1);
         }
 
             // HTTPS connector
             SslContextFactory sslContextFactory = new SslContextFactory();
             sslContextFactory.setKeyStorePath(p.getProperty(KEYSTORE_PATH_PROPERTY));
-            sslContextFactory.setKeyStorePassword(p.getProperty(KEYSTORE_PASSWORD_PROPERTY));
+            sslContextFactory.setKeyStorePassword(p.getProperty(KEYSTORE_PASS_PROPERTY));
             sslContextFactory
                     .setKeyManagerPassword(p.getProperty("org.onap.dmaap.datarouter.provserver.keymanager.password"));
             // SSL stuff
 
                 sslContextFactory.setKeyStoreType(p.getProperty(KEYSTORE_TYPE_PROPERTY, "jks"));
                 sslContextFactory.setKeyStorePath(p.getProperty(KEYSTORE_PATH_PROPERTY));
-                sslContextFactory.setKeyStorePassword(p.getProperty(KEYSTORE_PASSWORD_PROPERTY));
+                sslContextFactory.setKeyStorePassword(p.getProperty(KEYSTORE_PASS_PROPERTY));
                 sslContextFactory
                         .setKeyManagerPassword(p.getProperty("org.onap.dmaap.datarouter.provserver.keymanager.password"));
 
                 String ts = p.getProperty(TRUSTSTORE_PATH_PROPERTY);
                 if (ts != null && ts.length() > 0) {
-                    System.out.println("@@ TS -> " + ts);
+                    logger.info("@@ TS -> " + ts);
                     sslContextFactory.setTrustStorePath(ts);
-                    sslContextFactory.setTrustStorePassword(p.getProperty(TRUSTSTORE_PASSWORD_PROPERTY));
+                    sslContextFactory.setTrustStorePassword(p.getProperty(TRUSTSTORE_PASS_PROPERTY));
                 } else {
                     sslContextFactory.setTrustStorePath(DEFAULT_TRUSTSTORE);
                     sslContextFactory.setTrustStorePassword("changeit");
         logger.info("PROV0001 **** AT&T Data Router Provisioning Server halted.");
     }
 
-    private static boolean checkDatabase(Logger logger) {
+    private static boolean checkDatabase() {
         DB db = new DB();
         return db.runRetroFits();
     }
 
 import org.onap.dmaap.datarouter.provisioning.utils.DB;
 import org.onap.dmaap.datarouter.provisioning.utils.URLUtilities;
 
+import static org.onap.dmaap.datarouter.provisioning.utils.HttpServletUtils.sendResponseError;
+
 /**
  * This class is the base class for those servlets that need to proxy their requests from the standby to active server.
  * Its methods perform the proxy function to the active server. If the active server is not reachable, a 503
             Properties props = (new DB()).getProperties();
             String type = props.getProperty(Main.KEYSTORE_TYPE_PROPERTY, "jks");
             String store = props.getProperty(Main.KEYSTORE_PATH_PROPERTY);
-            String pass = props.getProperty(Main.KEYSTORE_PASSWORD_PROPERTY);
+            String pass = props.getProperty(Main.KEYSTORE_PASS_PROPERTY);
             KeyStore keyStore = readStore(store, pass, type);
 
             store = props.getProperty(Main.TRUSTSTORE_PATH_PROPERTY);
-            pass = props.getProperty(Main.TRUSTSTORE_PASSWORD_PROPERTY);
+            pass = props.getProperty(Main.TRUSTSTORE_PASS_PROPERTY);
             if (store == null || store.length() == 0) {
                 store = Main.DEFAULT_TRUSTSTORE;
                 pass = "changeit";
             // We are connecting with the node name, but the certificate will have the CNAME
             // So we need to accept a non-matching certificate name
             SSLSocketFactory socketFactory = new SSLSocketFactory(keyStore,
-                props.getProperty(Main.KEYSTORE_PASSWORD_PROPERTY), trustStore);
+                props.getProperty(Main.KEYSTORE_PASS_PROPERTY), trustStore);
             socketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
             sch = new Scheme("https", 443, socketFactory);
             inited = true;
         } catch (Exception e) {
-            e.printStackTrace();
+            intlogger.error("ProxyServlet: " + e.getMessage());
         }
         intlogger.info("ProxyServlet: inited = " + inited);
     }
         } catch (FileNotFoundException fileNotFoundException) {
             intlogger.error("ProxyServlet: " + fileNotFoundException.getMessage());
         } catch (Exception x) {
-            System.err.println("READING TRUSTSTORE: " + x);
+            intlogger.error("READING TRUSTSTORE: " + x);
         }
         return ks;
     }
      * Issue a proxy DELETE to the active provisioning server.
      */
     @Override
-    public void doDelete(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+    public void doDelete(HttpServletRequest req, HttpServletResponse resp) {
         doProxy(req, resp, "DELETE");
     }
 
      * Issue a proxy GET to the active provisioning server.
      */
     @Override
-    public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+    public void doGet(HttpServletRequest req, HttpServletResponse resp) {
         doProxy(req, resp, "GET");
     }
 
      * Issue a proxy PUT to the active provisioning server.
      */
     @Override
-    public void doPut(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+    public void doPut(HttpServletRequest req, HttpServletResponse resp) {
         doProxy(req, resp, "PUT");
     }
 
      * Issue a proxy POST to the active provisioning server.
      */
     @Override
-    public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+    public void doPost(HttpServletRequest req, HttpServletResponse resp) {
         doProxy(req, resp, "POST");
     }
 
      *
      * @return true if the proxy succeeded
      */
-    public boolean doGetWithFallback(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+    public boolean doGetWithFallback(HttpServletRequest req, HttpServletResponse resp) {
         boolean rv = false;
         if (inited) {
             String url = buildUrl(req);
                     copyRequestHeaders(req, proxy);
 
                     // Execute the request
-                    HttpResponse pxy_response = httpclient.execute(proxy);
+                    HttpResponse pxyResponse = httpclient.execute(proxy);
 
                     // Get response headers and body
-                    int code = pxy_response.getStatusLine().getStatusCode();
+                    int code = pxyResponse.getStatusLine().getStatusCode();
                     resp.setStatus(code);
-                    copyResponseHeaders(pxy_response, resp);
-
-                    HttpEntity entity = pxy_response.getEntity();
-                    if (entity != null) {
-                        InputStream in = entity.getContent();
-                        IOUtils.copy(in, resp.getOutputStream());
-                        in.close();
-                    }
+                    copyResponseHeaders(pxyResponse, resp);
+                    copyEntityContent(pxyResponse, resp);
                     rv = true;
 
                 } catch (IOException e) {
-                    System.err.println("ProxyServlet: " + e);
-                    e.printStackTrace();
+                    intlogger.error("ProxyServlet: " + e.getMessage());
                 } finally {
                     proxy.releaseConnection();
                     httpclient.getConnectionManager().shutdown();
         return rv;
     }
 
-    private void doProxy(HttpServletRequest req, HttpServletResponse resp, final String method) throws IOException {
+    private void doProxy(HttpServletRequest req, HttpServletResponse resp, final String method) {
         if (inited && isProxyServer()) {
             String url = buildUrl(req);
             intlogger.info("ProxyServlet: proxying " + method + " " + url);
                     }
 
                     // Execute the request
-                    HttpResponse pxy_response = httpclient.execute(proxy);
+                    HttpResponse pxyResponse = httpclient.execute(proxy);
 
                     // Get response headers and body
-                    int code = pxy_response.getStatusLine().getStatusCode();
+                    int code = pxyResponse.getStatusLine().getStatusCode();
                     resp.setStatus(code);
-                    copyResponseHeaders(pxy_response, resp);
-
-                    HttpEntity entity = pxy_response.getEntity();
-                    if (entity != null) {
-                        InputStream in = entity.getContent();
-                        IOUtils.copy(in, resp.getOutputStream());
-                        in.close();
-                    }
+                    copyResponseHeaders(pxyResponse, resp);
+                    copyEntityContent(pxyResponse, resp);
                 } catch (IOException e) {
                     intlogger.warn("ProxyServlet: " + e);
-                    resp.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE);
-                    e.printStackTrace();
+                    sendResponseError(resp, HttpServletResponse.SC_SERVICE_UNAVAILABLE, "", intlogger);
                 } finally {
                     proxy.releaseConnection();
                     httpclient.getConnectionManager().shutdown();
             }
         } else {
             intlogger.warn("ProxyServlet: proxy disabled");
-            resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+            sendResponseError(resp, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, DB_PROBLEM_MSG, intlogger);
         }
     }
 
         }
     }
 
+    private void copyEntityContent(HttpResponse pxyResponse, HttpServletResponse resp) {
+        HttpEntity entity = pxyResponse.getEntity();
+        if (entity != null) {
+            try (InputStream in = entity.getContent()) {
+                IOUtils.copy(in, resp.getOutputStream());
+            } catch (Exception e) {
+                intlogger.error("Exception: " + e.getMessage());
+            }
+        }
+    }
+
     public class ProxyHttpRequest extends HttpEntityEnclosingRequestBase {
 
         private final String method;
 
             return;\r
         }\r
         if (isProxyOK(req) && isProxyServer()) {\r
-            try {\r
-                super.doDelete(req, resp);\r
-            } catch (IOException ioe) {\r
-                eventlogger.error("IOException" + ioe.getMessage());\r
-            }\r
+            super.doDelete(req, resp);\r
             return;\r
         }\r
 \r
             return;\r
         }\r
         if (isProxyOK(req) && isProxyServer()) {\r
-            try {\r
-                super.doGet(req, resp);\r
-            } catch (IOException ioe) {\r
-                eventlogger.error("IOException" + ioe.getMessage());\r
-            }\r
+            super.doGet(req, resp);\r
             return;\r
         }\r
 \r
             return;\r
         }\r
         if (isProxyOK(req) && isProxyServer()) {\r
-            try {\r
-                super.doPost(req, resp);\r
-            } catch (IOException ioe) {\r
-                intlogger.error("IOException" + ioe.getMessage());\r
-            }\r
+            super.doPost(req, resp);\r
             return;\r
         }\r
         String path = req.getPathInfo();\r
 
             return;
         }
         if (isProxyServer()) {
-            try {
-                super.doGet(req, resp);
-            } catch (IOException ioe) {
-                eventlogger.error("IOException: " + ioe.getMessage());
-            }
+            super.doGet(req, resp);
             return;
         }
         String bhdr = req.getHeader(BEHALF_HEADER);
      * section in the <b>Provisioning API</b> document for details on how this method should be invoked.
      */
     @Override
-    public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+    public void doPost(HttpServletRequest req, HttpServletResponse resp) {
         setIpAndFqdnForEelf("doPost");
         eelflogger.info(EelfMsgs.MESSAGE_WITH_BEHALF, req.getHeader(BEHALF_HEADER));
         EventLogRecord elr = new EventLogRecord(req);
             return;
         }
         if (isProxyServer()) {
-            try {
-                super.doPost(req, resp);
-            } catch (IOException ioe) {
-                eventlogger.error("IOException: " + ioe.getMessage());
-            }
+            super.doPost(req, resp);
             return;
         }
         String bhdr = req.getHeader(BEHALF_HEADER);
 
             return;\r
         }\r
         if (isProxyServer()) {\r
-            try {\r
-                super.doDelete(req, resp);\r
-            } catch (IOException ioe) {\r
-                eventlogger.error("IOException: " + ioe.getMessage());\r
-            }\r
+            super.doDelete(req, resp);\r
             return;\r
         }\r
         String bhdr = req.getHeader(BEHALF_HEADER);\r
             return;\r
         }\r
         if (isProxyServer()) {\r
-            try {\r
-                super.doGet(req, resp);\r
-            } catch (IOException ioe) {\r
-                eventlogger.error("IOException: " + ioe.getMessage());\r
-            }\r
+            super.doGet(req, resp);\r
             return;\r
         }\r
         String bhdr = req.getHeader(BEHALF_HEADER);\r
             return;\r
         }\r
         if (isProxyServer()) {\r
-            try {\r
-                super.doPut(req, resp);\r
-            } catch (IOException ioe) {\r
-                eventlogger.error("IOException: " + ioe.getMessage());\r
-            }\r
+            super.doPut(req, resp);\r
             return;\r
         }\r
         String bhdr = req.getHeader(BEHALF_HEADER);\r
             return;\r
         }\r
         if (isProxyServer()) {\r
-            try {\r
-                super.doPost(req, resp);\r
-            } catch (IOException ioe) {\r
-                eventlogger.error("IOException: " + ioe.getMessage());\r
-            }\r
+            super.doPost(req, resp);\r
             return;\r
         }\r
         String bhdr = req.getHeader(BEHALF_HEADER);\r
 
             Properties props = (new DB()).getProperties();
             String type = props.getProperty(Main.KEYSTORE_TYPE_PROPERTY, "jks");
             String store = props.getProperty(Main.KEYSTORE_PATH_PROPERTY);
-            String pass = props.getProperty(Main.KEYSTORE_PASSWORD_PROPERTY);
+            String pass = props.getProperty(Main.KEYSTORE_PASS_PROPERTY);
             KeyStore keyStore = KeyStore.getInstance(type);
             try(FileInputStream instream = new FileInputStream(new File(store))) {
                 keyStore.load(instream, pass.toCharArray());
 
             }
                 store = props.getProperty(Main.TRUSTSTORE_PATH_PROPERTY);
-                pass = props.getProperty(Main.TRUSTSTORE_PASSWORD_PROPERTY);
+                pass = props.getProperty(Main.TRUSTSTORE_PASS_PROPERTY);
                 KeyStore trustStore = null;
                 if (store != null && store.length() > 0) {
                     trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
             // We are connecting with the node name, but the certificate will have the CNAME
             // So we need to accept a non-matching certificate name
             String keystorepass = props.getProperty(
-                Main.KEYSTORE_PASSWORD_PROPERTY); //itrack.web.att.com/browse/DATARTR-6 for changing hard coded passphase ref
+                Main.KEYSTORE_PASS_PROPERTY); //itrack.web.att.com/browse/DATARTR-6 for changing hard coded passphase ref
            try(AbstractHttpClient hc = new DefaultHttpClient()) {
                SSLSocketFactory socketFactory =
                        (trustStore == null)
             }
         } catch (Exception e) {
             logger.warn("PROV0020: Caught exception in SynchronizerTask: " + e);
-            e.printStackTrace();
         }
     }
 
      * Synchronize the Feeds in the JSONArray, with the Feeds in the DB.
      */
     private void syncFeeds(JSONArray ja) {
-        Collection<Syncable> coll = new ArrayList<Syncable>();
+        Collection<Syncable> coll = new ArrayList<>();
         for (int n = 0; n < ja.length(); n++) {
             try {
                 Feed f = new Feed(ja.getJSONObject(n));
      * Synchronize the Subscriptions in the JSONArray, with the Subscriptions in the DB.
      */
     private void syncSubs(JSONArray ja) {
-        Collection<Syncable> coll = new ArrayList<Syncable>();
+        Collection<Syncable> coll = new ArrayList<>();
         for (int n = 0; n < ja.length(); n++) {
             try {
                 //Data Router Subscriber HTTPS Relaxation feature USERSTORYID:US674047.
      * Rally:US708115  - Synchronize the Groups in the JSONArray, with the Groups in the DB.
      */
     private void syncGroups(JSONArray ja) {
-        Collection<Syncable> coll = new ArrayList<Syncable>();
+        Collection<Syncable> coll = new ArrayList<>();
         for (int n = 0; n < ja.length(); n++) {
             try {
                 Group g = new Group(ja.getJSONObject(n));
      * Synchronize the Parameters in the JSONObject, with the Parameters in the DB.
      */
     private void syncParams(JSONObject jo) {
-        Collection<Syncable> coll = new ArrayList<Syncable>();
+        Collection<Syncable> coll = new ArrayList<>();
         for (String k : jo.keySet()) {
             String v = "";
             try {
     }
 
     private void syncIngressRoutes(JSONArray ja) {
-        Collection<Syncable> coll = new ArrayList<Syncable>();
+        Collection<Syncable> coll = new ArrayList<>();
         for (int n = 0; n < ja.length(); n++) {
             try {
                 IngressRoute in = new IngressRoute(ja.getJSONObject(n));
     }
 
     private void syncEgressRoutes(JSONObject jo) {
-        Collection<Syncable> coll = new ArrayList<Syncable>();
+        Collection<Syncable> coll = new ArrayList<>();
         for (String key : jo.keySet()) {
             try {
                 int sub = Integer.parseInt(key);
     }
 
     private void syncNetworkRoutes(JSONArray ja) {
-        Collection<Syncable> coll = new ArrayList<Syncable>();
+        Collection<Syncable> coll = new ArrayList<>();
         for (int n = 0; n < ja.length(); n++) {
             try {
                 NetworkRoute nr = new NetworkRoute(ja.getJSONObject(n));
         try {
             Map<String, Syncable> newmap = getMap(newc);
             Map<String, Syncable> oldmap = getMap(oldc);
-            Set<String> union = new TreeSet<String>(newmap.keySet());
+            Set<String> union = new TreeSet<>(newmap.keySet());
             union.addAll(oldmap.keySet());
             DB db = new DB();
             @SuppressWarnings("resource")
             db.release(conn);
         } catch (SQLException e) {
             logger.warn("PROV5009: problem during sync, exception: " + e);
-            e.printStackTrace();
         }
         return changes;
     }
 
     private Map<String, Syncable> getMap(Collection<? extends Syncable> c) {
-        Map<String, Syncable> map = new HashMap<String, Syncable>();
+        Map<String, Syncable> map = new HashMap<>();
         for (Syncable v : c) {
             map.put(v.getKey(), v);
         }