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 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);
}
}
}
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;
}
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;
}
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;
}
@Invalidate
public void stop() {
log.debug("Stop OSGiServiceSimple: " + toString());
if (servicesConfig != null) {
servicesConfig.removeService(id);
started = false;
}
}
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);
}
@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");
}
}
@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 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;
}
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;
}
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;
}
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();
}
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 <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;
}
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);
}
}
}
/* (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);
}
}
@Override
protected void beforeInvocation(ServiceInvocationContext context) {
log.debug("Before Invocation");
}
@Override
protected Object afterInvocation(ServiceInvocationContext context, Object result) {
log.debug("After Invocation");
return result;
}
public SpringSecurityService() {
log.debug("Starting Spring Security Service!");
}
public void configure(Map<String, String> params) {
log.debug("Configuring with parameters (NOOP) %s: ", params);
}
