package org.onap.dmaap.datarouter.provisioning;
+import static org.onap.dmaap.datarouter.provisioning.utils.HttpServletUtils.sendResponseError;
+
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.security.KeyStoreException;
import java.util.Collections;
import java.util.List;
-import java.util.Properties;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import org.apache.http.entity.BasicHttpEntity;
import org.apache.http.impl.client.AbstractHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
-import org.onap.dmaap.datarouter.provisioning.utils.DB;
+import org.onap.dmaap.datarouter.provisioning.utils.AafPropsUtils;
+import org.onap.dmaap.datarouter.provisioning.utils.SynchronizerTask;
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
* @version $Id: ProxyServlet.java,v 1.3 2014/03/24 18:47:10 eby Exp $
*/
@SuppressWarnings("serial")
+
public class ProxyServlet extends BaseServlet {
private boolean inited = false;
super.init(config);
try {
// Set up keystore
- 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_PASS_PROPERTY);
+ String type = AafPropsUtils.KEYSTORE_TYPE_PROPERTY;
+ String store = ProvRunner.getAafPropsUtils().getKeystorePathProperty();
+ String pass = ProvRunner.getAafPropsUtils().getKeystorePassProperty();
KeyStore keyStore = readStore(store, pass, type);
-
- store = props.getProperty(Main.TRUSTSTORE_PATH_PROPERTY);
- pass = props.getProperty(Main.TRUSTSTORE_PASS_PROPERTY);
+ // Set up truststore
+ store = ProvRunner.getAafPropsUtils().getTruststorePathProperty();
+ pass = ProvRunner.getAafPropsUtils().getTruststorePassProperty();
if (store == null || store.length() == 0) {
- store = Main.DEFAULT_TRUSTSTORE;
+ store = AafPropsUtils.DEFAULT_TRUSTSTORE;
pass = "changeit";
}
- KeyStore trustStore = readStore(store, pass, KeyStore.getDefaultType());
+ KeyStore trustStore = readStore(store, pass, AafPropsUtils.TRUESTSTORE_TYPE_PROPERTY);
// 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_PASS_PROPERTY), trustStore);
+ ProvRunner.getAafPropsUtils().getKeystorePassProperty(), trustStore);
socketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
sch = new Scheme("https", 443, socketFactory);
inited = true;
} catch (Exception e) {
- intlogger.error("ProxyServlet: " + e.getMessage());
+ intlogger.error("ProxyServlet.init: " + e.getMessage(), e);
}
intlogger.info("ProxyServlet: inited = " + inited);
}
try (FileInputStream instream = new FileInputStream(new File(store))) {
ks.load(instream, pass.toCharArray());
} catch (FileNotFoundException fileNotFoundException) {
- intlogger.error("ProxyServlet: " + fileNotFoundException.getMessage());
+ intlogger.error("ProxyServlet.readStore: " + fileNotFoundException.getMessage(), fileNotFoundException);
} catch (Exception x) {
intlogger.error("READING TRUSTSTORE: " + x);
}
* @param req the HTTP request
* @return true or false
*/
- protected boolean isProxyOK(final HttpServletRequest req) {
- String t = req.getQueryString();
- if (t != null) {
- t = t.replaceAll("&", "&");
- for (String s : t.split("&")) {
- if (s.equals("noproxy") || s.startsWith("noproxy=")) {
+ boolean isProxyOK(final HttpServletRequest req) {
+ String str = req.getQueryString();
+ if (str != null) {
+ str = str.replaceAll("&", "&");
+ for (String s : str.split("&")) {
+ if ("noproxy".equals(s) || s.startsWith("noproxy=")) {
return false;
}
}
*
* @return true if this server is the standby (and hence a proxy server).
*/
- public boolean isProxyServer() {
+ boolean isProxyServer() {
SynchronizerTask st = SynchronizerTask.getSynchronizer();
- return st.getState() == SynchronizerTask.STANDBY;
+ return st.getPodState() == SynchronizerTask.STANDBY_POD;
}
/**
*
* @return true if the proxy succeeded
*/
- public boolean doGetWithFallback(HttpServletRequest req, HttpServletResponse resp) {
+ boolean doGetWithFallback(HttpServletRequest req, HttpServletResponse resp) {
boolean rv = false;
if (inited) {
String url = buildUrl(req);
rv = true;
} catch (IOException e) {
- intlogger.error("ProxyServlet: " + e.getMessage());
+ intlogger.error("ProxyServlet.doGetWithFallback: " + e.getMessage(), e);
} finally {
proxy.releaseConnection();
httpclient.getConnectionManager().shutdown();
// Copy request headers and request body
copyRequestHeaders(req, proxy);
- if (method.equals("POST") || method.equals("PUT")) {
- BasicHttpEntity body = new BasicHttpEntity();
- body.setContent(req.getInputStream());
- body.setContentLength(-1); // -1 = unknown
- proxy.setEntity(body);
- }
+
+ handlePutOrPost(req, method, proxy);
// Execute the request
HttpResponse pxyResponse = httpclient.execute(proxy);
copyResponseHeaders(pxyResponse, resp);
copyEntityContent(pxyResponse, resp);
} catch (IOException e) {
- intlogger.warn("ProxyServlet: " + e.getMessage());
+ intlogger.warn("ProxyServlet.doProxy: " + e.getMessage(), e);
sendResponseError(resp, HttpServletResponse.SC_SERVICE_UNAVAILABLE, "", intlogger);
} finally {
proxy.releaseConnection();
}
}
+ private void handlePutOrPost(HttpServletRequest req, String method, ProxyHttpRequest proxy) throws IOException {
+ if ("POST".equals(method) || "PUT".equals(method)) {
+ BasicHttpEntity body = new BasicHttpEntity();
+ body.setContent(req.getInputStream());
+ body.setContentLength(-1); // -1 = unknown
+ proxy.setEntity(body);
+ }
+ }
+
private String buildUrl(HttpServletRequest req) {
StringBuilder sb = new StringBuilder("https://");
sb.append(URLUtilities.getPeerPodName());
sb.append(req.getRequestURI());
- String q = req.getQueryString();
- if (q != null) {
- sb.append("?").append(q);
+ String query = req.getQueryString();
+ if (query != null) {
+ sb.append("?").append(query);
}
return sb.toString();
}
private void copyRequestHeaders(HttpServletRequest from, HttpRequestBase to) {
- @SuppressWarnings("unchecked")
List<String> list = Collections.list(from.getHeaderNames());
for (String name : list) {
// Proxy code will add this one
- if (!name.equalsIgnoreCase("Content-Length")) {
+ if (!"Content-Length".equalsIgnoreCase(name)) {
to.addHeader(name, from.getHeader(name));
}
}
}
- private void copyResponseHeaders(HttpResponse from, HttpServletResponse to) {
+ void copyResponseHeaders(HttpResponse from, HttpServletResponse to) {
for (Header hdr : from.getAllHeaders()) {
// Don't copy Date: our Jetty will add another Date header
- if (!hdr.getName().equals("Date")) {
+ if (!"Date".equals(hdr.getName())) {
to.addHeader(hdr.getName(), hdr.getValue());
}
}
}
- private void copyEntityContent(HttpResponse pxyResponse, HttpServletResponse resp) {
+ 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());
+ intlogger.error("ProxyServlet.copyEntityContent: " + e.getMessage(), e);
}
}
}
- public class ProxyHttpRequest extends HttpEntityEnclosingRequestBase {
+ public static class ProxyHttpRequest extends HttpEntityEnclosingRequestBase {
private final String method;
- public ProxyHttpRequest(final String method, final String uri) {
+ ProxyHttpRequest(final String method, final String uri) {
super();
this.method = method;
setURI(URI.create(uri));
Code Review / dmaap / datarouter.git / blobdiff