/**
* @author Cameron INGRAM
* @author Venkat DANDA
*/
public class SeamServiceInvoker extends ServiceInvoker<SeamServiceFactory> {
private static final long serialVersionUID = 1L;
private static final Logger log = Logger.getLogger(SeamServiceInvoker.class);
public static final String CAPITALIZED_DESTINATION_ID = "{capitalized.destination.id}";
public static final String DESTINATION_ID = "{destination.id}";
public SeamServiceInvoker(Destination destination, SeamServiceFactory factory, Object instance)
throws ServiceException {
super(destination, factory);
this.invokee = instance;
}
@Override
protected void beforeInvocation(ServiceInvocationContext context) {
log.debug("Before Invocation");
}
@Override
protected Object afterInvocation(ServiceInvocationContext context, Object result) {
log.debug("After Invocation");
return result;
}
}
/**
* @author William DRAI
* @author Franck WOLFF
*/
public class DefaultGravity implements Gravity, DefaultGravityMBean {
///////////////////////////////////////////////////////////////////////////
// Fields.
private static final Logger log = Logger.getLogger(Gravity.class);
private final Map<String, Object> applicationMap = new HashMap<String, Object>();
private final ConcurrentHashMap<String, TimeChannel<?>> channels =
new ConcurrentHashMap<String, TimeChannel<?>>();
private GravityConfig gravityConfig = null;
private ServicesConfig servicesConfig = null;
private GraniteConfig graniteConfig = null;
private SharedContext sharedContext = null;
private Channel serverChannel = null;
private AdapterFactory adapterFactory = null;
private GravityPool gravityPool = null;
private UdpReceiverFactory udpReceiverFactory = null;
private Timer channelsTimer;
private boolean started;
///////////////////////////////////////////////////////////////////////////
// Constructor.
public DefaultGravity(
GravityConfig gravityConfig,
ServicesConfig servicesConfig,
GraniteConfig graniteConfig,
SharedContext sharedContext) {
if (gravityConfig == null || servicesConfig == null || graniteConfig == null)
throw new NullPointerException("All arguments must be non null.");
this.gravityConfig = gravityConfig;
this.servicesConfig = servicesConfig;
this.graniteConfig = graniteConfig;
this.sharedContext = sharedContext;
}
///////////////////////////////////////////////////////////////////////////
// Properties.
public GravityConfig getGravityConfig() {
return gravityConfig;
}
public ServicesConfig getServicesConfig() {
return servicesConfig;
}
public GraniteConfig getGraniteConfig() {
return graniteConfig;
}
public SharedContext getSharedContext() {
return sharedContext;
}
public boolean isStarted() {
return started;
}
public ServiceAdapter getServiceAdapter(String messageType, String destinationId) {
return adapterFactory.getServiceAdapter(messageType, destinationId);
}
///////////////////////////////////////////////////////////////////////////
// Starting/stopping.
public void start() throws Exception {
log.info("Starting Gravity...");
synchronized (this) {
if (!started) {
adapterFactory = new AdapterFactory(this);
internalStart();
serverChannel = new ServerChannel(this, ServerChannel.class.getName(), null, null);
if (gravityConfig.isUseUdp()) {
ServiceLoader<UdpReceiverFactory> loader = ServiceLoader.load(UdpReceiverFactory.class);
Iterator<UdpReceiverFactory> factories = loader.iterator();
if (factories.hasNext()) {
udpReceiverFactory = factories.next();
udpReceiverFactory.setPort(gravityConfig.getUdpPort());
udpReceiverFactory.setNio(gravityConfig.isUdpNio());
udpReceiverFactory.setConnected(gravityConfig.isUdpConnected());
udpReceiverFactory.setSendBufferSize(gravityConfig.getUdpSendBufferSize());
udpReceiverFactory.start();
} else log.warn("UDP receiver factory not found");
}
started = true;
}
}
log.info("Gravity successfully started.");
}
protected void internalStart() {
gravityPool = new GravityPool(gravityConfig);
channelsTimer = new Timer();
if (graniteConfig.isRegisterMBeans()) {
try {
ObjectName name =
new ObjectName(
"org.graniteds:type=Gravity,context=" + graniteConfig.getMBeanContextName());
log.info("Registering MBean: %s", name);
OpenMBean mBean = OpenMBean.createMBean(this);
MBeanServerLocator.getInstance().register(mBean, name, true);
} catch (Exception e) {
log.error(
e,
"Could not register Gravity MBean for context: %s",
graniteConfig.getMBeanContextName());
}
}
}
public void restart() throws Exception {
synchronized (this) {
stop();
start();
}
}
public void reconfigure(GravityConfig gravityConfig, GraniteConfig graniteConfig) {
this.gravityConfig = gravityConfig;
this.graniteConfig = graniteConfig;
if (gravityPool != null) gravityPool.reconfigure(gravityConfig);
}
public void stop() throws Exception {
stop(true);
}
public void stop(boolean now) throws Exception {
log.info("Stopping Gravity (now=%s)...", now);
synchronized (this) {
if (adapterFactory != null) {
try {
adapterFactory.stopAll();
} catch (Exception e) {
log.error(e, "Error while stopping adapter factory");
}
adapterFactory = null;
}
if (serverChannel != null) {
try {
removeChannel(serverChannel.getId(), false);
} catch (Exception e) {
log.error(e, "Error while removing server channel: %s", serverChannel);
}
serverChannel = null;
}
if (channelsTimer != null) {
try {
channelsTimer.cancel();
} catch (Exception e) {
log.error(e, "Error while cancelling channels timer");
}
channelsTimer = null;
}
if (gravityPool != null) {
try {
if (now) gravityPool.shutdownNow();
else gravityPool.shutdown();
} catch (Exception e) {
log.error(e, "Error while stopping thread pool");
}
gravityPool = null;
}
if (udpReceiverFactory != null) {
try {
udpReceiverFactory.stop();
} catch (Exception e) {
log.error(e, "Error while stopping udp receiver factory");
}
udpReceiverFactory = null;
}
started = false;
}
log.info("Gravity sucessfully stopped.");
}
///////////////////////////////////////////////////////////////////////////
// GravityMBean attributes implementation.
public String getGravityFactoryName() {
return gravityConfig.getGravityFactory();
}
public long getChannelIdleTimeoutMillis() {
return gravityConfig.getChannelIdleTimeoutMillis();
}
public void setChannelIdleTimeoutMillis(long channelIdleTimeoutMillis) {
gravityConfig.setChannelIdleTimeoutMillis(channelIdleTimeoutMillis);
}
public boolean isRetryOnError() {
return gravityConfig.isRetryOnError();
}
public void setRetryOnError(boolean retryOnError) {
gravityConfig.setRetryOnError(retryOnError);
}
public long getLongPollingTimeoutMillis() {
return gravityConfig.getLongPollingTimeoutMillis();
}
public void setLongPollingTimeoutMillis(long longPollingTimeoutMillis) {
gravityConfig.setLongPollingTimeoutMillis(longPollingTimeoutMillis);
}
public int getMaxMessagesQueuedPerChannel() {
return gravityConfig.getMaxMessagesQueuedPerChannel();
}
public void setMaxMessagesQueuedPerChannel(int maxMessagesQueuedPerChannel) {
gravityConfig.setMaxMessagesQueuedPerChannel(maxMessagesQueuedPerChannel);
}
public long getReconnectIntervalMillis() {
return gravityConfig.getReconnectIntervalMillis();
}
public int getReconnectMaxAttempts() {
return gravityConfig.getReconnectMaxAttempts();
}
public int getCorePoolSize() {
if (gravityPool != null) return gravityPool.getCorePoolSize();
return gravityConfig.getCorePoolSize();
}
public void setCorePoolSize(int corePoolSize) {
gravityConfig.setCorePoolSize(corePoolSize);
if (gravityPool != null) gravityPool.setCorePoolSize(corePoolSize);
}
public long getKeepAliveTimeMillis() {
if (gravityPool != null) return gravityPool.getKeepAliveTimeMillis();
return gravityConfig.getKeepAliveTimeMillis();
}
public void setKeepAliveTimeMillis(long keepAliveTimeMillis) {
gravityConfig.setKeepAliveTimeMillis(keepAliveTimeMillis);
if (gravityPool != null) gravityPool.setKeepAliveTimeMillis(keepAliveTimeMillis);
}
public int getMaximumPoolSize() {
if (gravityPool != null) return gravityPool.getMaximumPoolSize();
return gravityConfig.getMaximumPoolSize();
}
public void setMaximumPoolSize(int maximumPoolSize) {
gravityConfig.setMaximumPoolSize(maximumPoolSize);
if (gravityPool != null) gravityPool.setMaximumPoolSize(maximumPoolSize);
}
public int getQueueCapacity() {
if (gravityPool != null) return gravityPool.getQueueCapacity();
return gravityConfig.getQueueCapacity();
}
public int getQueueRemainingCapacity() {
if (gravityPool != null) return gravityPool.getQueueRemainingCapacity();
return gravityConfig.getQueueCapacity();
}
public int getQueueSize() {
if (gravityPool != null) return gravityPool.getQueueSize();
return 0;
}
public boolean hasUdpReceiverFactory() {
return udpReceiverFactory != null;
}
public UdpReceiverFactory getUdpReceiverFactory() {
return udpReceiverFactory;
}
///////////////////////////////////////////////////////////////////////////
// Channel's operations.
protected <C extends Channel> C createChannel(ChannelFactory<C> channelFactory, String clientId) {
C channel = null;
if (clientId != null) {
channel = getChannel(channelFactory, clientId);
if (channel != null) return channel;
}
String clientType = GraniteContext.getCurrentInstance().getClientType();
channel = channelFactory.newChannel(UUIDUtil.randomUUID(), clientType);
TimeChannel<C> timeChannel = new TimeChannel<C>(channel);
for (int i = 0; channels.putIfAbsent(channel.getId(), timeChannel) != null; i++) {
if (i >= 10)
throw new RuntimeException("Could not find random new clientId after 10 iterations");
channel.destroy(false);
channel = channelFactory.newChannel(UUIDUtil.randomUUID(), clientType);
timeChannel = new TimeChannel<C>(channel);
}
String channelId = channel.getId();
// Save channel id in distributed data (clustering).
try {
DistributedData gdd = graniteConfig.getDistributedDataFactory().getInstance();
if (gdd != null) {
log.debug("Saving channel id in distributed data: %s", channelId);
gdd.addChannelId(channelId, channelFactory.getClass().getName(), clientType);
}
} catch (Exception e) {
log.error(e, "Could not add channel id in distributed data: %s", channelId);
}
// Initialize timer task.
access(channelId);
return channel;
}
@SuppressWarnings("unchecked")
public <C extends Channel> C getChannel(ChannelFactory<C> channelFactory, String clientId) {
if (clientId == null) return null;
TimeChannel<C> timeChannel = (TimeChannel<C>) channels.get(clientId);
if (timeChannel == null) {
// Look for existing channel id/subscriptions in distributed data (clustering).
log.debug("Lookup channel %s in distributed data", clientId);
try {
DistributedData gdd = graniteConfig.getDistributedDataFactory().getInstance();
if (gdd != null && gdd.hasChannelId(clientId)) {
log.debug("Found channel id in distributed data: %s", clientId);
String channelFactoryClassName = gdd.getChannelFactoryClassName(clientId);
String clientType = gdd.getChannelClientType(clientId);
channelFactory =
(ChannelFactory<C>)
TypeUtil.newInstance(
channelFactoryClassName, new Class<?>[] {Gravity.class}, new Object[] {this});
C channel = channelFactory.newChannel(clientId, clientType);
timeChannel = new TimeChannel<C>(channel);
if (channels.putIfAbsent(clientId, timeChannel) == null) {
for (CommandMessage subscription : gdd.getSubscriptions(clientId)) {
log.debug("Resubscribing channel: %s - %s", clientId, subscription);
handleSubscribeMessage(channelFactory, subscription, false);
}
access(clientId);
}
}
} catch (Exception e) {
log.error(
e, "Could not recreate channel/subscriptions from distributed data: %s", clientId);
}
}
return (timeChannel != null ? timeChannel.getChannel() : null);
}
public Channel removeChannel(String channelId, boolean timeout) {
if (channelId == null) return null;
// Remove existing channel id/subscriptions in distributed data (clustering).
try {
DistributedData gdd = graniteConfig.getDistributedDataFactory().getInstance();
if (gdd != null) {
log.debug("Removing channel id from distributed data: %s", channelId);
gdd.removeChannelId(channelId);
}
} catch (Exception e) {
log.error(e, "Could not remove channel id from distributed data: %s", channelId);
}
TimeChannel<?> timeChannel = channels.get(channelId);
Channel channel = null;
if (timeChannel != null) {
try {
if (timeChannel.getTimerTask() != null) timeChannel.getTimerTask().cancel();
} catch (Exception e) {
// Should never happen...
}
channel = timeChannel.getChannel();
try {
for (Subscription subscription : channel.getSubscriptions()) {
try {
Message message = subscription.getUnsubscribeMessage();
handleMessage(channel.getFactory(), message, true);
} catch (Exception e) {
log.error(
e,
"Error while unsubscribing channel: %s from subscription: %s",
channel,
subscription);
}
}
} finally {
channels.remove(channelId);
channel.destroy(timeout);
}
}
return channel;
}
public boolean access(String channelId) {
if (channelId != null) {
TimeChannel<?> timeChannel = channels.get(channelId);
if (timeChannel != null) {
synchronized (timeChannel) {
TimerTask timerTask = timeChannel.getTimerTask();
if (timerTask != null) {
log.debug("Canceling TimerTask: %s", timerTask);
timerTask.cancel();
timeChannel.setTimerTask(null);
}
timerTask = new ChannelTimerTask(this, channelId);
timeChannel.setTimerTask(timerTask);
long timeout = gravityConfig.getChannelIdleTimeoutMillis();
log.debug("Scheduling TimerTask: %s for %s ms.", timerTask, timeout);
channelsTimer.schedule(timerTask, timeout);
return true;
}
}
}
return false;
}
public void execute(AsyncChannelRunner runner) {
if (gravityPool == null) {
runner.reset();
throw new NullPointerException("Gravity not started or pool disabled");
}
gravityPool.execute(runner);
}
public boolean cancel(AsyncChannelRunner runner) {
if (gravityPool == null) {
runner.reset();
throw new NullPointerException("Gravity not started or pool disabled");
}
return gravityPool.remove(runner);
}
///////////////////////////////////////////////////////////////////////////
// Incoming message handling.
public Message handleMessage(final ChannelFactory<?> channelFactory, Message message) {
return handleMessage(channelFactory, message, false);
}
public Message handleMessage(
final ChannelFactory<?> channelFactory, final Message message, boolean skipInterceptor) {
AMF3MessageInterceptor interceptor = null;
if (!skipInterceptor)
interceptor =
GraniteContext.getCurrentInstance().getGraniteConfig().getAmf3MessageInterceptor();
Message reply = null;
boolean publish = false;
try {
if (interceptor != null) interceptor.before(message);
if (message instanceof CommandMessage) {
CommandMessage command = (CommandMessage) message;
switch (command.getOperation()) {
case CommandMessage.LOGIN_OPERATION:
case CommandMessage.LOGOUT_OPERATION:
return handleSecurityMessage(command);
case CommandMessage.CLIENT_PING_OPERATION:
return handlePingMessage(channelFactory, command);
case CommandMessage.CONNECT_OPERATION:
return handleConnectMessage(channelFactory, command);
case CommandMessage.DISCONNECT_OPERATION:
return handleDisconnectMessage(channelFactory, command);
case CommandMessage.SUBSCRIBE_OPERATION:
return handleSubscribeMessage(channelFactory, command);
case CommandMessage.UNSUBSCRIBE_OPERATION:
return handleUnsubscribeMessage(channelFactory, command);
default:
throw new UnsupportedOperationException("Unsupported command operation: " + command);
}
}
reply = handlePublishMessage(channelFactory, (AsyncMessage) message);
publish = true;
} finally {
if (interceptor != null) interceptor.after(message, reply);
}
if (reply != null) {
GraniteContext context = GraniteContext.getCurrentInstance();
if (context.getSessionId() != null) {
reply.setHeader("org.granite.sessionId", context.getSessionId());
if (publish
&& context instanceof ServletGraniteContext
&& ((ServletGraniteContext) context).getSession(false) != null) {
long serverTime = new Date().getTime();
((ServletGraniteContext) context)
.getSession()
.setAttribute(GraniteContext.SESSION_LAST_ACCESSED_TIME_KEY, serverTime);
reply.setHeader("org.granite.time", serverTime);
reply.setHeader(
"org.granite.sessionExp",
((ServletGraniteContext) context).getSession().getMaxInactiveInterval());
}
}
}
return reply;
}
///////////////////////////////////////////////////////////////////////////
// Other Public API methods.
public GraniteContext initThread(String sessionId, String clientType) {
GraniteContext context = GraniteContext.getCurrentInstance();
if (context == null)
context =
SimpleGraniteContext.createThreadInstance(
graniteConfig, servicesConfig, sessionId, applicationMap, clientType);
return context;
}
public void releaseThread() {
GraniteContext.release();
}
public Message publishMessage(AsyncMessage message) {
return publishMessage(serverChannel, message);
}
public Message publishMessage(Channel fromChannel, AsyncMessage message) {
initThread(
null, fromChannel != null ? fromChannel.getClientType() : serverChannel.getClientType());
return handlePublishMessage(null, message, fromChannel != null ? fromChannel : serverChannel);
}
private Message handlePingMessage(ChannelFactory<?> channelFactory, CommandMessage message) {
Channel channel = createChannel(channelFactory, (String) message.getClientId());
AsyncMessage reply = new AcknowledgeMessage(message);
reply.setClientId(channel.getId());
Map<String, Object> advice = new HashMap<String, Object>();
advice.put(RECONNECT_INTERVAL_MS_KEY, Long.valueOf(gravityConfig.getReconnectIntervalMillis()));
advice.put(RECONNECT_MAX_ATTEMPTS_KEY, Long.valueOf(gravityConfig.getReconnectMaxAttempts()));
advice.put(ENCODE_MESSAGE_BODY_KEY, Boolean.valueOf(gravityConfig.isEncodeMessageBody()));
reply.setBody(advice);
reply.setDestination(message.getDestination());
log.debug("handshake.handle: reply=%s", reply);
return reply;
}
private Message handleSecurityMessage(CommandMessage message) {
GraniteConfig config = GraniteContext.getCurrentInstance().getGraniteConfig();
Message response = null;
if (!config.hasSecurityService())
log.warn(
"Ignored security operation (no security settings in granite-config.xml): %s", message);
else if (!config.getSecurityService().acceptsContext())
log.info(
"Ignored security operation (security service does not handle this kind of granite context)",
message);
else {
SecurityService securityService = config.getSecurityService();
try {
if (message.isLoginOperation())
securityService.login(
message.getBody(), (String) message.getHeader(Message.CREDENTIALS_CHARSET_HEADER));
else securityService.logout();
} catch (Exception e) {
if (e instanceof SecurityServiceException)
log.debug(e, "Could not process security operation: %s", message);
else log.error(e, "Could not process security operation: %s", message);
response = new ErrorMessage(message, e, true);
}
}
if (response == null) {
response = new AcknowledgeMessage(message, true);
// For SDK 2.0.1_Hotfix2.
if (message.isSecurityOperation()) response.setBody("success");
}
return response;
}
private Message handleConnectMessage(
final ChannelFactory<?> channelFactory, CommandMessage message) {
Channel client = getChannel(channelFactory, (String) message.getClientId());
if (client == null) return handleUnknownClientMessage(message);
return null;
}
private Message handleDisconnectMessage(
final ChannelFactory<?> channelFactory, CommandMessage message) {
Channel client = getChannel(channelFactory, (String) message.getClientId());
if (client == null) return handleUnknownClientMessage(message);
removeChannel(client.getId(), false);
AcknowledgeMessage reply = new AcknowledgeMessage(message);
reply.setDestination(message.getDestination());
reply.setClientId(client.getId());
return reply;
}
private Message handleSubscribeMessage(
final ChannelFactory<?> channelFactory, final CommandMessage message) {
return handleSubscribeMessage(channelFactory, message, true);
}
private Message handleSubscribeMessage(
final ChannelFactory<?> channelFactory,
final CommandMessage message,
final boolean saveMessageInSession) {
final GraniteContext context = GraniteContext.getCurrentInstance();
// Get and check destination.
final Destination destination =
context
.getServicesConfig()
.findDestinationById(message.getMessageRefType(), message.getDestination());
if (destination == null) return getInvalidDestinationError(message);
GravityInvocationContext invocationContext =
new GravityInvocationContext(message, destination) {
@Override
public Object invoke() throws Exception {
// Subscribe...
Channel channel = getChannel(channelFactory, (String) message.getClientId());
if (channel == null) return handleUnknownClientMessage(message);
String subscriptionId =
(String) message.getHeader(AsyncMessage.DESTINATION_CLIENT_ID_HEADER);
if (subscriptionId == null) {
subscriptionId = UUIDUtil.randomUUID();
message.setHeader(AsyncMessage.DESTINATION_CLIENT_ID_HEADER, subscriptionId);
}
DistributedData gdd = graniteConfig.getDistributedDataFactory().getInstance();
if (gdd != null) {
if (!gdd.hasChannelId(channel.getId())) {
gdd.addChannelId(
channel.getId(),
channel.getFactory().getClass().getName(),
context.getClientType());
log.debug("Stored channel %s in distributed data", channel.getId());
}
if (Boolean.TRUE
.toString()
.equals(destination.getProperties().get("session-selector"))) {
String selector = gdd.getDestinationSelector(destination.getId());
log.debug("Session selector found: %s", selector);
if (selector != null) message.setHeader(CommandMessage.SELECTOR_HEADER, selector);
}
}
ServiceAdapter adapter = adapterFactory.getServiceAdapter(message);
AsyncMessage reply = (AsyncMessage) adapter.manage(channel, message);
postManage(channel);
if (saveMessageInSession && !(reply instanceof ErrorMessage)) {
// Save subscription message in distributed data (clustering).
try {
if (gdd != null) {
log.debug(
"Saving new subscription message for channel: %s - %s",
channel.getId(), message);
gdd.addSubcription(channel.getId(), message);
}
} catch (Exception e) {
log.error(
e,
"Could not add subscription in distributed data: %s - %s",
channel.getId(),
subscriptionId);
}
}
reply.setDestination(message.getDestination());
reply.setClientId(channel.getId());
reply.getHeaders().putAll(message.getHeaders());
if (gdd != null && message.getDestination() != null) {
gdd.setDestinationClientId(message.getDestination(), channel.getId());
gdd.setDestinationSubscriptionId(message.getDestination(), subscriptionId);
}
return reply;
}
};
// Check security 1 (destination).
if (destination.getSecurizer() instanceof GravityDestinationSecurizer) {
try {
((GravityDestinationSecurizer) destination.getSecurizer()).canSubscribe(invocationContext);
} catch (Exception e) {
return new ErrorMessage(message, e);
}
}
// Check security 2 (security service).
GraniteConfig config = context.getGraniteConfig();
try {
if (config.hasSecurityService() && config.getSecurityService().acceptsContext())
return (Message) config.getSecurityService().authorize(invocationContext);
return (Message) invocationContext.invoke();
} catch (Exception e) {
return new ErrorMessage(message, e, true);
}
}
private Message handleUnsubscribeMessage(
final ChannelFactory<?> channelFactory, CommandMessage message) {
Channel channel = getChannel(channelFactory, (String) message.getClientId());
if (channel == null) return handleUnknownClientMessage(message);
AsyncMessage reply = null;
ServiceAdapter adapter = adapterFactory.getServiceAdapter(message);
reply = (AcknowledgeMessage) adapter.manage(channel, message);
postManage(channel);
if (!(reply instanceof ErrorMessage)) {
// Remove subscription message in distributed data (clustering).
try {
DistributedData gdd = graniteConfig.getDistributedDataFactory().getInstance();
if (gdd != null) {
String subscriptionId =
(String) message.getHeader(AsyncMessage.DESTINATION_CLIENT_ID_HEADER);
log.debug(
"Removing subscription message from channel info: %s - %s",
channel.getId(), subscriptionId);
gdd.removeSubcription(channel.getId(), subscriptionId);
}
} catch (Exception e) {
log.error(
e,
"Could not remove subscription from distributed data: %s - %s",
channel.getId(),
message.getHeader(AsyncMessage.DESTINATION_CLIENT_ID_HEADER));
}
}
reply.setDestination(message.getDestination());
reply.setClientId(channel.getId());
reply.getHeaders().putAll(message.getHeaders());
return reply;
}
protected void postManage(Channel channel) {}
private Message handlePublishMessage(
final ChannelFactory<?> channelFactory, final AsyncMessage message) {
return handlePublishMessage(channelFactory, message, null);
}
private Message handlePublishMessage(
final ChannelFactory<?> channelFactory, final AsyncMessage message, final Channel channel) {
GraniteContext context = GraniteContext.getCurrentInstance();
// Get and check destination.
Destination destination =
context
.getServicesConfig()
.findDestinationById(message.getClass().getName(), message.getDestination());
if (destination == null) return getInvalidDestinationError(message);
if (message.getMessageId() == null) message.setMessageId(UUIDUtil.randomUUID());
message.setTimestamp(System.currentTimeMillis());
if (channel != null) message.setClientId(channel.getId());
GravityInvocationContext invocationContext =
new GravityInvocationContext(message, destination) {
@Override
public Object invoke() throws Exception {
// Publish...
Channel fromChannel = channel;
if (fromChannel == null)
fromChannel = getChannel(channelFactory, (String) message.getClientId());
if (fromChannel == null) return handleUnknownClientMessage(message);
ServiceAdapter adapter = adapterFactory.getServiceAdapter(message);
AsyncMessage reply = (AsyncMessage) adapter.invoke(fromChannel, message);
reply.setDestination(message.getDestination());
reply.setClientId(fromChannel.getId());
return reply;
}
};
// Check security 1 (destination).
if (destination.getSecurizer() instanceof GravityDestinationSecurizer) {
try {
((GravityDestinationSecurizer) destination.getSecurizer()).canPublish(invocationContext);
} catch (Exception e) {
return new ErrorMessage(message, e, true);
}
}
// Check security 2 (security service).
GraniteConfig config = context.getGraniteConfig();
try {
if (config.hasSecurityService() && config.getSecurityService().acceptsContext())
return (Message) config.getSecurityService().authorize(invocationContext);
return (Message) invocationContext.invoke();
} catch (Exception e) {
return new ErrorMessage(message, e, true);
}
}
private Message handleUnknownClientMessage(Message message) {
ErrorMessage reply = new ErrorMessage(message, true);
reply.setFaultCode("Server.Call.UnknownClient");
reply.setFaultString("Unknown client");
return reply;
}
///////////////////////////////////////////////////////////////////////////
// Utilities.
private ErrorMessage getInvalidDestinationError(Message message) {
String messageType = message.getClass().getName();
if (message instanceof CommandMessage)
messageType += '[' + ((CommandMessage) message).getMessageRefType() + ']';
ErrorMessage reply = new ErrorMessage(message, true);
reply.setFaultCode("Server.Messaging.InvalidDestination");
reply.setFaultString(
"No configured destination for id: "
+ message.getDestination()
+ " and message type: "
+ messageType);
return reply;
}
private static class ServerChannel extends AbstractChannel implements Serializable {
private static final long serialVersionUID = 1L;
public ServerChannel(
Gravity gravity,
String channelId,
ChannelFactory<ServerChannel> factory,
String clientType) {
super(gravity, channelId, factory, clientType);
}
@Override
public Gravity getGravity() {
return gravity;
}
public void close() {}
@Override
public void receive(AsyncMessage message) throws MessageReceivingException {}
@Override
protected boolean hasAsyncHttpContext() {
return false;
}
@Override
protected AsyncHttpContext acquireAsyncHttpContext() {
return null;
}
@Override
protected void releaseAsyncHttpContext(AsyncHttpContext context) {}
}
}
/**
* @author Bouiaw
* @author wdrai
*/
public class SpringSecurityService extends AbstractSecurityService {
private static final Logger log = Logger.getLogger(SpringSecurityService.class);
private static final String FILTER_APPLIED =
"__spring_security_filterSecurityInterceptor_filterApplied";
private AbstractSpringSecurityInterceptor securityInterceptor = null;
public SpringSecurityService() {
log.debug("Starting Spring Security Service!");
}
public void configure(Map<String, String> params) {
log.debug("Configuring with parameters (NOOP) %s: ", params);
}
public void setSecurityInterceptor(AbstractSpringSecurityInterceptor securityInterceptor) {
this.securityInterceptor = securityInterceptor;
}
public Principal login(Object credentials, String charset) {
List<String> decodedCredentials = Arrays.asList(decodeBase64Credentials(credentials, charset));
HttpGraniteContext context = (HttpGraniteContext) GraniteContext.getCurrentInstance();
HttpServletRequest httpRequest = context.getRequest();
String user = decodedCredentials.get(0);
String password = decodedCredentials.get(1);
Authentication auth = new UsernamePasswordAuthenticationToken(user, password);
Principal principal = null;
ApplicationContext ctx =
WebApplicationContextUtils.getWebApplicationContext(
httpRequest.getSession().getServletContext());
if (ctx != null) {
AbstractAuthenticationManager authenticationManager =
BeanFactoryUtils.beanOfTypeIncludingAncestors(ctx, AbstractAuthenticationManager.class);
try {
Authentication authentication = authenticationManager.authenticate(auth);
SecurityContext securityContext = SecurityContextHolder.getContext();
securityContext.setAuthentication(authentication);
principal = authentication;
SecurityContextHolder.setContext(securityContext);
saveSecurityContextInSession(securityContext, 0);
endLogin(credentials, charset);
} catch (AuthenticationException e) {
handleAuthenticationExceptions(e);
}
}
log.debug("User %s logged in", user);
return principal;
}
protected void handleAuthenticationExceptions(AuthenticationException e) {
if (e instanceof BadCredentialsException || e instanceof UsernameNotFoundException)
throw SecurityServiceException.newInvalidCredentialsException(e.getMessage());
throw SecurityServiceException.newAuthenticationFailedException(e.getMessage());
}
public Object authorize(AbstractSecurityContext context) throws Exception {
log.debug("Authorize: %s", context);
log.debug(
"Is %s secured? %b",
context.getDestination().getId(), context.getDestination().isSecured());
startAuthorization(context);
HttpGraniteContext graniteContext = (HttpGraniteContext) GraniteContext.getCurrentInstance();
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
SecurityContext securityContextBefore = null;
int securityContextHashBefore = 0;
if (graniteContext.getRequest().getAttribute(FILTER_APPLIED) == null) {
securityContextBefore = loadSecurityContextFromSession();
if (securityContextBefore == null) securityContextBefore = SecurityContextHolder.getContext();
else securityContextHashBefore = securityContextBefore.hashCode();
SecurityContextHolder.setContext(securityContextBefore);
authentication = securityContextBefore.getAuthentication();
}
if (context.getDestination().isSecured()) {
if (!isAuthenticated(authentication)
|| authentication instanceof AnonymousAuthenticationToken) {
log.debug("Is not authenticated!");
throw SecurityServiceException.newNotLoggedInException("User not logged in");
}
if (!userCanAccessService(context, authentication)) {
log.debug("Access denied for: %s", authentication.getName());
throw SecurityServiceException.newAccessDeniedException("User not in required role");
}
}
try {
Object returnedObject =
securityInterceptor != null
? securityInterceptor.invoke(context)
: endAuthorization(context);
return returnedObject;
} catch (AccessDeniedException e) {
throw SecurityServiceException.newAccessDeniedException(e.getMessage());
} catch (InvocationTargetException e) {
handleAuthorizationExceptions(e);
throw e;
} finally {
if (graniteContext.getRequest().getAttribute(FILTER_APPLIED) == null) {
// Do this only when not already filtered by Spring Security
SecurityContext securityContextAfter = SecurityContextHolder.getContext();
SecurityContextHolder.clearContext();
saveSecurityContextInSession(securityContextAfter, securityContextHashBefore);
}
}
}
public void logout() {
HttpGraniteContext context = (HttpGraniteContext) GraniteContext.getCurrentInstance();
HttpSession session = context.getSession(false);
if (session != null
&& session.getAttribute(HttpSessionContextIntegrationFilter.SPRING_SECURITY_CONTEXT_KEY)
!= null) session.invalidate();
SecurityContextHolder.clearContext();
}
protected boolean isUserInRole(Authentication authentication, String role) {
for (GrantedAuthority ga : authentication.getAuthorities()) {
if (ga.getAuthority().matches(role)) return true;
}
return false;
}
protected boolean isAuthenticated(Authentication authentication) {
return authentication != null && authentication.isAuthenticated();
}
protected boolean userCanAccessService(
AbstractSecurityContext context, Authentication authentication) {
log.debug("Is authenticated as: %s", authentication.getName());
for (String role : context.getDestination().getRoles()) {
if (isUserInRole(authentication, role)) {
log.debug("Allowed access to %s in role %s", authentication.getName(), role);
return true;
}
log.debug("Access denied for %s not in role %s", authentication.getName(), role);
}
return false;
}
protected SecurityContext loadSecurityContextFromSession() {
HttpGraniteContext context = (HttpGraniteContext) GraniteContext.getCurrentInstance();
HttpServletRequest request = context.getRequest();
return (SecurityContext)
request
.getSession()
.getAttribute(HttpSessionContextIntegrationFilter.SPRING_SECURITY_CONTEXT_KEY);
}
protected void saveSecurityContextInSession(
SecurityContext securityContext, int securityContextHashBefore) {
if (securityContext.hashCode() != securityContextHashBefore
&& !(securityContext.getAuthentication() instanceof AnonymousAuthenticationToken)) {
HttpGraniteContext context = (HttpGraniteContext) GraniteContext.getCurrentInstance();
HttpServletRequest request = context.getRequest();
request
.getSession()
.setAttribute(
HttpSessionContextIntegrationFilter.SPRING_SECURITY_CONTEXT_KEY, securityContext);
}
}
protected void handleAuthorizationExceptions(InvocationTargetException e) {
for (Throwable t = e; t != null; t = t.getCause()) {
// Don't create a dependency to javax.ejb in SecurityService...
if (t instanceof SecurityException
|| t instanceof AccessDeniedException
|| "javax.ejb.EJBAccessException".equals(t.getClass().getName()))
throw SecurityServiceException.newAccessDeniedException(t.getMessage());
}
}
}
/** @author Franck WOLFF */
public abstract class AbstractChannel implements Channel {
///////////////////////////////////////////////////////////////////////////
// Fields.
private static final Logger log = Logger.getLogger(AbstractChannel.class);
protected final String id;
protected final String sessionId;
protected final String clientType;
protected final GravityInternal gravity;
protected final ChannelFactory<? extends Channel> factory;
// protected final ServletConfig servletConfig;
protected final ConcurrentMap<String, Subscription> subscriptions =
new ConcurrentHashMap<String, Subscription>();
protected Principal userPrincipal;
protected LinkedList<AsyncPublishedMessage> publishedQueue =
new LinkedList<AsyncPublishedMessage>();
protected final Lock publishedQueueLock = new ReentrantLock();
protected LinkedList<AsyncMessage> receivedQueue = new LinkedList<AsyncMessage>();
protected final Lock receivedQueueLock = new ReentrantLock();
protected final AsyncPublisher publisher;
protected final AsyncReceiver receiver;
protected UdpReceiver udpReceiver = null;
///////////////////////////////////////////////////////////////////////////
// Constructor.
protected AbstractChannel(
GravityInternal gravity,
String id,
ChannelFactory<? extends Channel> factory,
String clientType) {
if (id == null) throw new NullPointerException("id cannot be null");
this.id = id;
GraniteContext graniteContext = GraniteContext.getCurrentInstance();
this.clientType = clientType;
this.sessionId = graniteContext != null ? graniteContext.getSessionId() : null;
this.gravity = gravity;
this.factory = factory;
this.publisher = new AsyncPublisher(this);
this.receiver = new AsyncReceiver(this);
}
///////////////////////////////////////////////////////////////////////////
// Abstract protected method.
protected abstract boolean hasAsyncHttpContext();
protected abstract AsyncHttpContext acquireAsyncHttpContext();
protected abstract void releaseAsyncHttpContext(AsyncHttpContext context);
///////////////////////////////////////////////////////////////////////////
// Channel interface implementation.
public String getId() {
return id;
}
public String getClientType() {
return clientType;
}
public ChannelFactory<? extends Channel> getFactory() {
return factory;
}
public GravityInternal getGravity() {
return gravity;
}
public Subscription addSubscription(
String destination, String subTopicId, String subscriptionId, boolean noLocal) {
Subscription subscription =
new Subscription(this, destination, subTopicId, subscriptionId, noLocal);
Subscription present = subscriptions.putIfAbsent(subscriptionId, subscription);
return (present != null ? present : subscription);
}
public Collection<Subscription> getSubscriptions() {
return subscriptions.values();
}
public Subscription removeSubscription(String subscriptionId) {
return subscriptions.remove(subscriptionId);
}
public boolean isConnected() {
return true;
}
public boolean isAuthenticated() {
return userPrincipal != null;
}
public Principal getUserPrincipal() {
return userPrincipal;
}
public void setUserPrincipal(Principal principal) {
this.userPrincipal = principal;
gravity.notifyAuthenticated(this, principal);
}
public void publish(AsyncPublishedMessage message) throws MessagePublishingException {
if (message == null) throw new NullPointerException("message cannot be null");
publishedQueueLock.lock();
try {
publishedQueue.add(message);
} finally {
publishedQueueLock.unlock();
}
publisher.queue(getGravity());
}
public boolean hasPublishedMessage() {
publishedQueueLock.lock();
try {
return !publishedQueue.isEmpty();
} finally {
publishedQueueLock.unlock();
}
}
public boolean runPublish() {
LinkedList<AsyncPublishedMessage> publishedCopy = null;
publishedQueueLock.lock();
try {
if (publishedQueue.isEmpty()) return false;
publishedCopy = publishedQueue;
publishedQueue = new LinkedList<AsyncPublishedMessage>();
} finally {
publishedQueueLock.unlock();
}
for (AsyncPublishedMessage message : publishedCopy) {
try {
message.publish(this);
} catch (Exception e) {
log.error(e, "Error while trying to publish message: %s", message);
}
}
return true;
}
public void receive(AsyncMessage message) throws MessageReceivingException {
if (message == null) throw new NullPointerException("message cannot be null");
GravityInternal gravity = getGravity();
if (udpReceiver != null) {
if (udpReceiver.isClosed()) return;
try {
udpReceiver.receive(message);
} catch (MessageReceivingException e) {
if (e.getCause() instanceof SocketException) {
log.debug(e, "Closing unreachable UDP channel %s", getId());
udpReceiver.close(false);
} else log.error(e, "Cannot access UDP channel %s", getId());
}
return;
}
receivedQueueLock.lock();
try {
if (receivedQueue.size() + 1 > gravity.getGravityConfig().getMaxMessagesQueuedPerChannel())
throw new MessageReceivingException(
message, "Could not queue message (channel's queue is full) for channel: " + this);
log.debug(
"Channel %s queue message %s for client %s",
getId(), message.getMessageId(), message.getClientId());
receivedQueue.add(message);
} finally {
receivedQueueLock.unlock();
}
if (hasAsyncHttpContext()) receiver.queue(gravity);
}
public boolean hasReceivedMessage() {
receivedQueueLock.lock();
try {
return !receivedQueue.isEmpty();
} finally {
receivedQueueLock.unlock();
}
}
public boolean runReceive() {
return runReceived(null);
}
protected void createUdpReceiver(UdpReceiverFactory factory, AsyncHttpContext asyncHttpContext) {
OutputStream os = null;
try {
Message connectMessage = asyncHttpContext.getConnectMessage();
if (udpReceiver == null || udpReceiver.isClosed())
udpReceiver = factory.newReceiver(this, asyncHttpContext.getRequest(), connectMessage);
AsyncMessage reply = udpReceiver.acknowledge(connectMessage);
HttpServletRequest request = asyncHttpContext.getRequest();
HttpServletResponse response = asyncHttpContext.getResponse();
GraniteContext context =
HttpGraniteContext.createThreadIntance(
gravity.getGraniteConfig(), gravity.getServicesConfig(), null, request, response);
((AMFContextImpl) context.getAMFContext())
.setCurrentAmf3Message(asyncHttpContext.getConnectMessage());
GravityServletUtil.serialize(
gravity,
response,
new AsyncMessage[] {reply},
ContentType.forMimeType(request.getContentType()));
} catch (ServletException e) {
log.error(e, "Could not send UDP connect acknowledgement to channel: %s", this);
} catch (IOException e) {
log.error(e, "Could not send UDP connect acknowledgement to channel: %s", this);
} finally {
try {
GraniteContext.release();
} catch (Exception e) {
// should never happen...
}
// Close output stream.
try {
if (os != null) {
try {
os.close();
} catch (IOException e) {
log.warn(e, "Could not close output stream (ignored)");
}
}
} finally {
releaseAsyncHttpContext(asyncHttpContext);
}
}
}
public boolean runReceived(AsyncHttpContext asyncHttpContext) {
GravityInternal gravity = getGravity();
if (asyncHttpContext != null && gravity.hasUdpReceiverFactory()) {
UdpReceiverFactory factory = gravity.getUdpReceiverFactory();
if (factory.isUdpConnectRequest(asyncHttpContext.getConnectMessage())) {
createUdpReceiver(factory, asyncHttpContext);
return true;
}
if (udpReceiver != null) {
if (!udpReceiver.isClosed()) udpReceiver.close(false);
udpReceiver = null;
}
}
boolean httpAsParam = (asyncHttpContext != null);
LinkedList<AsyncMessage> messages = null;
OutputStream os = null;
try {
receivedQueueLock.lock();
try {
// Do we have any pending messages?
if (receivedQueue.isEmpty()) return false;
// Do we have a valid http context?
if (asyncHttpContext == null) {
asyncHttpContext = acquireAsyncHttpContext();
if (asyncHttpContext == null) return false;
}
// Both conditions are ok, get all pending messages.
messages = receivedQueue;
receivedQueue = new LinkedList<AsyncMessage>();
} finally {
receivedQueueLock.unlock();
}
HttpServletRequest request = asyncHttpContext.getRequest();
HttpServletResponse response = asyncHttpContext.getResponse();
// Set response messages correlation ids to connect request message id.
String correlationId = asyncHttpContext.getConnectMessage().getMessageId();
AsyncMessage[] messagesArray = new AsyncMessage[messages.size()];
int i = 0;
for (AsyncMessage message : messages) {
message.setCorrelationId(correlationId);
messagesArray[i++] = message;
}
// Setup serialization context (thread local)
GraniteContext context =
HttpGraniteContext.createThreadIntance(
gravity.getGraniteConfig(), gravity.getServicesConfig(), null, request, response);
((AMFContextImpl) context.getAMFContext())
.setCurrentAmf3Message(asyncHttpContext.getConnectMessage());
// Write messages to response output stream.
GravityServletUtil.serialize(
gravity, response, messagesArray, ContentType.forMimeType(request.getContentType()));
return true; // Messages were delivered, http context isn't valid anymore.
} catch (ServletException e) {
log.error(e, "Configuration error for channel: %s", getId());
return true;
} catch (IOException e) {
log.warn(e, "Could not send messages to channel: %s (retrying later)", getId());
GravityConfig gravityConfig = getGravity().getGravityConfig();
if (gravityConfig.isRetryOnError()) {
receivedQueueLock.lock();
try {
if (receivedQueue.size() + messages.size()
> gravityConfig.getMaxMessagesQueuedPerChannel()) {
log.warn(
"Channel %s has reached its maximum queue capacity %s (throwing %s messages)",
getId(), gravityConfig.getMaxMessagesQueuedPerChannel(), messages.size());
} else receivedQueue.addAll(0, messages);
} finally {
receivedQueueLock.unlock();
}
}
return true; // Messages weren't delivered, but http context isn't valid anymore.
} finally {
// Cleanup serialization context (thread local)
try {
GraniteContext.release();
} catch (Exception e) {
// should never happen...
}
// Close output stream.
try {
if (os != null) {
try {
os.close();
} catch (IOException e) {
log.warn(e, "Could not close output stream (ignored)");
}
}
} finally {
// Cleanup http context (only if this method wasn't explicitly called with a non null
// AsyncHttpContext from the servlet).
if (!httpAsParam) releaseAsyncHttpContext(asyncHttpContext);
}
}
}
public final void destroy() {
destroy(false);
}
public void destroy(boolean timeout) {
try {
GravityInternal gravity = getGravity();
gravity.cancel(publisher);
gravity.cancel(receiver);
subscriptions.clear();
} finally {
if (udpReceiver != null) {
if (!udpReceiver.isClosed()) udpReceiver.close(timeout);
udpReceiver = null;
}
}
}
///////////////////////////////////////////////////////////////////////////
// Protected utilities.
protected boolean queueReceiver() {
if (hasReceivedMessage()) {
receiver.queue(getGravity());
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////////
// Object overwritten methods.
@Override
public boolean equals(Object obj) {
return (obj instanceof Channel && id.equals(((Channel) obj).getId()));
}
@Override
public int hashCode() {
return id.hashCode();
}
@Override
public String toString() {
return getClass().getName() + " {id=" + id + ", subscriptions=" + subscriptions.values() + "}";
}
}
/** * @author <a href="mailto:[email protected]">[email protected]</a> * @since 1.1.0 */ public class AMFServiceAdaptor extends HttpServlet { private static final long serialVersionUID = 4777538296260511097L; private static final Logger log = Logger.getLogger(AMFServiceAdaptor.class); private GraniteConfig graniteConfig = null; private ServicesConfig servicesConfig = null; BundleContext context; public AMFServiceAdaptor(BundleContext context) { this.context = context; } /* * (non-Javadoc) * @see javax.servlet.GenericServlet#init(javax.servlet.ServletConfig) */ @Override public void init(ServletConfig config) { try { super.init(config); Configuration configuration = Activator.getConfigurationService(); getServletContext() .setAttribute(ServletGraniteConfig.GRANITE_CONFIG_CONFIGURATION_KEY, configuration); graniteConfig = ServletGraniteConfig.loadConfig(getServletContext()); servicesConfig = ServletServicesConfig.loadConfig(getServletContext()); // register EventHandler ServicesConfig handle Add or Remove dataservice Dictionary<String, Object> properties = new Hashtable<String, Object>(); String[] topics = new String[] { OSGIConstants.TOPIC_GDS_ADD_SERVICE, OSGIConstants.TOPIC_GDS_REMOVE_SERVICE }; properties.put(EventConstants.EVENT_TOPIC, topics); context.registerService( EventHandler.class.getName(), new ServiceEventHandler(servicesConfig), properties); } catch (ServletException e) { log.error(e, "Could initialize OSGi service adaptor"); } } public ServicesConfig getServicesConfig() { return servicesConfig; } /* * (non-Javadoc) * @see javax.servlet.http.HttpServlet#doPost(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse) */ @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { if (log.isInfoEnabled()) try { GraniteContext context = HttpGraniteContext.createThreadIntance( graniteConfig, servicesConfig, getServletContext(), request, response); if (context == null) throw new ServletException("GraniteContext not Initialized!!"); // AMFContextImpl amf = (AMFContextImpl) context.getAMFContext(); // Phase1 Deserializing AMF0 request if (log.isInfoEnabled()) log.info(">>>>> Deserializing AMF0 request from..." + request.getRequestURI()); AMF0Deserializer deserializer = new AMF0Deserializer(new DataInputStream(request.getInputStream())); AMF0Message amf0Request = deserializer.getAMFMessage(); // Phase2 Processing AMF0 request if (log.isInfoEnabled()) log.info(">>>>> Processing AMF0 request: " + amf0Request); AMF0Message amf0Response = AMF0MessageProcessor.process(amf0Request); if (log.isInfoEnabled()) log.info("<<<<< Returning AMF0 response: " + amf0Response); // Phase3 Send back response to the client response.setContentType(AMF0Message.CONTENT_TYPE); AMF0Serializer serializer = new AMF0Serializer(new DataOutputStream(response.getOutputStream())); serializer.serializeMessage(amf0Response); if (log.isInfoEnabled()) log.info("...End of Processing AMF Request......"); } catch (Exception e) { log.error(e, "Could not handle AMF request"); throw new ServletException(e); } } }
/** @author Franck WOLFF */
public class StandardRemoteAliasScanner implements RemoteAliasScanner {
private static final Logger log = Logger.getLogger(StandardRemoteAliasScanner.class);
@Override
public Set<Class<?>> scan(Set<String> packageNames) {
Set<Class<?>> classes = new HashSet<Class<?>>();
Scanner scanner =
ScannerFactory.createScanner(new MessagingScannedItemHandler(packageNames, classes), null);
try {
scanner.scan();
} catch (Exception e) {
log.error(e, "Could not scan classpath for @RemoteAlias");
}
return classes;
}
class MessagingScannedItemHandler implements ScannedItemHandler {
final String[] packageNames;
final Set<Class<?>> classes;
MessagingScannedItemHandler(Set<String> packageNames, Set<Class<?>> classes) {
this.packageNames = new String[packageNames.size()];
int i = 0;
for (String packageName : packageNames)
this.packageNames[i++] = packageName.replace('.', '/') + '/';
this.classes = classes;
}
@Override
public boolean handleMarkerItem(ScannedItem item) {
return false;
}
@Override
public void handleScannedItem(ScannedItem item) {
if ("class".equals(item.getExtension())) {
boolean scan = false;
String path = item.getRelativePath();
for (String packageName : packageNames) {
if (path.startsWith(packageName)) {
scan = true;
break;
}
}
if (scan) {
try {
Class<?> cls = item.loadAsClass();
RemoteAlias alias = cls.getAnnotation(RemoteAlias.class);
if (alias != null) classes.add(cls);
} catch (ClassFormatError e) {
} catch (ClassNotFoundException e) {
} catch (IOException e) {
log.error(e, "Could not load class: %s", item);
}
}
}
}
}
}
/**
* @author Venkat DANDA
* @author Cameron INGRAM
* <p>Update services-config.xml to use the seam service exception handler <factory
* id="tideSeamFactory" class="org.granite.tide.seam.SeamServiceFactory" > <properties>
* <service-exception-handler>org.granite.tide.seam.SeamServiceExceptionHandler</service-exception-handler>
* </properties> </factory>
*/
public class ExtendedServiceExceptionHandler extends DefaultServiceExceptionHandler {
private static final long serialVersionUID = -1L;
private static final Logger log = Logger.getLogger(ExtendedServiceExceptionHandler.class);
public static final Class<?> JAVAX_EJB_EXCEPTION;
static {
Class<?> exception = null;
try {
exception =
Thread.currentThread().getContextClassLoader().loadClass("javax.ejb.EJBException");
} catch (Exception e) {
}
JAVAX_EJB_EXCEPTION = exception;
}
public ExtendedServiceExceptionHandler() {
this(true);
}
public ExtendedServiceExceptionHandler(boolean logException) {
super(logException);
}
@Override
protected ServiceException getServiceException(
Message request, Destination destination, String method, Throwable t) {
if (t == null) throw new NullPointerException("Parameter t cannot be null");
Map<String, Object> extendedData = new HashMap<String, Object>();
if (t instanceof ServiceException) {
((ServiceException) t).getExtendedData().putAll(extendedData);
return (ServiceException) t;
}
List<Throwable> causes = new ArrayList<Throwable>();
for (Throwable cause = t; cause != null; cause = getCause(cause)) causes.add(cause);
String detail =
"\n"
+ "- destination: "
+ (destination != null ? destination.getId() : "")
+ "\n"
+ "- method: "
+ method
+ "\n"
+ "- exception: "
+ t.toString()
+ "\n";
for (int i = causes.size() - 1; i >= 0; i--) {
Throwable cause = causes.get(i);
for (ExceptionConverter ec :
GraniteContext.getCurrentInstance().getGraniteConfig().getExceptionConverters()) {
if (ec.accepts(cause, t)) return ec.convert(cause, detail, extendedData);
}
}
if (getLogException()) log.error(t, "Could not process remoting message: %s", request);
// Default exception handler
ServiceException se =
new ServiceException(
t.getClass().getSimpleName() + ".Call.Failed", t.getMessage(), detail, t);
se.getExtendedData().putAll(extendedData);
return se;
}
public static Throwable getCause(Throwable t) {
Throwable cause = null;
try {
if (JAVAX_EJB_EXCEPTION != null && JAVAX_EJB_EXCEPTION.isInstance(t)) {
Method m = JAVAX_EJB_EXCEPTION.getMethod("getCausedByException");
cause = (Throwable) m.invoke(t);
} else if (t instanceof ServletException) cause = ((ServletException) t).getRootCause();
else cause = t.getCause();
} catch (Exception x) {
return null;
}
return cause == t ? null : (Throwable) cause;
}
}
/** @author William DRAI */
public class EjbServiceContext extends TideServiceContext {
private static final long serialVersionUID = 1L;
private static final Logger log = Logger.getLogger(EjbServiceContext.class);
public static final String CAPITALIZED_DESTINATION_ID = "{capitalized.component.name}";
public static final String DESTINATION_ID = "{component.name}";
private final transient Map<String, EjbComponent> ejbLookupCache =
new ConcurrentHashMap<String, EjbComponent>();
private final Set<String> remoteObservers = new HashSet<String>();
private final String lookup;
private final EjbIdentity identity;
private String entityManagerFactoryJndiName = null;
private String entityManagerJndiName = null;
public EjbServiceContext() throws ServiceException {
super();
lookup = "";
identity = new EjbIdentity();
}
public EjbServiceContext(String lookup) throws ServiceException {
super();
this.lookup = lookup;
identity = new EjbIdentity();
}
@Override
protected AsyncPublisher getAsyncPublisher() {
return null;
}
public void setEntityManagerFactoryJndiName(String entityManagerFactoryJndiName) {
this.entityManagerFactoryJndiName = entityManagerFactoryJndiName;
}
public void setEntityManagerJndiName(String entityManagerJndiName) {
this.entityManagerJndiName = entityManagerJndiName;
}
/**
* Create a TidePersistenceManager
*
* @param create create if not existent (can be false for use in entity merge)
* @return a TidePersistenceManager
*/
@Override
protected TidePersistenceManager getTidePersistenceManager(boolean create) {
if (!create) return null;
EntityManager em = getEntityManager();
if (em == null) return null;
return new JPAPersistenceManager(em);
}
/**
* Find the entity manager using the jndi names stored in the bean.
*
* @return The found entity manager
*/
private EntityManager getEntityManager() {
try {
InitialContext jndiContext = new InitialContext();
if (entityManagerFactoryJndiName != null) {
EntityManagerFactory factory =
(EntityManagerFactory) jndiContext.lookup(entityManagerFactoryJndiName);
return factory.createEntityManager();
} else if (entityManagerJndiName != null) {
return (EntityManager) jndiContext.lookup(entityManagerJndiName);
}
} catch (NamingException e) {
if (entityManagerFactoryJndiName != null)
throw new RuntimeException(
"Unable to find a EntityManagerFactory for jndiName " + entityManagerFactoryJndiName);
else if (entityManagerJndiName != null)
throw new RuntimeException(
"Unable to find a EntityManager for jndiName " + entityManagerJndiName);
}
return null;
}
public Object callComponent(Method method, Object... args) throws Exception {
String name = method.getDeclaringClass().getSimpleName();
name = name.substring(0, 1).toLowerCase() + name.substring(1);
if (name.endsWith("Bean")) name = name.substring(0, name.length() - "Bean".length());
Object invokee = findComponent(name, null);
method = invokee.getClass().getMethod(method.getName(), method.getParameterTypes());
return method.invoke(invokee, args);
}
public Set<String> getRemoteObservers() {
return remoteObservers;
}
/* (non-Javadoc)
* @see org.granite.tide.ejb.EJBServiceContextIntf#findComponent(java.lang.String)
*/
@Override
public Object findComponent(String componentName, Class<?> componentClass) {
if ("identity".equals(componentName)) return identity;
EjbComponent component = ejbLookupCache.get(componentName);
if (component != null) return component.ejbInstance;
// Compute EJB JNDI binding.
String name = componentName;
if (lookup != null) {
name = lookup;
if (lookup.contains(CAPITALIZED_DESTINATION_ID))
name = lookup.replace(CAPITALIZED_DESTINATION_ID, capitalize(componentName));
if (lookup.contains(DESTINATION_ID)) name = lookup.replace(DESTINATION_ID, componentName);
}
InitialContext ic = null;
try {
ic = new InitialContext();
} catch (Exception e) {
throw new ServiceException("Could not get InitialContext", e);
}
log.debug(">> New EjbServiceInvoker looking up: %s", name);
try {
component = new EjbComponent();
component.ejbInstance = ic.lookup(name);
component.ejbClasses = new HashSet<Class<?>>();
Class<?> scannedClass = null;
EjbScannedItemHandler itemHandler = EjbScannedItemHandler.instance();
for (Class<?> i : component.ejbInstance.getClass().getInterfaces()) {
if (itemHandler.getScannedClasses().containsKey(i)) {
scannedClass = itemHandler.getScannedClasses().get(i);
break;
}
}
if (scannedClass == null)
scannedClass = itemHandler.getScannedClasses().get(component.ejbInstance.getClass());
// GDS-768: handle of proxied no-interface EJBs in GlassFish v3
if (scannedClass == null && component.ejbInstance.getClass().getSuperclass() != null)
scannedClass =
itemHandler.getScannedClasses().get(component.ejbInstance.getClass().getSuperclass());
if (scannedClass != null) {
component.ejbClasses.add(scannedClass);
for (Map.Entry<Class<?>, Class<?>> me : itemHandler.getScannedClasses().entrySet()) {
if (me.getValue().equals(scannedClass)) component.ejbClasses.add(me.getKey());
}
component.ejbMetadata =
new EjbServiceMetadata(scannedClass, component.ejbInstance.getClass());
} else
log.warn(
"Ejb "
+ componentName
+ " was not scanned: remove method will not be called if it is a Stateful bean. Add META-INF/services-config.properties if needed.");
ejbLookupCache.put(componentName, component);
return component.ejbInstance;
} catch (NamingException e) {
log.error("EJB not found " + name + ": " + e.getMessage());
throw new ServiceException("Could not lookup for: " + name, e);
}
}
/* (non-Javadoc)
* @see org.granite.tide.ejb.EJBServiceContextIntf#findComponentClass(java.lang.String)
*/
@Override
public Set<Class<?>> findComponentClasses(String componentName, Class<?> componentClass) {
if ("identity".equals(componentName)) {
Set<Class<?>> classes = new HashSet<Class<?>>(1);
classes.add(EjbIdentity.class);
return classes;
}
EjbComponent component = ejbLookupCache.get(componentName);
if (component == null) findComponent(componentName, componentClass);
return ejbLookupCache.get(componentName).ejbClasses;
}
private String capitalize(String s) {
if (s == null || s.length() == 0) return s;
if (s.length() == 1) return s.toUpperCase();
return s.substring(0, 1).toUpperCase() + s.substring(1);
}
/* (non-Javadoc)
* @see org.granite.tide.ejb.EJBServiceContextIntf#prepareCall(org.granite.messaging.service.ServiceInvocationContext, org.granite.tide.IInvocationCall, java.lang.String)
*/
@Override
public void prepareCall(
ServiceInvocationContext context,
IInvocationCall c,
String componentName,
Class<?> componentClass) {
if ((c instanceof InvocationCall) && ((InvocationCall) c).getListeners() != null)
remoteObservers.addAll(((InvocationCall) c).getListeners());
Context.create(this);
}
private static class EjbComponent {
public Object ejbInstance;
public Set<Class<?>> ejbClasses;
public EjbServiceMetadata ejbMetadata;
}
/* (non-Javadoc)
* @see org.granite.tide.ejb.EJBServiceContextIntf#postCall(org.granite.messaging.service.ServiceInvocationContext, java.lang.Object, java.lang.String)
*/
@Override
public IInvocationResult postCall(
ServiceInvocationContext context,
Object result,
String componentName,
Class<?> componentClass) {
try {
AbstractContext threadContext = AbstractContext.instance();
List<ContextUpdate> results = new ArrayList<ContextUpdate>(threadContext.size());
DataContext dataContext = DataContext.get();
Set<Object[]> dataUpdates = dataContext != null ? dataContext.getDataUpdates() : null;
Object[][] updates = null;
if (dataUpdates != null && !dataUpdates.isEmpty())
updates = dataUpdates.toArray(new Object[dataUpdates.size()][]);
for (Map.Entry<String, Object> entry : threadContext.entrySet())
results.add(new ContextUpdate(entry.getKey(), null, entry.getValue(), 3, false));
InvocationResult ires = new InvocationResult(result, results);
if (context.getBean() != null) {
if (context.getBean().getClass().isAnnotationPresent(BypassTideMerge.class))
ires.setMerge(false);
else {
try {
Method m =
context
.getBean()
.getClass()
.getMethod(
context.getMethod().getName(), context.getMethod().getParameterTypes());
if (m.isAnnotationPresent(BypassTideMerge.class)) ires.setMerge(false);
} catch (Exception e) {
log.warn("Could not find bean method", e);
}
}
}
ires.setUpdates(updates);
ires.setEvents(new ArrayList<ContextEvent>(threadContext.getRemoteEvents()));
if (componentName != null) {
EjbComponent component = ejbLookupCache.get(componentName);
if (component != null
&& component.ejbMetadata != null
&& component.ejbMetadata.isStateful()
&& component.ejbMetadata.isRemoveMethod(context.getMethod()))
ejbLookupCache.remove(componentName);
}
return ires;
} finally {
AbstractContext.remove();
}
}
/* (non-Javadoc)
* @see org.granite.tide.ejb.EJBServiceContextIntf#postCallFault(org.granite.messaging.service.ServiceInvocationContext, java.lang.Throwable, java.lang.String)
*/
@Override
public void postCallFault(
ServiceInvocationContext context,
Throwable t,
String componentName,
Class<?> componentClass) {
try {
if (componentName != null) {
EjbComponent component = ejbLookupCache.get(componentName);
if (t instanceof NoSuchEJBException
|| (component != null
&& component.ejbMetadata != null
&& (component.ejbMetadata.isStateful()
&& component.ejbMetadata.isRemoveMethod(context.getMethod())
&& !component.ejbMetadata.getRetainIfException(context.getMethod())))) {
ejbLookupCache.remove(componentName);
}
}
} finally {
AbstractContext.remove();
}
}
}
/** @author Franck WOLFF */
public class EntityCodec implements ExtendedObjectCodec {
private static final Logger log = Logger.getLogger(EntityCodec.class);
private final ConcurrentMap<Class<?>, SerializableProxyAdapter> serializableProxyAdapters =
new ConcurrentHashMap<Class<?>, SerializableProxyAdapter>();
static class SerializableProxyAdapter {
private final Object serializableProxy;
private final Field idField;
private final Method readResolveMethod;
public SerializableProxyAdapter(HibernateProxy proxy)
throws NoSuchMethodException, SecurityException, NoSuchFieldException {
this.serializableProxy = proxy.writeReplace();
this.idField = serializableProxy.getClass().getDeclaredField("id");
this.idField.setAccessible(true);
this.readResolveMethod = serializableProxy.getClass().getDeclaredMethod("readResolve");
this.readResolveMethod.setAccessible(true);
}
public HibernateProxy newProxy(Serializable id)
throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
synchronized (serializableProxy) {
idField.set(serializableProxy, id);
return (HibernateProxy) readResolveMethod.invoke(serializableProxy);
}
}
}
public boolean canEncode(ExtendedObjectOutput out, Object v) {
Class<?> cls = getClass(out, v);
return (cls.isAnnotationPresent(Entity.class)
|| cls.isAnnotationPresent(MappedSuperclass.class));
}
public String getEncodedClassName(ExtendedObjectOutput out, Object v) {
return getClass(out, v).getName();
}
public void encode(ExtendedObjectOutput out, Object v)
throws IOException, IllegalAccessException, InvocationTargetException {
String detachedState = null;
if (v instanceof HibernateProxy) {
HibernateProxy proxy = (HibernateProxy) v;
// Only write initialized flag, detachedState & id if v is an uninitialized proxy.
if (proxy.getHibernateLazyInitializer().isUninitialized()) {
Class<?> persistentClass = proxy.getHibernateLazyInitializer().getPersistentClass();
if (!serializableProxyAdapters.containsKey(persistentClass)) {
try {
SerializableProxyAdapter proxyAdapter = new SerializableProxyAdapter(proxy);
serializableProxyAdapters.putIfAbsent(persistentClass, proxyAdapter);
} catch (Exception e) {
throw new IOException("Could not create SerializableProxyAdapter for: " + proxy);
}
}
Serializable id = proxy.getHibernateLazyInitializer().getIdentifier();
log.debug("Writing uninitialized HibernateProxy %s with id %s", detachedState, id);
out.writeBoolean(false);
out.writeUTF(null);
out.writeObject(id);
return;
}
// Proxy is initialized, get the underlying persistent object.
log.debug("Writing initialized HibernateProxy...");
v = proxy.getHibernateLazyInitializer().getImplementation();
}
// Write initialized flag & detachedState.
out.writeBoolean(true);
out.writeUTF(null);
// Write all properties in lexical order.
List<Property> properties = out.getReflection().findSerializableProperties(v.getClass());
for (Property property : properties) out.getAndWriteProperty(v, property);
}
public boolean canDecode(ExtendedObjectInput in, String className) throws ClassNotFoundException {
Class<?> cls = in.getReflection().loadClass(className);
return (cls.isAnnotationPresent(Entity.class)
|| cls.isAnnotationPresent(MappedSuperclass.class));
}
public String getDecodedClassName(ExtendedObjectInput in, String className) {
return in.getAlias(className);
}
public Object newInstance(ExtendedObjectInput in, String className)
throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException,
InvocationTargetException, SecurityException, NoSuchMethodException, IOException {
Class<?> cls = in.getReflection().loadClass(className);
// Read initialized flag & detachedState.
boolean initialized = in.readBoolean();
in.readUTF();
if (initialized) return in.getReflection().newInstance(cls);
// Create an HibernateProxy.
SerializableProxyAdapter proxyAdapter = serializableProxyAdapters.get(cls);
if (proxyAdapter == null)
throw new IOException("Could not find SerializableProxyAdapter for: " + cls);
Serializable id = (Serializable) in.readObject();
return proxyAdapter.newProxy(id);
}
public void decode(ExtendedObjectInput in, Object v)
throws IOException, ClassNotFoundException, IllegalAccessException,
InvocationTargetException {
if (!(v instanceof HibernateProxy)) {
List<Property> properties = in.getReflection().findSerializableProperties(v.getClass());
for (Property property : properties) in.readAndSetProperty(v, property);
}
}
protected Class<?> getClass(ExtendedObjectOutput out, Object v) {
Class<?> cls = v.getClass();
if (v instanceof HibernateProxy) {
LazyInitializer initializer = ((HibernateProxy) v).getHibernateLazyInitializer();
String className =
(initializer.isUninitialized()
? initializer.getEntityName()
: initializer.getImplementation().getClass().getName());
if (className != null && className.length() > 0) {
try {
cls = out.getReflection().loadClass(className);
} catch (ClassNotFoundException e) {
cls = initializer.getPersistentClass();
}
}
}
return cls;
}
}
@Component
@Provides
public class OSGiServiceSimple extends SimpleService {
private static final Logger log = Logger.getLogger(OSGiServiceSimple.class);
@ServiceProperty(name = "ID")
private String ID;
@Requires(proxy = false)
private ServicesConfig servicesConfig;
//
private boolean started = false;
//
public OSGiServiceSimple() {
super(
null, null, null, null, new HashMap<String, Adapter>(), new HashMap<String, Destination>());
}
@Property(name = "id", mandatory = true)
private void setId(String id) {
this.id = id;
this.ID = id;
}
@Property(name = "messageTypes", mandatory = true)
private void setMessageTypes(String messageTypes) {
this.messageTypes = messageTypes;
}
@Property(name = "class", mandatory = false, value = "flex.messaging.services.RemotingService")
private void setClass(String className) {
this.className = className;
}
@Validate
public void start() {
log.debug("Start OSGiServiceSimple: " + toString());
if (servicesConfig.findServiceById(id) == null) {
// Clear destinations
destinations.clear();
servicesConfig.addService(this);
started = true;
} else {
log.error("Service \"" + id + "\" already registered");
}
}
@Invalidate
public void stop() {
log.debug("Stop OSGiServiceSimple: " + toString());
if (servicesConfig != null) {
servicesConfig.removeService(id);
started = false;
}
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
OSGiServiceSimple that = (OSGiServiceSimple) o;
if (this != that) return false;
return true;
}
@Override
public String toString() {
return "Service{"
+ "id="
+ id
+ ", class="
+ className
+ ", messageTypes="
+ messageTypes
+ '}';
}
}
/** @author Franck WOLFF */
public class JMFServletContextListener implements ServletContextListener {
private static final Logger log = Logger.getLogger(GraniteConfigListener.class);
private static final String[] CODEC_EXTENSION_FACTORY_NAMES = {
"org.granite.hibernate.jmf.Hibernate3CodecExtensionFactory"
};
public static final String EXTENDED_OBJECT_CODECS_PARAM = "jmf-extended-object-codecs";
public static final String DEFAULT_STORED_STRINGS_PARAM = "jmf-default-stored-strings";
public static final String SHARED_CONTEXT_KEY = SharedContext.class.getName();
public static final String DUMP_SHARED_CONTEXT_KEY = SharedContext.class.getName() + ":DUMP";
public static SharedContext getSharedContext(ServletContext servletContext) {
return (SharedContext) servletContext.getAttribute(SHARED_CONTEXT_KEY);
}
public static SharedContext getDumpSharedContext(ServletContext servletContext) {
return (SharedContext) servletContext.getAttribute(DUMP_SHARED_CONTEXT_KEY);
}
public static ServletException newSharedContextNotInitializedException() {
return new ServletException(
"JMF shared context not initialized (configure "
+ JMFServletContextListener.class.getName()
+ " in your web.xml)");
}
public void contextInitialized(ServletContextEvent event) {
log.info("Loading JMF shared context");
ServletContext servletContext = event.getServletContext();
List<ExtendedObjectCodec> extendedObjectCodecs = loadExtendedObjectCodecs(servletContext);
List<String> defaultStoredStrings = loadDefaultStoredStrings(servletContext);
SharedContext sharedContext =
new DefaultSharedContext(
new DefaultCodecRegistry(extendedObjectCodecs), null, defaultStoredStrings);
servletContext.setAttribute(SHARED_CONTEXT_KEY, sharedContext);
SharedContext dumpSharedContext =
new DefaultSharedContext(new DefaultCodecRegistry(), null, defaultStoredStrings);
servletContext.setAttribute(DUMP_SHARED_CONTEXT_KEY, dumpSharedContext);
log.info("JMF shared context loaded");
}
protected List<ExtendedObjectCodec> loadExtendedObjectCodecs(ServletContext servletContext) {
String extendedObjectCodecsParam =
servletContext.getInitParameter(EXTENDED_OBJECT_CODECS_PARAM);
if (extendedObjectCodecsParam == null) return detectExtendedObjectCodecs();
ClassLoader classLoader = getClass().getClassLoader();
List<ExtendedObjectCodec> extendedObjectCodecs = new ArrayList<ExtendedObjectCodec>();
for (String className : extendedObjectCodecsParam.trim().split("\\s*\\,\\s*")) {
if (className.length() == 0) continue;
log.info("Loading JMF extended object codec: %s", className);
try {
@SuppressWarnings("unchecked")
Class<? extends ExtendedObjectCodec> cls =
(Class<? extends ExtendedObjectCodec>) classLoader.loadClass(className);
extendedObjectCodecs.add(cls.getDeclaredConstructor().newInstance());
} catch (Throwable t) {
log.warn(t, "Could not load JMF codec: %s", className);
}
}
return extendedObjectCodecs;
}
protected List<ExtendedObjectCodec> detectExtendedObjectCodecs() {
log.info("Auto detecting extended object codec...");
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
for (String factoryName : CODEC_EXTENSION_FACTORY_NAMES) {
try {
CodecExtensionFactory factory =
(CodecExtensionFactory) classLoader.loadClass(factoryName).newInstance();
List<ExtendedObjectCodec> extendedObjectCodecs = factory.getCodecs();
log.info("Using %s: %s", factoryName, extendedObjectCodecs);
return extendedObjectCodecs;
} catch (Throwable t) {
log.debug(t, "Could not load factory: %s", factoryName);
}
}
log.info("No extended object codec detected");
return Collections.emptyList();
}
protected List<String> loadDefaultStoredStrings(ServletContext servletContext) {
List<String> defaultStoredStrings =
new ArrayList<String>(JMFAMFUtil.AMF_DEFAULT_STORED_STRINGS);
String defaultStoredStringsParam =
servletContext.getInitParameter(DEFAULT_STORED_STRINGS_PARAM);
if (defaultStoredStringsParam != null) {
for (String value : defaultStoredStringsParam.trim().split("\\s*\\,\\s*")) {
if (value.length() > 0) defaultStoredStrings.add(value);
}
}
return defaultStoredStrings;
}
public void contextDestroyed(ServletContextEvent event) {
ServletContext servletContext = event.getServletContext();
servletContext.removeAttribute(SHARED_CONTEXT_KEY);
}
}
/** @author Franck WOLFF */
public class DumpFilter implements Filter {
private static final Logger log = Logger.getLogger(DumpFilter.class);
private static final String HEXS = "0123456789ABCDEF";
private static final String DUMP_DIR = "dumpDir";
File dumpDir = null;
public void init(FilterConfig config) throws ServletException {
String dumpDirString = ServletParams.get(config, DUMP_DIR, String.class, null);
if (dumpDirString != null) {
File dumpDir = new File(dumpDirString);
if (!dumpDir.exists() || !dumpDir.isDirectory() || !dumpDir.canWrite())
log.warn("Ignoring dump directory (is it a writable directory?): %s", dumpDir);
else this.dumpDir = dumpDir;
}
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
DumpRequestWrapper requestWrapper = new DumpRequestWrapper((HttpServletRequest) request);
DumpResponseWrapper responseWrapper = new DumpResponseWrapper((HttpServletResponse) response);
dumpBytes("request", requestWrapper.getBytes());
chain.doFilter(requestWrapper, responseWrapper);
dumpBytes("response", responseWrapper.getBytes());
}
public void destroy() {
dumpDir = null;
}
private void dumpBytes(String label, byte[] bytes) {
StringBuilder hexSb = new StringBuilder();
StringBuilder charSb = new StringBuilder();
for (int i = 0; i < bytes.length; i++) {
int b = bytes[i] & 0xFF;
if (hexSb.length() > 0) {
hexSb.append(' ');
charSb.append(' ');
}
hexSb.append(HEXS.charAt(b >> 4)).append(HEXS.charAt(b & 0x0F));
if (b >= 0x20 && b <= 0x7e) charSb.append(' ').append((char) b);
else charSb.append("##");
}
log.info("[RAW %s] {\n%s\n%s\n}", label.toUpperCase(), hexSb.toString(), charSb.toString());
if (dumpDir != null) {
File file =
new File(
dumpDir.getPath()
+ File.separator
+ label
+ "_"
+ System.currentTimeMillis()
+ ".amf");
for (int i = 1; i < 100 && file.exists(); i++)
file = new File(file.getAbsolutePath() + "." + i);
OutputStream os = null;
try {
os = new FileOutputStream(file);
os.write(bytes);
} catch (Exception e) {
log.error(e, "Could not write dump file: %s", file);
} finally {
if (os != null)
try {
os.close();
} catch (Exception e) {
}
}
}
}
class DumpRequestWrapper extends HttpServletRequestWrapper {
private byte[] bytes = null;
public DumpRequestWrapper(HttpServletRequest request) throws IOException {
super(request);
setCharacterEncoding("UTF-8");
InputStream is = null;
try {
is = request.getInputStream();
ByteArrayOutputStream out = new ByteArrayOutputStream(128);
for (int b = is.read(); b != -1; b = is.read()) out.write(b);
this.bytes = out.toByteArray();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
return new ServletInputStream() {
@Override
public int read() throws IOException {
return bais.read();
}
};
}
public byte[] getBytes() {
return bytes;
}
}
class DumpResponseWrapper extends HttpServletResponseWrapper {
private ByteArrayOutputStream baos = new ByteArrayOutputStream(256);
private ServletOutputStream out = null;
public DumpResponseWrapper(HttpServletResponse response) throws IOException {
super(response);
this.out = response.getOutputStream();
}
@Override
public ServletOutputStream getOutputStream() throws IOException {
return new ServletOutputStream() {
@Override
public void write(int b) throws IOException {
baos.write(b);
out.write(b);
}
};
}
public byte[] getBytes() {
return baos.toByteArray();
}
}
}
/** @author Franck WOLFF */
public class GraniteConfig
implements ConvertersConfig,
AliasRegistryConfig,
AMF3Config,
ExternalizersConfig,
ScannedItemHandler {
public enum JMF_EXTENSIONS_MODE {
PREPPEND,
APPEND,
REPLACE
}
///////////////////////////////////////////////////////////////////////////
// Static fields.
private static final Logger log = Logger.getLogger(GraniteConfig.class);
private static final String GRANITE_CONFIG_PUBLIC_ID =
"-//Granite Data Services//DTD granite-config internal//EN";
private static final String GRANITE_CONFIG_PROPERTIES = "META-INF/granite-config.properties";
final ExternalizerFactory EXTERNALIZER_FACTORY = new ExternalizerFactory();
private static final Externalizer LONG_EXTERNALIZER = new LongExternalizer();
private static final Externalizer BIGINTEGER_EXTERNALIZER = new BigIntegerExternalizer();
private static final Externalizer BIGDECIMAL_EXTERNALIZER = new BigDecimalExternalizer();
private static final Externalizer MAP_EXTERNALIZER = new MapExternalizer();
final ActionScriptClassDescriptorFactory ASC_DESCRIPTOR_FACTORY =
new ActionScriptClassDescriptorFactory();
final JavaClassDescriptorFactory JC_DESCRIPTOR_FACTORY = new JavaClassDescriptorFactory();
final TideComponentMatcherFactory TIDE_COMPONENT_MATCHER_FACTORY =
new TideComponentMatcherFactory();
///////////////////////////////////////////////////////////////////////////
// Instance fields.
// Should we scan classpath for auto-configured services/externalizers?
private boolean scan = false;
private AliasRegistry aliasRegistry = new DefaultAliasRegistry();
private String MBeanContextName = null;
// Custom AMF3 (De)Serializer configuration.
private Constructor<AMF3Serializer> amf3SerializerConstructor = null;
private Constructor<AMF3Deserializer> amf3DeserializerConstructor = null;
private AMF3DeserializerSecurizer amf3DeserializerSecurizer = null;
// Custom AMF3 message interceptor configuration.
private AMF3MessageInterceptor amf3MessageInterceptor = null;
// Converters configuration.
private List<Class<? extends Converter>> converterClasses =
new ArrayList<Class<? extends Converter>>();
private Converters converters = null;
// MethodMatcher configuration.
private MethodMatcher methodMatcher = new DefaultMethodMatcher();
// Invocation listener configuration.
private ServiceInvocationListener invocationListener = null;
// Instantiators configuration.
private final Map<String, String> instantiators = new HashMap<String, String>();
// Class getter configuration.
private ClassGetter classGetter = new DefaultClassGetter();
private boolean classGetterSet = false;
// Externalizers configuration.
private XMap externalizersConfiguration = null;
private final List<Externalizer> scannedExternalizers = new ArrayList<Externalizer>();
private final ConcurrentHashMap<String, Externalizer> externalizersByType =
new ConcurrentHashMap<String, Externalizer>();
private final Map<String, String> externalizersByInstanceOf = new HashMap<String, String>();
private final Map<String, String> externalizersByAnnotatedWith = new HashMap<String, String>();
// JMF extended codecs.
private JMF_EXTENSIONS_MODE jmfExtendedCodecsMode = JMF_EXTENSIONS_MODE.APPEND;
private final List<ExtendedObjectCodec> jmfExtendedCodecs = new ArrayList<ExtendedObjectCodec>();
// JMF default stored strings.
private JMF_EXTENSIONS_MODE jmfDefaultStoredStringsMode = JMF_EXTENSIONS_MODE.APPEND;
private final List<String> jmfDefaultStoredStrings = new ArrayList<String>();
// JMF reflection.
private Reflection jmfReflection = null;
// JMF
private SharedContext sharedContext;
// Java descriptors configuration.
private final ConcurrentHashMap<String, JavaClassDescriptor> javaDescriptorsCache =
new ConcurrentHashMap<String, JavaClassDescriptor>();
private final ConcurrentHashMap<String, Class<? extends JavaClassDescriptor>>
javaDescriptorsByType = new ConcurrentHashMap<String, Class<? extends JavaClassDescriptor>>();
private final Map<String, String> javaDescriptorsByInstanceOf = new HashMap<String, String>();
// AS3 descriptors configuration.
private final ConcurrentHashMap<String, Class<? extends ActionScriptClassDescriptor>>
as3DescriptorsByType =
new ConcurrentHashMap<String, Class<? extends ActionScriptClassDescriptor>>();
private final Map<String, String> as3DescriptorsByInstanceOf = new HashMap<String, String>();
// Exception converters
private final List<ExceptionConverter> exceptionConverters = new ArrayList<ExceptionConverter>();
// Tide-enabled Components configuration.
private final ConcurrentHashMap<String, Object[]> enabledTideComponentsByName =
new ConcurrentHashMap<String, Object[]>();
private final ConcurrentHashMap<String, Object[]> disabledTideComponentsByName =
new ConcurrentHashMap<String, Object[]>();
private final List<TideComponentMatcher> tideComponentMatchers =
new ArrayList<TideComponentMatcher>();
// Security service configuration.
private SecurityService securityService = null;
// MessageSelector configuration.
private Constructor<?> messageSelectorConstructor;
// Gravity configuration.
private XMap gravityConfig;
// Clustering
private DistributedDataFactory distributedDataFactory;
///////////////////////////////////////////////////////////////////////////
// Constructor.
public GraniteConfig(
String stdConfig,
InputStream customConfigIs,
Configuration configuration,
String MBeanContextName)
throws IOException, SAXException {
try {
amf3SerializerConstructor =
TypeUtil.getConstructor(AMF3Serializer.class, new Class<?>[] {OutputStream.class});
amf3DeserializerConstructor =
TypeUtil.getConstructor(AMF3Deserializer.class, new Class<?>[] {InputStream.class});
} catch (Exception e) {
throw new GraniteConfigException("Could not get constructor for AMF3 (de)serializers", e);
}
this.MBeanContextName = MBeanContextName;
ClassLoader loader = GraniteConfig.class.getClassLoader();
final ByteArrayInputStream dtd =
StreamUtil.getResourceAsStream("org/granite/config/granite-config.dtd", loader);
final EntityResolver resolver =
new EntityResolver() {
public InputSource resolveEntity(String publicId, String systemId)
throws SAXException, IOException {
if (GRANITE_CONFIG_PUBLIC_ID.equals(publicId)) {
dtd.reset();
InputSource source = new InputSource(dtd);
source.setPublicId(publicId);
return source;
}
return null;
}
};
// Load standard config.
InputStream is = null;
try {
is = StreamUtil.getResourceAsStream("org/granite/config/granite-config.xml", loader);
XMap doc = new XMap(is, resolver);
forElement(doc, false, null);
} finally {
if (is != null) is.close();
}
if (stdConfig != null) {
try {
is = StreamUtil.getResourceAsStream(stdConfig, loader);
XMap doc = new XMap(is, resolver);
forElement(doc, false, null);
} finally {
if (is != null) is.close();
}
}
// Load custom config (override).
if (customConfigIs != null) {
XMap doc = new XMap(customConfigIs, resolver);
forElement(
doc, true, configuration != null ? configuration.getGraniteConfigProperties() : null);
}
if (amf3DeserializerSecurizer == null)
log.warn(
"You should configure a deserializer securizer in your granite-config.xml file in order to prevent potential security exploits!");
}
///////////////////////////////////////////////////////////////////////////
// Classpath scan initialization.
private void scanConfig(String graniteConfigProperties) {
// if config overriding exists
Scanner scanner =
ScannerFactory.createScanner(
this,
graniteConfigProperties != null ? graniteConfigProperties : GRANITE_CONFIG_PROPERTIES);
try {
scanner.scan();
} catch (Exception e) {
log.error(e, "Could not scan classpath for configuration");
}
}
public boolean handleMarkerItem(ScannedItem item) {
try {
return handleProperties(item.loadAsProperties());
} catch (Exception e) {
log.error(e, "Could not load properties: %s", item);
}
return true;
}
public void handleScannedItem(ScannedItem item) {
if ("class".equals(item.getExtension()) && item.getName().indexOf('$') == -1) {
try {
handleClass(item.loadAsClass());
} catch (NoClassDefFoundError e) {
// Ignore errors with Tide classes depending on Gravity
} catch (LinkageError e) {
// Ignore errors with GraniteDS/Hibernate classes depending on Hibernate 3 when using
// Hibernate 4
} catch (Throwable t) {
log.error(t, "Could not load class: %s", item);
}
}
}
private boolean handleProperties(Properties properties) {
if (properties.getProperty("dependsOn") != null) {
String dependsOn = properties.getProperty("dependsOn");
try {
TypeUtil.forName(dependsOn);
} catch (ClassNotFoundException e) {
// Class not found, skip scan for this package
return true;
}
}
String classGetterName = properties.getProperty("classGetter");
if (!classGetterSet && classGetterName != null) {
try {
classGetter = TypeUtil.newInstance(classGetterName, ClassGetter.class);
} catch (Throwable t) {
log.error(t, "Could not create instance of: %s", classGetterName);
}
}
String amf3MessageInterceptorName = properties.getProperty("amf3MessageInterceptor");
if (amf3MessageInterceptor == null && amf3MessageInterceptorName != null) {
try {
amf3MessageInterceptor =
TypeUtil.newInstance(amf3MessageInterceptorName, AMF3MessageInterceptor.class);
} catch (Throwable t) {
log.error(t, "Could not create instance of: %s", amf3MessageInterceptorName);
}
}
for (Map.Entry<?, ?> me : properties.entrySet()) {
if (me.getKey().toString().startsWith("converter.")) {
String converterName = me.getValue().toString();
try {
converterClasses.add(TypeUtil.forName(converterName, Converter.class));
} catch (Exception e) {
throw new GraniteConfigException(
"Could not get converter class for: " + converterName, e);
}
}
}
return false;
}
private void handleClass(Class<?> clazz) {
if (clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) return;
if (Externalizer.class.isAssignableFrom(clazz)) {
try {
scannedExternalizers.add(TypeUtil.newInstance(clazz, Externalizer.class));
} catch (Exception e) {
log.error(e, "Could not create new instance of: %s", clazz);
}
}
if (ExceptionConverter.class.isAssignableFrom(clazz)) {
try {
exceptionConverters.add(TypeUtil.newInstance(clazz, ExceptionConverter.class));
} catch (Exception e) {
if (!clazz
.getName()
.equals("org.granite.tide.hibernate.HibernateValidatorExceptionConverter")) // GDS-582
log.error(e, "Could not create new instance of: %s", clazz);
}
}
}
///////////////////////////////////////////////////////////////////////////
// Property getters.
public boolean getScan() {
return scan;
}
public boolean isRegisterMBeans() {
return MBeanContextName != null;
}
public String getMBeanContextName() {
return MBeanContextName;
}
public ObjectOutput newAMF3Serializer(OutputStream out) {
try {
return amf3SerializerConstructor.newInstance(new Object[] {out});
} catch (Exception e) {
throw new GraniteConfigException(
"Could not create serializer instance with: " + amf3SerializerConstructor, e);
}
}
public Constructor<?> getAmf3SerializerConstructor() {
return amf3SerializerConstructor;
}
public ObjectInput newAMF3Deserializer(InputStream in) {
try {
return amf3DeserializerConstructor.newInstance(new Object[] {in});
} catch (Exception e) {
throw new GraniteConfigException(
"Could not create deserializer instance with: " + amf3DeserializerConstructor, e);
}
}
public Constructor<?> getAmf3DeserializerConstructor() {
return amf3DeserializerConstructor;
}
public AMF3DeserializerSecurizer getAmf3DeserializerSecurizer() {
return amf3DeserializerSecurizer;
}
public void setAmf3DeserializerSecurizer(AMF3DeserializerSecurizer amf3DeserializerSecurizer) {
this.amf3DeserializerSecurizer = amf3DeserializerSecurizer;
}
public AMF3MessageInterceptor getAmf3MessageInterceptor() {
return amf3MessageInterceptor;
}
public void setAmf3MessageInterceptor(AMF3MessageInterceptor amf3MessageInterceptor) {
this.amf3MessageInterceptor = amf3MessageInterceptor;
}
public Map<String, String> getInstantiators() {
return instantiators;
}
public Converters getConverters() {
return converters;
}
public MethodMatcher getMethodMatcher() {
return methodMatcher;
}
public ServiceInvocationListener getInvocationListener() {
return invocationListener;
}
public String getInstantiator(String type) {
return instantiators.get(type);
}
public ClassGetter getClassGetter() {
return classGetter;
}
public XMap getExternalizersConfiguration() {
return externalizersConfiguration;
}
public void setExternalizersConfiguration(XMap externalizersConfiguration) {
this.externalizersConfiguration = externalizersConfiguration;
}
public Externalizer getExternalizer(String type) {
Externalizer externalizer =
getElementByType(
type,
EXTERNALIZER_FACTORY,
externalizersByType,
externalizersByInstanceOf,
externalizersByAnnotatedWith,
scannedExternalizers);
if (externalizer != null) return externalizer;
if ("java".equals(GraniteContext.getCurrentInstance().getClientType())) {
// Force use of number externalizers when serializing from/to a Java client
if (Long.class.getName().equals(type)) return LONG_EXTERNALIZER;
else if (BigInteger.class.getName().equals(type)) return BIGINTEGER_EXTERNALIZER;
else if (BigDecimal.class.getName().equals(type)) return BIGDECIMAL_EXTERNALIZER;
else {
try {
Class<?> clazz = TypeUtil.forName(type);
if (Map.class.isAssignableFrom(clazz) && !Externalizable.class.isAssignableFrom(clazz))
return MAP_EXTERNALIZER;
} catch (Exception e) {
}
}
}
return null;
}
public void registerExternalizer(Externalizer externalizer) {
scannedExternalizers.add(externalizer);
}
public Map<String, Externalizer> getExternalizersByType() {
return externalizersByType;
}
public Map<String, String> getExternalizersByInstanceOf() {
return externalizersByInstanceOf;
}
public Map<String, String> getExternalizersByAnnotatedWith() {
return externalizersByAnnotatedWith;
}
public List<Externalizer> getScannedExternalizers() {
return scannedExternalizers;
}
public JMF_EXTENSIONS_MODE getJmfExtendedCodecsMode() {
return jmfExtendedCodecsMode;
}
public List<ExtendedObjectCodec> getJmfExtendedCodecs() {
return jmfExtendedCodecs;
}
public JMF_EXTENSIONS_MODE getJmfDefaultStoredStringsMode() {
return jmfDefaultStoredStringsMode;
}
public Reflection getJmfReflection() {
return jmfReflection;
}
public List<String> getJmfDefaultStoredStrings() {
return jmfDefaultStoredStrings;
}
public Class<? extends ActionScriptClassDescriptor> getActionScriptDescriptor(String type) {
return getElementByType(
type, ASC_DESCRIPTOR_FACTORY, as3DescriptorsByType, as3DescriptorsByInstanceOf, null, null);
}
public Map<String, Class<? extends ActionScriptClassDescriptor>> getAs3DescriptorsByType() {
return as3DescriptorsByType;
}
public Map<String, String> getAs3DescriptorsByInstanceOf() {
return as3DescriptorsByInstanceOf;
}
public ConcurrentMap<String, JavaClassDescriptor> getJavaDescriptorsCache() {
return javaDescriptorsCache;
}
public Class<? extends JavaClassDescriptor> getJavaDescriptor(String type) {
return getElementByType(
type,
JC_DESCRIPTOR_FACTORY,
javaDescriptorsByType,
javaDescriptorsByInstanceOf,
null,
null);
}
public Map<String, Class<? extends JavaClassDescriptor>> getJavaDescriptorsByType() {
return javaDescriptorsByType;
}
public Map<String, String> getJavaDescriptorsByInstanceOf() {
return javaDescriptorsByInstanceOf;
}
public boolean isComponentTideEnabled(
String componentName, Set<Class<?>> componentClasses, Object instance) {
return TideComponentMatcherFactory.isComponentTideEnabled(
enabledTideComponentsByName,
tideComponentMatchers,
componentName,
componentClasses,
instance);
}
public boolean isComponentTideDisabled(
String componentName, Set<Class<?>> componentClasses, Object instance) {
return TideComponentMatcherFactory.isComponentTideDisabled(
disabledTideComponentsByName,
tideComponentMatchers,
componentName,
componentClasses,
instance);
}
public List<ExceptionConverter> getExceptionConverters() {
return exceptionConverters;
}
public void registerExceptionConverter(
Class<? extends ExceptionConverter> exceptionConverterClass) {
registerExceptionConverter(exceptionConverterClass, false);
}
public void registerExceptionConverter(
Class<? extends ExceptionConverter> exceptionConverterClass, boolean first) {
for (ExceptionConverter ec : exceptionConverters) {
if (ec.getClass() == exceptionConverterClass) return;
}
try {
ExceptionConverter exceptionConverter =
TypeUtil.newInstance(exceptionConverterClass, ExceptionConverter.class);
if (first) exceptionConverters.add(0, exceptionConverter);
else exceptionConverters.add(exceptionConverter);
} catch (Exception e) {
log.error(e, "Could not instantiate exception converter: %s", exceptionConverterClass);
}
}
public void registerExceptionConverter(ExceptionConverter exceptionConverter, boolean first) {
for (ExceptionConverter ec : exceptionConverters) {
if (ec.getClass() == exceptionConverter.getClass()) return;
}
if (first) exceptionConverters.add(0, exceptionConverter);
else exceptionConverters.add(exceptionConverter);
}
public boolean hasSecurityService() {
return securityService != null;
}
public SecurityService getSecurityService() {
return securityService;
}
public List<TideComponentMatcher> getTideComponentMatchers() {
return tideComponentMatchers;
}
public Map<String, Object[]> getEnabledTideComponentsByName() {
return enabledTideComponentsByName;
}
public Map<String, Object[]> getDisabledTideComponentsByName() {
return disabledTideComponentsByName;
}
public XMap getGravityConfig() {
return gravityConfig;
}
public DistributedDataFactory getDistributedDataFactory() {
return distributedDataFactory;
}
public Constructor<?> getMessageSelectorConstructor() {
return messageSelectorConstructor;
}
public Externalizer setExternalizersByType(String type, String externalizerType) {
return externalizersByType.put(type, EXTERNALIZER_FACTORY.getInstance(externalizerType, this));
}
public String putExternalizersByInstanceOf(String instanceOf, String externalizerType) {
return externalizersByInstanceOf.put(instanceOf, externalizerType);
}
public String putExternalizersByAnnotatedWith(String annotatedWith, String externalizerType) {
return externalizersByAnnotatedWith.put(annotatedWith, externalizerType);
}
///////////////////////////////////////////////////////////////////////////
// Static GraniteConfig loading helpers.
private void forElement(XMap element, boolean custom, String graniteConfigProperties) {
String scan = element.get("@scan");
this.scan = Boolean.TRUE.toString().equals(scan);
loadCustomAMF3Serializer(element, custom);
loadCustomAMF3DeserializerSecurizer(element, custom);
loadCustomAMF3MessageInterceptor(element, custom);
loadCustomConverters(element, custom);
loadCustomMethodMatcher(element, custom);
loadCustomInvocationListener(element, custom);
loadCustomInstantiators(element, custom);
loadCustomClassGetter(element, custom);
loadCustomExternalizers(element, custom);
loadCustomJMFExtendedCodecs(element, custom);
loadCustomJMFDefaultStoredStrings(element, custom);
loadCustomJMFReflection(element, custom);
loadCustomDescriptors(element, custom);
loadCustomExceptionConverters(element, custom);
loadCustomTideComponents(element, custom);
loadCustomSecurity(element, custom);
loadCustomMessageSelector(element, custom);
loadCustomGravity(element, custom);
loadCustomDistributedDataFactory(element, custom);
if (this.scan) scanConfig(graniteConfigProperties);
finishCustomConverters(custom);
}
private void loadCustomAMF3Serializer(XMap element, boolean custom) {
XMap amf3Serializer = element.getOne("amf3-serializer");
if (amf3Serializer != null) {
String type = amf3Serializer.get("@type");
try {
Class<AMF3Serializer> amf3SerializerClass = TypeUtil.forName(type, AMF3Serializer.class);
amf3SerializerConstructor =
TypeUtil.getConstructor(amf3SerializerClass, new Class<?>[] {OutputStream.class});
} catch (Exception e) {
throw new GraniteConfigException(
"Could not get constructor for AMF3 serializer: " + type, e);
}
}
XMap amf3Deserializer = element.getOne("amf3-deserializer");
if (amf3Deserializer != null) {
String type = amf3Deserializer.get("@type");
try {
Class<AMF3Deserializer> amf3DeserializerClass =
TypeUtil.forName(type, AMF3Deserializer.class);
amf3DeserializerConstructor =
TypeUtil.getConstructor(amf3DeserializerClass, new Class<?>[] {InputStream.class});
} catch (Exception e) {
throw new GraniteConfigException(
"Could not get constructor for AMF3 deserializer: " + type, e);
}
}
}
private void loadCustomAMF3DeserializerSecurizer(XMap element, boolean custom) {
XMap securizer = element.getOne("amf3-deserializer-securizer");
if (securizer != null) {
String type = securizer.get("@type");
try {
amf3DeserializerSecurizer = (AMF3DeserializerSecurizer) TypeUtil.newInstance(type);
} catch (Exception e) {
throw new GraniteConfigException(
"Could not construct amf3 deserializer securizer: " + type, e);
}
String param = securizer.get("@param");
try {
amf3DeserializerSecurizer.setParam(param);
} catch (Exception e) {
throw new GraniteConfigException(
"Could not set param of amf3 deserializer securizer: " + type + ", param: " + param, e);
}
}
}
private void loadCustomAMF3MessageInterceptor(XMap element, boolean custom) {
XMap interceptor = element.getOne("amf3-message-interceptor");
if (interceptor != null) {
String type = interceptor.get("@type");
try {
amf3MessageInterceptor = (AMF3MessageInterceptor) TypeUtil.newInstance(type);
} catch (Exception e) {
throw new GraniteConfigException(
"Could not construct amf3 message interceptor: " + type, e);
}
}
}
private void loadCustomDistributedDataFactory(XMap element, boolean custom) {
XMap distributedDataFactory = element.getOne("distributed-data-factory");
if (distributedDataFactory != null) {
String type = distributedDataFactory.get("@type");
try {
this.distributedDataFactory = (DistributedDataFactory) TypeUtil.newInstance(type);
} catch (Exception e) {
throw new GraniteConfigException(
"Could not construct build distributed data factory: " + type, e);
}
}
}
private void loadCustomConverters(XMap element, boolean custom) {
XMap converters = element.getOne("converters");
if (converters != null) {
// Should we override standard config converters?
String override = converters.get("@override");
if (Boolean.TRUE.toString().equals(override)) converterClasses.clear();
int i = 0;
for (XMap converter : converters.getAll("converter")) {
String type = converter.get("@type");
try {
// For custom config, shifts any standard converters to the end of the list...
converterClasses.add(i++, TypeUtil.forName(type, Converter.class));
} catch (Exception e) {
throw new GraniteConfigException("Could not get converter class for: " + type, e);
}
}
}
}
private void finishCustomConverters(boolean custom) {
try {
converters = new Converters(converterClasses);
} catch (Exception e) {
throw new GraniteConfigException("Could not construct new Converters instance", e);
}
// Cleanup...
if (custom) converterClasses = null;
}
private void loadCustomMethodMatcher(XMap element, boolean custom) {
XMap methodMatcher = element.getOne("method-matcher");
if (methodMatcher != null) {
String type = methodMatcher.get("@type");
try {
this.methodMatcher = (MethodMatcher) TypeUtil.newInstance(type);
} catch (Exception e) {
throw new GraniteConfigException("Could not construct method matcher: " + type, e);
}
}
}
private void loadCustomInvocationListener(XMap element, boolean custom) {
XMap invocationListener = element.getOne("invocation-listener");
if (invocationListener != null) {
String type = invocationListener.get("@type");
try {
this.invocationListener = (ServiceInvocationListener) TypeUtil.newInstance(type);
} catch (Exception e) {
throw new GraniteConfigException(
"Could not instantiate ServiceInvocationListener: " + type, e);
}
}
}
private void loadCustomInstantiators(XMap element, boolean custom) {
XMap instantiators = element.getOne("instantiators");
if (instantiators != null) {
for (XMap instantiator : instantiators.getAll("instantiator"))
this.instantiators.put(instantiator.get("@type"), instantiator.get("."));
}
}
private void loadCustomClassGetter(XMap element, boolean custom) {
XMap classGetter = element.getOne("class-getter");
if (classGetter != null) {
String type = classGetter.get("@type");
try {
this.classGetter = (ClassGetter) TypeUtil.newInstance(type);
classGetterSet = true;
} catch (Exception e) {
throw new GraniteConfigException("Could not instantiate ClassGetter: " + type, e);
}
}
}
private void loadCustomExternalizers(XMap element, boolean custom) {
externalizersConfiguration = element.getOne("externalizers/configuration");
for (XMap externalizer : element.getAll("externalizers/externalizer")) {
String externalizerType = externalizer.get("@type");
for (XMap include : externalizer.getAll("include")) {
String type = include.get("@type");
if (type != null)
externalizersByType.put(type, EXTERNALIZER_FACTORY.getInstance(externalizerType, this));
else {
String instanceOf = include.get("@instance-of");
if (instanceOf != null) externalizersByInstanceOf.put(instanceOf, externalizerType);
else {
String annotatedWith = include.get("@annotated-with");
if (annotatedWith == null)
throw new GraniteConfigException(
"Element 'include' has no attribute 'type', 'instance-of' or 'annotated-with'");
externalizersByAnnotatedWith.put(annotatedWith, externalizerType);
}
}
}
}
}
private void loadCustomJMFExtendedCodecs(XMap element, boolean custom) {
String jmfExtendedCodecsMode = element.get("jmf-extended-codecs/@mode");
if (jmfExtendedCodecsMode != null) {
try {
this.jmfExtendedCodecsMode =
JMF_EXTENSIONS_MODE.valueOf(jmfExtendedCodecsMode.toLowerCase());
} catch (Exception e) {
throw new GraniteConfigException(
"Illegal JMF extended codecs mode: " + jmfExtendedCodecsMode, e);
}
}
for (XMap codec : element.getAll("jmf-extended-codecs/jmf-extended-codec")) {
String codecType = codec.get("@type");
try {
jmfExtendedCodecs.add((ExtendedObjectCodec) TypeUtil.newInstance(codecType));
} catch (Exception e) {
throw new GraniteConfigException(
"Could not instantiate JMF extended codec: " + codecType, e);
}
}
}
private void loadCustomJMFDefaultStoredStrings(XMap element, boolean custom) {
String jmfDefaultStoredStringsMode = element.get("jmf-default-stored-strings/@mode");
if (jmfDefaultStoredStringsMode != null) {
try {
this.jmfDefaultStoredStringsMode =
JMF_EXTENSIONS_MODE.valueOf(jmfDefaultStoredStringsMode.toLowerCase());
} catch (Exception e) {
throw new GraniteConfigException(
"Illegal JMF default stored strings mode: " + jmfDefaultStoredStringsMode, e);
}
}
for (XMap codec : element.getAll("jmf-default-stored-strings/jmf-default-stored-string"))
jmfDefaultStoredStrings.add(codec.get("@value"));
}
private void loadCustomJMFReflection(XMap element, boolean custom) {
String jmfReflection = element.get("jmf-reflection/@type");
if (jmfReflection == null)
this.jmfReflection = new Reflection(Thread.currentThread().getContextClassLoader());
else {
try {
this.jmfReflection = (Reflection) TypeUtil.newInstance(jmfReflection);
} catch (Exception e) {
throw new GraniteConfigException(
"Could not instantiate JMF reflection: " + jmfReflection, e);
}
}
}
/**
* Read custom class descriptors. Descriptor must have 'type' or 'instanceof' attribute and one of
* 'java' or 'as3' attributes specified.
*/
private void loadCustomDescriptors(XMap element, boolean custom) {
for (XMap descriptor : element.getAll("descriptors/descriptor")) {
String type = descriptor.get("@type");
if (type != null) {
String java = descriptor.get("@java");
String as3 = descriptor.get("@as3");
if (java == null && as3 == null)
throw new GraniteConfigException(
"Element 'descriptor' has no attributes 'java' or 'as3'\n" + descriptor);
if (java != null)
javaDescriptorsByType.put(type, JC_DESCRIPTOR_FACTORY.getInstance(java, this));
if (as3 != null)
as3DescriptorsByType.put(type, ASC_DESCRIPTOR_FACTORY.getInstance(as3, this));
} else {
String instanceOf = descriptor.get("@instance-of");
if (instanceOf == null)
throw new GraniteConfigException(
"Element 'descriptor' has no attribute 'type' or 'instance-of'\n" + descriptor);
String java = descriptor.get("@java");
String as3 = descriptor.get("@as3");
if (java == null && as3 == null) {
throw new GraniteConfigException(
"Element 'descriptor' has no attributes 'java' or 'as3' in:\n" + descriptor);
}
if (java != null) javaDescriptorsByInstanceOf.put(instanceOf, java);
if (as3 != null) as3DescriptorsByInstanceOf.put(instanceOf, as3);
}
}
}
public void setAliasRegistry(AliasRegistry aliasRegistry) {
this.aliasRegistry = aliasRegistry;
}
public AliasRegistry getAliasRegistry() {
return aliasRegistry;
}
public void setSharedContext(SharedContext sharedContext) {
this.sharedContext = sharedContext;
}
public SharedContext getSharedContext() {
return sharedContext;
}
/** Read custom class exception converters Converter must have 'type' attribute */
private void loadCustomExceptionConverters(XMap element, boolean custom) {
for (XMap exceptionConverter : element.getAll("exception-converters/exception-converter")) {
String type = exceptionConverter.get("@type");
ExceptionConverter converter = null;
try {
converter = (ExceptionConverter) TypeUtil.newInstance(type);
exceptionConverters.add(converter);
} catch (Exception e) {
throw new GraniteConfigException("Could not construct exception converter: " + type, e);
}
}
}
private void loadCustomTideComponents(XMap element, boolean custom) {
for (XMap component : element.getAll("tide-components/tide-component")) {
boolean disabled = Boolean.TRUE.toString().equals(component.get("@disabled"));
String type = component.get("@type");
if (type != null)
tideComponentMatchers.add(TIDE_COMPONENT_MATCHER_FACTORY.getTypeMatcher(type, disabled));
else {
String name = component.get("@name");
if (name != null)
tideComponentMatchers.add(TIDE_COMPONENT_MATCHER_FACTORY.getNameMatcher(name, disabled));
else {
String instanceOf = component.get("@instance-of");
if (instanceOf != null)
tideComponentMatchers.add(
TIDE_COMPONENT_MATCHER_FACTORY.getInstanceOfMatcher(instanceOf, disabled));
else {
String annotatedWith = component.get("@annotated-with");
if (annotatedWith == null)
throw new GraniteConfigException(
"Element 'component' has no attribute 'type', 'name', 'instance-of' or 'annotated-with'");
tideComponentMatchers.add(
TIDE_COMPONENT_MATCHER_FACTORY.getAnnotatedWithMatcher(annotatedWith, disabled));
}
}
}
}
}
private void loadCustomSecurity(XMap element, boolean custom) {
XMap security = element.getOne("security");
if (security != null) {
String type = security.get("@type");
try {
securityService = (SecurityService) TypeUtil.newInstance(type);
} catch (Exception e) {
throw new GraniteConfigException("Could not instantiate SecurityService: " + type, e);
}
Map<String, String> params = new HashMap<String, String>();
for (XMap param : security.getAll("param")) {
String name = param.get("@name");
String value = param.get("@value");
params.put(name, value);
}
try {
securityService.configure(params);
} catch (Exception e) {
throw new GraniteConfigException(
"Could not configure SecurityService " + type + " with: " + params, e);
}
}
}
public void setSecurityService(SecurityService securityService) {
this.securityService = securityService;
}
private void loadCustomMessageSelector(XMap element, boolean custom) {
XMap selector = element.getOne("message-selector");
if (selector != null) {
String type = selector.get("@type");
try {
messageSelectorConstructor = TypeUtil.getConstructor(type, new Class<?>[] {String.class});
} catch (Exception e) {
throw new GraniteConfigException("Could not construct message selector: " + type, e);
}
}
}
private void loadCustomGravity(XMap element, boolean custom) {
gravityConfig = element.getOne("gravity");
}
///////////////////////////////////////////////////////////////////////////
// Other helpers.
@SuppressWarnings("unchecked")
private <T, C extends Config> T getElementByType(
String type,
ConfigurableFactory<T, C> factory,
ConcurrentHashMap<String, T> elementsByType,
Map<String, String> elementsByInstanceOf,
Map<String, String> elementsByAnnotatedWith,
List<T> scannedConfigurables) {
// This NULL object is a Java null placeholder: ConcurrentHashMap doesn't allow
// null values...
final T NULL = factory.getNullInstance();
T element = elementsByType.get(type);
if (element != null) return (NULL == element ? null : element);
element = NULL;
Class<?> typeClass = null;
try {
typeClass = TypeUtil.forName(type);
} catch (Exception e) {
throw new GraniteConfigException("Could not load class: " + type, e);
}
if (elementsByAnnotatedWith != null && NULL == element) {
for (Map.Entry<String, String> entry : elementsByAnnotatedWith.entrySet()) {
String annotation = entry.getKey();
try {
Class<Annotation> annotationClass = TypeUtil.forName(annotation, Annotation.class);
if (typeClass.isAnnotationPresent(annotationClass)) {
element = factory.getInstance(entry.getValue(), (C) this);
break;
}
} catch (Exception e) {
throw new GraniteConfigException("Could not load class: " + annotation, e);
}
}
}
if (elementsByInstanceOf != null && NULL == element) {
for (Map.Entry<String, String> entry : elementsByInstanceOf.entrySet()) {
String instanceOf = entry.getKey();
try {
Class<?> instanceOfClass = TypeUtil.forName(instanceOf);
if (instanceOfClass.isAssignableFrom(typeClass)) {
element = factory.getInstance(entry.getValue(), (C) this);
break;
}
} catch (Exception e) {
throw new GraniteConfigException("Could not load class: " + instanceOf, e);
}
}
}
if (NULL == element)
element = factory.getInstanceForBean(scannedConfigurables, typeClass, (C) this);
T previous = elementsByType.putIfAbsent(type, element);
if (previous != null) element = previous;
return (NULL == element ? null : element);
}
}
/** @author Franck WOLFF */
public abstract class AbstractChannel implements Channel {
///////////////////////////////////////////////////////////////////////////
// Fields.
private static final Logger log = Logger.getLogger(AbstractChannel.class);
protected final String id;
protected final ServletConfig servletConfig;
protected final ConcurrentMap<String, Subscription> subscriptions =
new ConcurrentHashMap<String, Subscription>();
protected LinkedList<AsyncPublishedMessage> publishedQueue =
new LinkedList<AsyncPublishedMessage>();
protected final Lock publishedQueueLock = new ReentrantLock();
protected LinkedList<AsyncMessage> receivedQueue = new LinkedList<AsyncMessage>();
protected final Lock receivedQueueLock = new ReentrantLock();
protected final AsyncPublisher publisher;
protected final AsyncReceiver receiver;
///////////////////////////////////////////////////////////////////////////
// Constructor.
protected AbstractChannel(ServletConfig servletConfig, GravityConfig gravityConfig, String id) {
if (id == null) throw new NullPointerException("id cannot be null");
this.id = id;
this.servletConfig = servletConfig;
this.publisher = new AsyncPublisher(this);
this.receiver = new AsyncReceiver(this);
}
///////////////////////////////////////////////////////////////////////////
// Abstract protected method.
protected abstract boolean hasAsyncHttpContext();
protected abstract AsyncHttpContext acquireAsyncHttpContext();
protected abstract void releaseAsyncHttpContext(AsyncHttpContext context);
///////////////////////////////////////////////////////////////////////////
// Channel interface implementation.
public String getId() {
return id;
}
public Gravity getGravity() {
return GravityManager.getGravity(getServletContext());
}
public Subscription addSubscription(
String destination, String subTopicId, String subscriptionId, boolean noLocal) {
Subscription subscription =
new Subscription(this, destination, subTopicId, subscriptionId, noLocal);
Subscription present = subscriptions.putIfAbsent(subscriptionId, subscription);
return (present != null ? present : subscription);
}
public Collection<Subscription> getSubscriptions() {
return subscriptions.values();
}
public Subscription removeSubscription(String subscriptionId) {
return subscriptions.remove(subscriptionId);
}
public void publish(AsyncPublishedMessage message) throws MessagePublishingException {
if (message == null) throw new NullPointerException("message cannot be null");
publishedQueueLock.lock();
try {
publishedQueue.add(message);
} finally {
publishedQueueLock.unlock();
}
publisher.queue(getGravity());
}
public boolean hasPublishedMessage() {
publishedQueueLock.lock();
try {
return !publishedQueue.isEmpty();
} finally {
publishedQueueLock.unlock();
}
}
public boolean runPublish() {
LinkedList<AsyncPublishedMessage> publishedCopy = null;
publishedQueueLock.lock();
try {
if (publishedQueue.isEmpty()) return false;
publishedCopy = publishedQueue;
publishedQueue = new LinkedList<AsyncPublishedMessage>();
} finally {
publishedQueueLock.unlock();
}
for (AsyncPublishedMessage message : publishedCopy) {
try {
message.publish(this);
} catch (Exception e) {
log.error(e, "Error while trying to publish message: %s", message);
}
}
return true;
}
public void receive(AsyncMessage message) throws MessageReceivingException {
if (message == null) throw new NullPointerException("message cannot be null");
Gravity gravity = getGravity();
receivedQueueLock.lock();
try {
if (receivedQueue.size() + 1 > gravity.getGravityConfig().getMaxMessagesQueuedPerChannel())
throw new MessageReceivingException(
message, "Could not queue message (channel's queue is full) for channel: " + this);
receivedQueue.add(message);
} finally {
receivedQueueLock.unlock();
}
if (hasAsyncHttpContext()) receiver.queue(gravity);
}
public boolean hasReceivedMessage() {
receivedQueueLock.lock();
try {
return !receivedQueue.isEmpty();
} finally {
receivedQueueLock.unlock();
}
}
public boolean runReceive() {
return runReceived(null);
}
public boolean runReceived(AsyncHttpContext asyncHttpContext) {
boolean httpAsParam = (asyncHttpContext != null);
LinkedList<AsyncMessage> messages = null;
OutputStream os = null;
try {
receivedQueueLock.lock();
try {
// Do we have any pending messages?
if (receivedQueue.isEmpty()) return false;
// Do we have a valid http context?
if (asyncHttpContext == null) {
asyncHttpContext = acquireAsyncHttpContext();
if (asyncHttpContext == null) return false;
}
// Both conditions are ok, get all pending messages.
messages = receivedQueue;
receivedQueue = new LinkedList<AsyncMessage>();
} finally {
receivedQueueLock.unlock();
}
HttpServletRequest request = asyncHttpContext.getRequest();
HttpServletResponse response = asyncHttpContext.getResponse();
// Set response messages correlation ids to connect request message id.
String correlationId = asyncHttpContext.getConnectMessage().getMessageId();
AsyncMessage[] messagesArray = new AsyncMessage[messages.size()];
int i = 0;
for (AsyncMessage message : messages) {
message.setCorrelationId(correlationId);
messagesArray[i++] = message;
}
// Setup serialization context (thread local)
Gravity gravity = getGravity();
GraniteContext context =
HttpGraniteContext.createThreadIntance(
gravity.getGraniteConfig(), gravity.getServicesConfig(), null, request, response);
((AMFContextImpl) context.getAMFContext())
.setCurrentAmf3Message(asyncHttpContext.getConnectMessage());
// Write messages to response output stream.
response.setStatus(HttpServletResponse.SC_OK);
response.setContentType(AMF0Message.CONTENT_TYPE);
response.setDateHeader("Expire", 0L);
response.setHeader("Cache-Control", "no-store");
os = response.getOutputStream();
ObjectOutput amf3Serializer = context.getGraniteConfig().newAMF3Serializer(os);
log.debug("<< [MESSAGES for channel=%s] %s", this, messagesArray);
amf3Serializer.writeObject(messagesArray);
os.flush();
response.flushBuffer();
return true; // Messages were delivered, http context isn't valid anymore.
} catch (IOException e) {
log.warn(e, "Could not send messages to channel: %s (retrying later)", this);
GravityConfig gravityConfig = getGravity().getGravityConfig();
if (messages != null && gravityConfig.isRetryOnError()) {
receivedQueueLock.lock();
try {
if (receivedQueue.size() + messages.size()
> gravityConfig.getMaxMessagesQueuedPerChannel()) {
log.warn(
"Channel %s has reached its maximum queue capacity %s (throwing %s messages)",
this, gravityConfig.getMaxMessagesQueuedPerChannel(), messages.size());
} else receivedQueue.addAll(0, messages);
} finally {
receivedQueueLock.unlock();
}
}
return true; // Messages weren't delivered, but http context isn't valid anymore.
} finally {
// Cleanup serialization context (thread local)
try {
GraniteContext.release();
} catch (Exception e) {
// should never happen...
}
// Close output stream.
try {
if (os != null) {
try {
os.close();
} catch (IOException e) {
log.warn(e, "Could not close output stream (ignored)");
}
}
} finally {
// Cleanup http context (only if this method wasn't explicitly called with a non null
// AsyncHttpContext from the servlet).
if (!httpAsParam) releaseAsyncHttpContext(asyncHttpContext);
}
}
}
public void destroy() {
Gravity gravity = getGravity();
gravity.cancel(publisher);
gravity.cancel(receiver);
subscriptions.clear();
}
///////////////////////////////////////////////////////////////////////////
// Protected utilities.
protected boolean queueReceiver() {
if (hasReceivedMessage()) {
receiver.queue(getGravity());
return true;
}
return false;
}
protected ServletConfig getServletConfig() {
return servletConfig;
}
protected ServletContext getServletContext() {
return servletConfig.getServletContext();
}
///////////////////////////////////////////////////////////////////////////
// Object overwritten methods.
@Override
public boolean equals(Object obj) {
return (obj instanceof Channel && id.equals(((Channel) obj).getId()));
}
@Override
public int hashCode() {
return id.hashCode();
}
@Override
public String toString() {
return getClass().getName() + " {id=" + id + ", subscriptions=" + subscriptions.values() + "}";
}
}
