
com.att.aft.dme2.api.DME2ServiceHolder Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of dme2-api Show documentation
Show all versions of dme2-api Show documentation
Direct Messaging Engine dme2-api
The newest version!
/*******************************************************************************
* Copyright (c) 2016 AT&T Intellectual Property. All rights reserved.
*******************************************************************************/
package com.att.aft.dme2.api;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.NameCallback;
import javax.security.auth.callback.PasswordCallback;
import javax.security.auth.callback.TextOutputCallback;
import javax.security.auth.callback.UnsupportedCallbackException;
import javax.security.auth.login.LoginContext;
import javax.security.auth.login.LoginException;
import javax.servlet.DispatcherType;
import javax.servlet.Servlet;
import javax.servlet.ServletContextListener;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang.exception.ExceptionUtils;
import org.eclipse.jetty.jaas.JAASLoginService;
import org.eclipse.jetty.jaas.callback.ObjectCallback;
import org.eclipse.jetty.jaas.callback.RequestParameterCallback;
import org.eclipse.jetty.security.ConstraintMapping;
import org.eclipse.jetty.security.ConstraintSecurityHandler;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.handler.gzip.GzipHandler;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import org.eclipse.jetty.servlets.GzipFilter;
import org.eclipse.jetty.util.security.Constraint;
import org.eclipse.jetty.websocket.core.api.WebSocketListener;
import org.eclipse.jetty.websocket.server.WebSocketHandler;
import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;
import com.att.aft.dme2.api.util.DME2FilterHolder;
import com.att.aft.dme2.api.util.DME2FilterHolder.RequestDispatcherType;
import com.att.aft.dme2.api.util.DME2ServletHolder;
import com.att.aft.dme2.api.util.DME2ThrottleFilter;
import com.att.aft.dme2.config.DME2Configuration;
import com.att.aft.dme2.logging.LogMessage;
import com.att.aft.dme2.logging.Logger;
import com.att.aft.dme2.logging.LoggerFactory;
import com.att.aft.dme2.server.api.websocket.DME2ServerWebSocket;
import com.att.aft.dme2.server.api.websocket.DME2ServerWebSocketHandler;
import com.att.aft.dme2.server.api.websocket.GRMHealthCheckServerWebSocket;
import com.att.aft.dme2.util.DME2Constants;
import com.att.aft.dme2.util.DME2ExceptionHandler;
import com.att.aft.dme2.util.ErrorContext;
/**
* The DME2ServiceHolder represents a SERVICE in the DME2-sense and the related artifacts required to start and publish that
* service.
*/
@SuppressWarnings("deprecation")
public class DME2ServiceHolder
{
private String context;
private String serviceURI;
private String realm;
private String loginMethod;
private String[] allowedRoles;
private Properties contextParams;
private DME2Server server;
private DME2Manager manager;
private Servlet servlet;
private final boolean active = false;
private DME2Configuration config;
private boolean metricsFilterDisabled; // = config.getBoolean(DME2Constants.AFT_DME2_DISABLE_METRICS_FILTER);
private List serviceAliases;
private List filters;
private List servletHolders;
private List contextListeners;
private GzipHandler gzipHandler=null;
private static Object serverLock = new Object();
private static final Logger logger = LoggerFactory.getLogger( DME2ServiceHolder.class );
private static final String SECURITY_REALM="securityRealm";
private static final String SERVLET="servlet";
private static final String SERVICE= "service";
private static final String TEST ="test";
private DME2ServerWebSocketHandler dme2WebSocketHandler;
private Float throttlePctPerPartner;
private Boolean throttleFilterDisabled;
private Properties serviceProperties;
public Properties getServiceProperties() {
return serviceProperties;
}
public void setServiceProperties(Properties props) {
this.serviceProperties= props;
}
public DME2ServerWebSocketHandler getDme2WebSocketHandler() {
return dme2WebSocketHandler;
}
public void setDme2WebSocketHandler( DME2ServerWebSocketHandler dme2WebSocketHandler ) {
this.dme2WebSocketHandler = dme2WebSocketHandler;
}
public DME2ServiceHolder()
{
}
public void setManager(DME2Manager manager)
{
this.manager = manager;
this.config = manager.getConfig();
this.serviceProperties = manager.getServiceProperties();
metricsFilterDisabled = config.getBoolean(DME2Constants.AFT_DME2_DISABLE_METRICS_FILTER);
}
public DME2Manager getManager()
{
return this.manager;
}
public void setServlet(Servlet servlet)
{
this.servlet = servlet;
}
public Servlet getServlet()
{
return servlet;
}
public void setServiceURI(String serviceURI)
{
this.serviceURI = serviceURI;
}
public void setServiceAliases(List serviceAliases)
{
this.serviceAliases = serviceAliases;
}
public List getServiceAliases()
{
return this.serviceAliases;
}
public String getServiceURI()
{
return this.serviceURI;
}
public void setContext(String context)
{
this.context = context;
}
public String getContext()
{
return context;
}
public void setSecurityRealm(String realm)
{
this.realm = realm;
}
public String getSecurityRealm()
{
return realm;
}
public void setAllowedRoles(String[] newAllowedRoles)
{
if(newAllowedRoles == null) {
this.allowedRoles = null;
} else {
this.allowedRoles = Arrays.copyOf(newAllowedRoles, newAllowedRoles.length);
}
}
public String[] getAllowedRoles()
{
return this.allowedRoles;
}
public void setLoginMethod(String loginMethod)
{
this.loginMethod = loginMethod;
}
public String getLoginMethod()
{
return loginMethod;
}
public void setFilters(List filterBeans)
{
this.filters = filterBeans;
}
public List getFilters()
{
return this.filters;
}
public void setServletHolders(List servlets)
{
this.servletHolders = servlets;
}
public List getServletHolders()
{
return this.servletHolders;
}
public void setContextListeners(List contextListeners)
{
this.contextListeners = contextListeners;
}
public List getContextListeners()
{
return this.contextListeners;
}
public boolean isActive()
{
return active;
}
public DME2Server getServer()
{
return server;
}
public void setServer(DME2Server server)
{
this.server = server;
}
public boolean isMetricsFilterEnabled()
{
return !metricsFilterDisabled;
}
public void enableMetricsFilter()
{
this.metricsFilterDisabled = false;
}
public void disableMetricsFilter()
{
this.metricsFilterDisabled = true;
}
public Properties getContextParams()
{
return contextParams;
}
public void setContextParams(Properties contextParams)
{
this.contextParams = contextParams;
}
public Float getThrottlePctPerPartner() {
return throttlePctPerPartner;
}
public void setThrottlePctPerPartner(Float throttlePctPerPartner) {
this.throttlePctPerPartner = throttlePctPerPartner;
}
public Boolean getThrottleFilterDisabled() {
return throttleFilterDisabled;
}
public void setThrottleFilterDisabled(Boolean throttleFilterDisabled) {
this.throttleFilterDisabled = throttleFilterDisabled;
}
private WebSocketHandler createWebSocketHandler(final DME2ServerWebSocketHandler webSocketHandler, final DME2Manager dme2Manager) throws DME2Exception{
WebSocketHandler websocketHandler = new WebSocketHandler() {
public WebSocketListener doWebSocketConnect(HttpServletRequest request,
String protocol) {
WebSocketListener webSocket=null;
String trackingId=request.getParameter("dme2_tracking_id");
if (trackingId==null){
trackingId=getTrackingId();
}
try {
Cookie[] cookies = request.getCookies();
boolean isHealthCheck=false;
for (Cookie cookie : cookies) {
if("healthcheck".equals(cookie.getName())){
if ("healthcheck".equals(cookie.getValue())){
isHealthCheck=true;
}else {
ErrorContext ec = new ErrorContext();
ec.add("Code", "DME2Server.Fault");
throw new DME2Exception("AFT-DME2-6712",ec);
}
break;
}
}
if (isHealthCheck){
webSocket=new GRMHealthCheckServerWebSocket();
}else{
webSocket = new DME2ServerWebSocket(webSocketHandler,dme2Manager,trackingId);
}
}catch (Exception e) {
ErrorContext ec = new ErrorContext();
ec.add("Code", "DME2Server.Fault");
ec.add("extendedMessage", e.getMessage());
ec.add("StackTrace", ExceptionUtils.getStackTrace(e));
logger.info( null, "createWebSocketHandler", LogMessage.WS_SERVER_WEBSOCKET_HEALTHCHECK_EXCEPTION, ec);
}
return webSocket;
}
@Override
public void configure(WebSocketServletFactory factory) {
// TODO Auto-generated method stub
}
};
return websocketHandler;
}
private static String getTrackingId() {
return "WS_SERVER_ID_" + UUID.randomUUID().toString() ;
}
@SuppressWarnings("unchecked")
public void start() throws DME2Exception
{
try
{
/*Check if server is started*/
if (server == null)
{
throw new DME2Exception("AFT-DME2-0013", new ErrorContext().add(SERVICE, serviceURI)
.add(SERVLET, "" + servlet).add(SECURITY_REALM, realm));
}
if (!server.isRunning())
{
throw new DME2Exception("AFT-DME2-0014", new ErrorContext().add(SERVICE, serviceURI)
.add(SERVLET, "" + servlet).add(SECURITY_REALM, realm));
}
if (this.getDme2WebSocketHandler()!=null){
WebSocketHandler websocketHandler = createWebSocketHandler(this.getDme2WebSocketHandler(),this.getManager());
ContextHandler context = new ContextHandler();
String contextPath=getContext();
if(contextPath==null){
context.setContextPath("/");
//contextPath="/";
}else {
context.setContextPath(contextPath);
}
context.setHandler(websocketHandler);
synchronized (this.serverLock)
{
server.addHandler(context);
try
{
context.start();
}
catch (Exception e)
{
throw new DME2Exception("AFT-DME2-6714", new ErrorContext().add(SERVICE, serviceURI).add("WEBSOCKET HANDLER", "" + websocketHandler));
}
}
// register endpoint
manager.publish(this);
return;
}
ServletContextHandler con = new ServletContextHandler();
con.setMaxFormContentSize(server.getServerProperties().getMaxRequestPostSize());
/*Check security configuration*/
if (realm != null){
checkForValidJAASConfiguration(con);
}
/* Setting context path */
if (this.getContext() != null){
con.setContextPath(getContext());
}
else {
con.setContextPath("/");
}
/* SCLD-2582 - Implementing ability to perform GZIP compression for DME2 calls based on payload size */
/*
* This is done per service. If "disableCompression" query param is present and is set to false in the service URI,
* compression will remain disabled
*/
logger.debug( null, "start", "config.getBoolean(DME2Constants.DME2_ENABLE_PAYLOAD_COMPRESSION_THRESH_KEY) : {}",
config.getBoolean(DME2Constants.DME2_ENABLE_PAYLOAD_COMPRESSION_THRESH_KEY));
if (config.getBoolean(DME2Constants.DME2_ENABLE_PAYLOAD_COMPRESSION_THRESH_KEY))
{
if (!disableCompressionForServiceOverride())
{
String serviceString = getServiceString();
if (!serviceString.startsWith("/")){
serviceString = "/" + serviceString;
}
// DME2FilterHolder holder = createGZIPFilter();
gzipHandler = createGZIPHandler(con, serviceString);
con.setGzipHandler(gzipHandler);
// con.addFilter(holder.getFilterHolder(), holder.getFilterPattern(), holder.getDispatcherType());
logger.info( null, "start", LogMessage.DEBUG_MESSAGE, "GZIP filter enabled for service: {}", getServiceString());
}
}
/*If Metrics Filter property is NOT disabled, add Metrics Filter to the Servlet Context Handler*/
if (!this.metricsFilterDisabled)
{
logger.debug( null, "start", LogMessage.ADD_METRICS_FILTER, serviceURI);
createMetricsFilter(con);
}
/* Throttle per service per partner */
addThrottleFilter(con);
// Add context parameters
Properties conParams = this.getContextParams();
if (conParams != null)
{
Enumeration
© 2015 - 2025 Weber Informatics LLC | Privacy Policy