flex.messaging.FlexContext Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
package flex.messaging;
import flex.messaging.client.FlexClient;
import flex.messaging.endpoints.Endpoint;
import flex.messaging.io.TypeMarshallingContext;
import flex.messaging.security.LoginManager;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.security.Principal;
/**
* The FlexContext is a utility class that exposes the current execution context.
* It provides access to FlexSession and FlexClient instances associated
* with the current message being processed, as well as global context via the MessageBroker,
* ServletContext and ServletConfig for the application.
* Any, or all, of the properties exposed by this class may be null depending upon
* the current execution context so test for that before attempting to interact with them.
*/
public class FlexContext
{
private static ThreadLocal flexClients = new ThreadLocal();
private static ThreadLocal sessions = new ThreadLocal();
private static ThreadLocal messageBrokers = new ThreadLocal();
private static ThreadLocal endpoints = new ThreadLocal();
private static ThreadLocal responses = new ThreadLocal();
private static ThreadLocal requests = new ThreadLocal();
private static ThreadLocal tunnelRequests = new ThreadLocal();
private static ThreadLocal servletConfigs = new ThreadLocal();
private static ThreadLocal messageFromPeer = new ThreadLocal();
private static ThreadLocal messageRoutedNotifiers = new ThreadLocal();
private static ServletConfig lastGoodServletConfig;
private FlexContext()
{
}
/**
* Users should not call this.
*
* @param flexClient the Flex client
* @param session the Flex session
* @param broker the message broker
* @param request the http servlet request
* @param response the http servlet response
* @param servletConfig the servlet config
*/
public static void setThreadLocalObjects(FlexClient flexClient,
FlexSession session,
MessageBroker broker,
HttpServletRequest request,
HttpServletResponse response,
ServletConfig servletConfig)
{
if (flexClients == null) // In case releaseThreadLocalObjects has been called.
return;
flexClients.set(flexClient);
sessions.set(session);
messageBrokers.set(broker);
requests.set(request);
responses.set(response);
setThreadLocalServletConfig(servletConfig);
messageFromPeer.set(Boolean.FALSE);
}
/**
* Users should not call this.
*
* @param flexClient the Flex client
* @param session the Flex session
* @param broker the message broker
*/
public static void setThreadLocalObjects(FlexClient flexClient, FlexSession session, MessageBroker broker)
{
setThreadLocalObjects(flexClient, session, broker, null, null, null);
}
/**
* Users should not call this.
*
*/
public static void clearThreadLocalObjects()
{
if (flexClients == null) // In case releaseThreadLocalObjects has been called.
return;
flexClients.remove();
sessions.remove();
messageBrokers.remove();
endpoints.remove();
requests.remove();
responses.remove();
tunnelRequests.remove();
servletConfigs.remove();
messageFromPeer.remove();
messageRoutedNotifiers.remove();
TypeMarshallingContext.clearThreadLocalObjects();
}
/**
* The HttpServletResponse for the current request if the request is via HTTP.
* Returns null if the client is using a non-HTTP channel.
* Available for users.
*
* @return HttpServletRequest current HttpServletRequest object
*/
public static HttpServletRequest getHttpRequest()
{
return requests != null? requests.get() : null;
}
/**
* Users should not call this.
*
* @param value HttpServletRequest object
*/
public static void setThreadLocalHttpRequest(HttpServletRequest value)
{
if (requests == null)
return;
if (value == null)
requests.remove();
else
requests.set(value);
}
/**
* The HttpServletResponse for the current request if the request is via HTTP.
* Returns null if the using an non-HTTP channel.
* Available for users.
*
* @return HttpServletResponse current HttpServletResponse object
*/
public static HttpServletResponse getHttpResponse()
{
return responses != null? responses.get() : null;
}
/**
* Users should not call this.
*
* @param value HttpServletResponse object
*/
public static void setThreadLocalHttpResponse(HttpServletResponse value)
{
if (responses == null)
return;
if (value == null)
responses.remove();
else
responses.set(value);
}
/**
* The HttpServletRequest for the current request if it is transporting a tunneled protocol.
* Returns null if the current request protocol it not tunneled.
* Available for users.
*
* @return HttpServletRequest tunnel HttpServletRequest object
*/
public static HttpServletRequest getTunnelHttpRequest()
{
return tunnelRequests != null? tunnelRequests.get() : null;
}
/**
* Users should not call this.
*
* @param value HttpServletRequest object
*/
public static void setThreadLocalTunnelHttpRequest(HttpServletRequest value)
{
if (tunnelRequests == null)
return;
if (value == null)
tunnelRequests.remove();
else
tunnelRequests.set(value);
}
/**
* The ServletConfig for the current request, uses the last known ServletConfig
* when the request is not via HTTP. Available for users.
*
* @return ServletConfig current ServletConfig object
*/
public static ServletConfig getServletConfig()
{
if (servletConfigs != null && servletConfigs.get() != null)
{
return servletConfigs.get();
}
return lastGoodServletConfig;
}
/**
* Users should not call this.
*
* @param value ServletConfig object
*/
public static void setThreadLocalServletConfig(ServletConfig value)
{
if (servletConfigs == null)
return;
if (value == null)
{
servletConfigs.remove();
}
else
{
servletConfigs.set(value);
lastGoodServletConfig = value;
}
}
/**
* The ServletContext for the current web application.
*
* @return ServletContext current ServletContext object
*/
public static ServletContext getServletContext()
{
return getServletConfig() != null? getServletConfig().getServletContext() : null;
}
/**
* The FlexClient for the current request. Available for users.
*
* @return FlexClient the current FlexClient object
*/
public static FlexClient getFlexClient()
{
return flexClients != null? flexClients.get() : null;
}
/**
* Users should not call this.
*
* @param flexClient FlexClient object
*/
public static void setThreadLocalFlexClient(FlexClient flexClient)
{
if (flexClients == null)
return;
if (flexClient == null)
flexClients.remove();
else
flexClients.set(flexClient);
}
/**
* The FlexSession for the current request. Available for users.
*
* @return FlexSession the current FlexSession object
*/
public static FlexSession getFlexSession()
{
return sessions != null? sessions.get() : null;
}
/**
* Users should not call this.
*
* @param session FlexSession object
*/
public static void setThreadLocalSession(FlexSession session)
{
if (sessions == null)
return;
if (session == null)
sessions.remove();
else
sessions.set(session);
}
/**
* The MessageBroker for the current request. Not available for users.
*
* @return The MessageBroker for the current request
*/
public static MessageBroker getMessageBroker()
{
return messageBrokers != null? messageBrokers.get() : null;
}
/**
* Users should not call this.
*
* @param value MessageBroker object
*/
public static void setThreadLocalMessageBroker(MessageBroker value)
{
// This is a special case because MessageBroker is sometimes accessed by
// services, destinations, adapters during shutdown so it needs to be set
// on the context even if a previous MessageBrokerServlet#destroy called
// releaseThreadLocalObjects.
if (messageBrokers == null)
messageBrokers = new ThreadLocal();
if (value == null)
messageBrokers.remove();
else
messageBrokers.set(value);
}
/**
* The Endpoint for the current message. Not available for users.
*
* @return The Endpoint for the current message
*/
public static Endpoint getEndpoint()
{
return endpoints != null? endpoints.get() : null;
}
/**
* Users should not call this.
*
* @param value Endpoint object
*/
public static void setThreadLocalEndpoint(Endpoint value)
{
if (endpoints == null)
return;
if (value == null)
endpoints.remove();
else
endpoints.set(value);
}
/**
* Users should not call this.
*
* @return MessageRoutedNotifier object
*/
public static MessageRoutedNotifier getMessageRoutedNotifier()
{
return messageRoutedNotifiers != null? messageRoutedNotifiers.get() : null;
}
/**
* Users should not call this.
*
* @param value MessageRoutedNotifier object
*/
public static void setMessageRoutedNotifier(MessageRoutedNotifier value)
{
if (messageRoutedNotifiers == null)
return;
if (value == null)
messageRoutedNotifiers.remove();
else
messageRoutedNotifiers.set(value);
}
/**
* Indicates whether the current message being processed came from a server peer
* in a cluster.
*
* @return true if message from a peer
*/
public static boolean isMessageFromPeer()
{
return messageFromPeer != null? messageFromPeer.get() : false;
}
/**
* Sets a thread local indicating whether the message being processed came from
* a server peer in a cluster.
*
* @param value True if the message came from a peer; otherwise false.
*/
public static void setMessageFromPeer(boolean value)
{
if (messageFromPeer == null)
return;
messageFromPeer.set(value);
}
/**
* Users should not call this.
*
* @return true if per-client-authentication is turned on.
*/
public static boolean isPerClientAuthentication()
{
MessageBroker messageBroker = getMessageBroker();
if (messageBroker == null)
return false;
LoginManager loginManager = messageBroker.getLoginManager();
return loginManager == null? false : loginManager.isPerClientAuthentication();
}
/**
* Returns the principal associated with the session or client depending on whether
* perClientauthentication is being used. If the client has not
* authenticated the principal will be null.
*
* @return The principal associated with the session.
*/
public static Principal getUserPrincipal()
{
if (isPerClientAuthentication())
{
FlexClient client = getFlexClient();
return client != null? client.getUserPrincipal() : null;
}
FlexSession session = getFlexSession();
return session != null? session.getUserPrincipal() : null;
}
/**
* Sets the Principal on either the current FlexClient or FlexSession depending upon whether
* perClientAuthentication is in use.
*
* @param userPrincipal The principal to associate with the FlexClient or FlexSession
* depending upon whether perClientAuthentication is in use.
*/
public static void setUserPrincipal(Principal userPrincipal)
{
if (isPerClientAuthentication())
getFlexClient().setUserPrincipal(userPrincipal);
else
getFlexSession().setUserPrincipal(userPrincipal);
}
/**
* Create the static thread local storage.
*/
public static void createThreadLocalObjects()
{
if (flexClients == null) // Allocate if needed.
{
flexClients = new ThreadLocal();
sessions = new ThreadLocal();
messageBrokers = new ThreadLocal();
endpoints = new ThreadLocal();
responses = new ThreadLocal();
requests = new ThreadLocal();
tunnelRequests = new ThreadLocal();
servletConfigs = new ThreadLocal();
messageFromPeer = new ThreadLocal();
messageRoutedNotifiers = new ThreadLocal();
}
}
/**
* Destroy the static thread local storage.
* Call ONLY on shutdown
*/
public static void releaseThreadLocalObjects()
{
clearThreadLocalObjects();
flexClients = null;
sessions = null;
messageBrokers = null;
endpoints = null;
responses = null;
requests = null;
tunnelRequests = null;
servletConfigs = null;
messageFromPeer = null;
messageRoutedNotifiers = null;
}
}