Java tutorial
/* * Copyright 2014 Matthias Einwag * * The jawampa authors license this file to you under the Apache License, * version 2.0 (the "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. */ package ws.wamp.jawampa; import java.util.ArrayList; import java.util.EnumMap; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.RejectedExecutionException; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ThreadFactory; import rx.Observable; import rx.Scheduler; import rx.schedulers.Schedulers; import rx.subjects.AsyncSubject; import ws.wamp.jawampa.WampMessages.*; import ws.wamp.jawampa.connection.ICompletionCallback; import ws.wamp.jawampa.connection.IConnectionController; import ws.wamp.jawampa.connection.IWampConnection; import ws.wamp.jawampa.connection.IWampConnectionAcceptor; import ws.wamp.jawampa.connection.IWampConnectionFuture; import ws.wamp.jawampa.connection.IWampConnectionListener; import ws.wamp.jawampa.connection.IWampConnectionPromise; import ws.wamp.jawampa.connection.QueueingConnectionController; import ws.wamp.jawampa.connection.WampConnectionPromise; import ws.wamp.jawampa.internal.IdGenerator; import ws.wamp.jawampa.internal.IdValidator; import ws.wamp.jawampa.internal.RealmConfig; import ws.wamp.jawampa.internal.UriValidator; import ws.wamp.jawampa.internal.Version; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.ObjectNode; /** * The {@link WampRouter} provides Dealer and Broker functionality for the WAMP * protocol.<br> */ public class WampRouter { final static Set<WampRoles> SUPPORTED_CLIENT_ROLES; static { SUPPORTED_CLIENT_ROLES = new HashSet<WampRoles>(); SUPPORTED_CLIENT_ROLES.add(WampRoles.Caller); SUPPORTED_CLIENT_ROLES.add(WampRoles.Callee); SUPPORTED_CLIENT_ROLES.add(WampRoles.Publisher); SUPPORTED_CLIENT_ROLES.add(WampRoles.Subscriber); } /** Represents a realm that is exposed through the router */ static class Realm { final RealmConfig config; final ObjectNode welcomeDetails; final Map<Long, ClientHandler> channelsBySessionId = new HashMap<Long, ClientHandler>(); final Map<String, Procedure> procedures = new HashMap<String, Procedure>(); // Fields that are used for implementing subscription functionality final EnumMap<SubscriptionFlags, Map<String, Subscription>> subscriptionsByFlags = new EnumMap<SubscriptionFlags, Map<String, Subscription>>( SubscriptionFlags.class); final Map<Long, Subscription> subscriptionsById = new HashMap<Long, Subscription>(); long lastUsedSubscriptionId = IdValidator.MIN_VALID_ID; public Realm(RealmConfig config) { this.config = config; subscriptionsByFlags.put(SubscriptionFlags.Exact, new HashMap<String, Subscription>()); subscriptionsByFlags.put(SubscriptionFlags.Prefix, new HashMap<String, Subscription>()); subscriptionsByFlags.put(SubscriptionFlags.Wildcard, new HashMap<String, Subscription>()); // Expose the roles that are configured for the realm ObjectMapper objectMapper = new ObjectMapper(); welcomeDetails = objectMapper.createObjectNode(); welcomeDetails.put("agent", Version.getVersion()); ObjectNode routerRoles = welcomeDetails.putObject("roles"); for (WampRoles role : config.roles) { ObjectNode roleNode = routerRoles.putObject(role.toString()); if (role == WampRoles.Publisher) { ObjectNode featuresNode = roleNode.putObject("features"); featuresNode.put("publisher_exclusion", true); } else if (role == WampRoles.Subscriber) { ObjectNode featuresNode = roleNode.putObject("features"); featuresNode.put("pattern_based_subscription", true); } } } void includeChannel(ClientHandler channel, long sessionId, Set<WampRoles> roles) { channel.realm = this; channel.sessionId = sessionId; channel.roles = roles; channelsBySessionId.put(sessionId, channel); } void removeChannel(ClientHandler channel, boolean removeFromList) { if (channel.realm == null) return; if (channel.subscriptionsById != null) { // Remove the channels subscriptions from our subscription table for (Subscription sub : channel.subscriptionsById.values()) { sub.subscribers.remove(channel); if (sub.subscribers.isEmpty()) { // Subscription is no longer used by any client subscriptionsByFlags.get(sub.flags).remove(sub.topic); subscriptionsById.remove(sub.subscriptionId); } } channel.subscriptionsById.clear(); channel.subscriptionsById = null; } if (channel.providedProcedures != null) { // Remove the clients procedures from our procedure table for (Procedure proc : channel.providedProcedures.values()) { // Clear all pending invocations and thereby inform other clients // that the proc has gone away for (Invocation invoc : proc.pendingCalls) { if (invoc.caller.state != RouterHandlerState.Open) continue; ErrorMessage errMsg = new ErrorMessage(CallMessage.ID, invoc.callRequestId, null, ApplicationError.NO_SUCH_PROCEDURE, null, null); invoc.caller.controller.sendMessage(errMsg, IWampConnectionPromise.Empty); } proc.pendingCalls.clear(); // Remove the procedure from the realm procedures.remove(proc.procName); } channel.providedProcedures = null; channel.pendingInvocations = null; } if (removeFromList) { channelsBySessionId.remove(channel.sessionId); } channel.realm = null; channel.roles.clear(); channel.roles = null; channel.sessionId = 0; } } static class Procedure { final String procName; final ClientHandler provider; final long registrationId; final List<Invocation> pendingCalls = new ArrayList<WampRouter.Invocation>(); public Procedure(String name, ClientHandler provider, long registrationId) { this.procName = name; this.provider = provider; this.registrationId = registrationId; } } static class Invocation { Procedure procedure; long callRequestId; ClientHandler caller; long invocationRequestId; } static class Subscription { final String topic; final SubscriptionFlags flags; final String components[]; // non-null only for wildcard type final long subscriptionId; final Set<ClientHandler> subscribers; public Subscription(String topic, SubscriptionFlags flags, long subscriptionId) { this.topic = topic; this.flags = flags; this.components = flags == SubscriptionFlags.Wildcard ? topic.split("\\.", -1) : null; this.subscriptionId = subscriptionId; this.subscribers = new HashSet<ClientHandler>(); } } final ScheduledExecutorService eventLoop; final Scheduler scheduler; final ObjectMapper objectMapper = new ObjectMapper(); boolean isDisposed = false; AsyncSubject<Void> closedFuture = AsyncSubject.create(); final Map<String, Realm> realms; final Set<IConnectionController> idleChannels; /** The number of connections that have to be closed. This is important for shutdown */ int connectionsToClose = 0; /** * Returns the (singlethreaded) EventLoop on which this router is running.<br> * This is required by other Netty ChannelHandlers that want to forward messages * to the router. */ public ScheduledExecutorService eventLoop() { return eventLoop; } /** * Returns the Jackson {@link ObjectMapper} that is used for JSON serialization, * deserialization and object mapping by this router. */ public ObjectMapper objectMapper() { return objectMapper; } WampRouter(Map<String, RealmConfig> realms) { // Populate the realms from the configuration this.realms = new HashMap<String, Realm>(); for (Map.Entry<String, RealmConfig> e : realms.entrySet()) { Realm info = new Realm(e.getValue()); this.realms.put(e.getKey(), info); } // Create an eventloop and the RX scheduler on top of it this.eventLoop = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() { @Override public Thread newThread(Runnable r) { Thread t = new Thread(r, "WampRouterEventLoop"); t.setDaemon(true); return t; } }); this.scheduler = Schedulers.from(eventLoop); idleChannels = new HashSet<IConnectionController>(); } /** * Tries to schedule a runnable on the underlying executor.<br> * Rejected executions will be suppressed.<br> * This is useful for cases when the clients EventLoop is shut down before * the EventLoop of the underlying connection. * * @param action The action to schedule. */ void tryScheduleAction(Runnable action) { try { eventLoop.submit(action); } catch (RejectedExecutionException e) { } } private ICompletionCallback<Void> onConnectionClosed = new ICompletionCallback<Void>() { @Override public void onCompletion(IWampConnectionFuture<Void> future) { tryScheduleAction(new Runnable() { @Override public void run() { connectionsToClose -= 1; if (isDisposed && connectionsToClose == 0) { eventLoop.shutdown(); closedFuture.onNext(null); closedFuture.onCompleted(); } } }); } }; /** * Increases the number of connections to close and starts to asynchronously * close it. When this has happened {@link WampRouter#onConnectionClosed} will be called. */ private void closeConnection(IConnectionController controller, boolean sendRemaining) { connectionsToClose += 1; WampConnectionPromise<Void> promise = new WampConnectionPromise<Void>(onConnectionClosed, null); controller.close(sendRemaining, promise); } /** * Closes the router.<br> * This will shut down all realm that are registered to the router. * All connections to clients on the realm will be closed.<br> * However pending calls will be completed through an error message * as far as possible. * @return Returns an observable that completes when the router is completely shut down. */ public Observable<Void> close() { if (eventLoop.isShutdown()) return closedFuture; tryScheduleAction(new Runnable() { @Override public void run() { if (isDisposed) return; isDisposed = true; // Close all currently connected channels for (IConnectionController con : idleChannels) closeConnection(con, true); idleChannels.clear(); for (Realm ri : realms.values()) { for (ClientHandler channel : ri.channelsBySessionId.values()) { ri.removeChannel(channel, false); channel.markAsClosed(); GoodbyeMessage goodbye = new GoodbyeMessage(null, ApplicationError.SYSTEM_SHUTDOWN); channel.controller.sendMessage(goodbye, IWampConnectionPromise.Empty); closeConnection(channel.controller, true); } ri.channelsBySessionId.clear(); } // close is asynchronous. It will wait until all connections are closed // Afterwards the eventLoop will be shutDown. } }); return closedFuture; } enum RouterHandlerState { Open, Closed } IWampConnectionAcceptor connectionAcceptor = new IWampConnectionAcceptor() { @Override public IWampConnectionListener createNewConnectionListener() { ClientHandler newHandler = new ClientHandler(); IConnectionController newController = new QueueingConnectionController(eventLoop, newHandler); newHandler.controller = newController; return newController; } @Override public void acceptNewConnection(final IWampConnection newConnection, final IWampConnectionListener connectionListener) { try { eventLoop.execute(new Runnable() { @Override public void run() { if (connectionListener == null || !(connectionListener instanceof QueueingConnectionController) || newConnection == null) { // This is always true if the transport provider does not manipulate the structure // that was sent by the router if (newConnection != null) newConnection.close(false, IWampConnectionPromise.Empty); return; } QueueingConnectionController controller = (QueueingConnectionController) connectionListener; controller.setConnection(newConnection); if (isDisposed) { // Got an incoming connection after the router has already shut down. // Therefore we close the connection closeConnection(controller, false); } else { // Store the controller idleChannels.add(controller); } } }); } catch (RejectedExecutionException e) { // Close the connection // Defer the operation to avoid a cyclic call from the new connection // to this method and back Runnable r = new Runnable() { @Override public void run() { newConnection.close(false, IWampConnectionPromise.Empty); } }; ExecutorService executor = Executors.newSingleThreadExecutor(); executor.submit(r); executor.shutdown(); } } }; /** * Returns the {@link IWampConnectionAcceptor} interface that the router * provides in order to be able to accept new connection. */ public IWampConnectionAcceptor connectionAcceptor() { return connectionAcceptor; } class ClientHandler implements IWampConnectionListener { IConnectionController controller; public RouterHandlerState state = RouterHandlerState.Open; long sessionId; Realm realm; Set<WampRoles> roles; /** * Procedures that this channel provides.<br> * Key is the registration ID, Value is the procedure */ Map<Long, Procedure> providedProcedures; Map<Long, Invocation> pendingInvocations; /** The Set of subscriptions to which this channel is subscribed */ Map<Long, Subscription> subscriptionsById; long lastUsedId = IdValidator.MIN_VALID_ID; void markAsClosed() { state = RouterHandlerState.Closed; } public ClientHandler() { } @Override public void transportClosed() { // Handle in the same way as a close due to an error transportError(null); } @Override public void transportError(Throwable cause) { if (isDisposed || state != RouterHandlerState.Open) return; if (realm != null) { closeActiveClient(ClientHandler.this, null); } else { closePassiveClient(ClientHandler.this); } } @Override public void messageReceived(final WampMessage message) { if (isDisposed || state != RouterHandlerState.Open) return; if (realm == null) { onMessageFromUnregisteredChannel(ClientHandler.this, message); } else { onMessageFromRegisteredChannel(ClientHandler.this, message); } } } private void onMessageFromRegisteredChannel(ClientHandler handler, WampMessage msg) { // TODO: Validate roles for all relevant messages if (msg instanceof HelloMessage || msg instanceof WelcomeMessage) { // The client sent hello but it was already registered -> This is an error // If the client sends welcome it's also an error closeActiveClient(handler, new GoodbyeMessage(null, ApplicationError.INVALID_ARGUMENT)); } else if (msg instanceof AbortMessage || msg instanceof GoodbyeMessage) { // The client wants to leave the realm // Remove the channel from the realm handler.realm.removeChannel(handler, true); // But add it to the list of passive channels idleChannels.add(handler.controller); // Echo the message in case of goodbye if (msg instanceof GoodbyeMessage) { GoodbyeMessage reply = new GoodbyeMessage(null, ApplicationError.GOODBYE_AND_OUT); handler.controller.sendMessage(reply, IWampConnectionPromise.Empty); } } else if (msg instanceof CallMessage) { // The client wants to call a remote function // Verify the message CallMessage call = (CallMessage) msg; String err = null; if (!UriValidator.tryValidate(call.procedure, handler.realm.config.useStrictUriValidation)) { // Client sent an invalid URI err = ApplicationError.INVALID_URI; } if (err == null && !(IdValidator.isValidId(call.requestId))) { // Client sent an invalid request ID err = ApplicationError.INVALID_ARGUMENT; } Procedure proc = null; if (err == null) { proc = handler.realm.procedures.get(call.procedure); if (proc == null) err = ApplicationError.NO_SUCH_PROCEDURE; } if (err != null) { // If we have an error send that to the client ErrorMessage errMsg = new ErrorMessage(CallMessage.ID, call.requestId, null, err, null, null); handler.controller.sendMessage(errMsg, IWampConnectionPromise.Empty); return; } // Everything checked, we can forward the call to the provider Invocation invoc = new Invocation(); invoc.callRequestId = call.requestId; invoc.caller = handler; invoc.procedure = proc; invoc.invocationRequestId = IdGenerator.newLinearId(proc.provider.lastUsedId, proc.provider.pendingInvocations); proc.provider.lastUsedId = invoc.invocationRequestId; // Store the invocation proc.provider.pendingInvocations.put(invoc.invocationRequestId, invoc); // Store the call in the procedure to return error if client unregisters proc.pendingCalls.add(invoc); // And send it to the provider InvocationMessage imsg = new InvocationMessage(invoc.invocationRequestId, proc.registrationId, null, call.arguments, call.argumentsKw); proc.provider.controller.sendMessage(imsg, IWampConnectionPromise.Empty); } else if (msg instanceof YieldMessage) { // The clients sends as the result of an RPC // Verify the message YieldMessage yield = (YieldMessage) msg; if (!(IdValidator.isValidId(yield.requestId))) return; // Look up the invocation to find the original caller if (handler.pendingInvocations == null) return; // If a client send a yield without an invocation, return Invocation invoc = handler.pendingInvocations.get(yield.requestId); if (invoc == null) return; // There is no invocation pending under this ID handler.pendingInvocations.remove(yield.requestId); invoc.procedure.pendingCalls.remove(invoc); // Send the result to the original caller ResultMessage result = new ResultMessage(invoc.callRequestId, null, yield.arguments, yield.argumentsKw); invoc.caller.controller.sendMessage(result, IWampConnectionPromise.Empty); } else if (msg instanceof ErrorMessage) { ErrorMessage err = (ErrorMessage) msg; if (!(IdValidator.isValidId(err.requestId))) { return; } if (err.requestType == InvocationMessage.ID) { if (!UriValidator.tryValidate(err.error, handler.realm.config.useStrictUriValidation)) { // The Message provider has sent us an invalid URI for the error string // We better don't forward it but instead close the connection, which will // give the original caller an unknown message error closeActiveClient(handler, new GoodbyeMessage(null, ApplicationError.INVALID_ARGUMENT)); return; } // Look up the invocation to find the original caller if (handler.pendingInvocations == null) return; // if an error is send before an invocation, do not do anything Invocation invoc = handler.pendingInvocations.get(err.requestId); if (invoc == null) return; // There is no invocation pending under this ID handler.pendingInvocations.remove(err.requestId); invoc.procedure.pendingCalls.remove(invoc); // Send the result to the original caller ErrorMessage fwdError = new ErrorMessage(CallMessage.ID, invoc.callRequestId, null, err.error, err.arguments, err.argumentsKw); invoc.caller.controller.sendMessage(fwdError, IWampConnectionPromise.Empty); } // else TODO: Are there any other possibilities where a client could return ERROR } else if (msg instanceof RegisterMessage) { // The client wants to register a procedure // Verify the message RegisterMessage reg = (RegisterMessage) msg; String err = null; if (!UriValidator.tryValidate(reg.procedure, handler.realm.config.useStrictUriValidation)) { // Client sent an invalid URI err = ApplicationError.INVALID_URI; } if (err == null && !(IdValidator.isValidId(reg.requestId))) { // Client sent an invalid request ID err = ApplicationError.INVALID_ARGUMENT; } Procedure proc = null; if (err == null) { proc = handler.realm.procedures.get(reg.procedure); if (proc != null) err = ApplicationError.PROCEDURE_ALREADY_EXISTS; } if (err != null) { // If we have an error send that to the client ErrorMessage errMsg = new ErrorMessage(RegisterMessage.ID, reg.requestId, null, err, null, null); handler.controller.sendMessage(errMsg, IWampConnectionPromise.Empty); return; } // Everything checked, we can register the caller as the procedure provider long registrationId = IdGenerator.newLinearId(handler.lastUsedId, handler.providedProcedures); handler.lastUsedId = registrationId; Procedure procInfo = new Procedure(reg.procedure, handler, registrationId); // Insert new procedure handler.realm.procedures.put(reg.procedure, procInfo); if (handler.providedProcedures == null) { handler.providedProcedures = new HashMap<Long, WampRouter.Procedure>(); handler.pendingInvocations = new HashMap<Long, WampRouter.Invocation>(); } handler.providedProcedures.put(procInfo.registrationId, procInfo); RegisteredMessage response = new RegisteredMessage(reg.requestId, procInfo.registrationId); handler.controller.sendMessage(response, IWampConnectionPromise.Empty); } else if (msg instanceof UnregisterMessage) { // The client wants to unregister a procedure // Verify the message UnregisterMessage unreg = (UnregisterMessage) msg; String err = null; if (!(IdValidator.isValidId(unreg.requestId)) || !(IdValidator.isValidId(unreg.registrationId))) { // Client sent an invalid request or registration ID err = ApplicationError.INVALID_ARGUMENT; } Procedure proc = null; if (err == null) { if (handler.providedProcedures != null) { proc = handler.providedProcedures.get(unreg.registrationId); } // Check whether the procedure exists AND if the caller is the owner // If the caller is not the owner it might be an attack, so we don't // disclose that the procedure exists. if (proc == null) { err = ApplicationError.NO_SUCH_REGISTRATION; } } if (err != null) { // If we have an error send that to the client ErrorMessage errMsg = new ErrorMessage(UnregisterMessage.ID, unreg.requestId, null, err, null, null); handler.controller.sendMessage(errMsg, IWampConnectionPromise.Empty); return; } // Mark pending calls to this procedure as failed for (Invocation invoc : proc.pendingCalls) { handler.pendingInvocations.remove(invoc.invocationRequestId); if (invoc.caller.state == RouterHandlerState.Open) { ErrorMessage errMsg = new ErrorMessage(CallMessage.ID, invoc.callRequestId, null, ApplicationError.NO_SUCH_PROCEDURE, null, null); invoc.caller.controller.sendMessage(errMsg, IWampConnectionPromise.Empty); } } proc.pendingCalls.clear(); // Remove the procedure from the realm and the handler handler.realm.procedures.remove(proc.procName); handler.providedProcedures.remove(proc.registrationId); if (handler.providedProcedures.size() == 0) { handler.providedProcedures = null; handler.pendingInvocations = null; } // Send the acknowledge UnregisteredMessage response = new UnregisteredMessage(unreg.requestId); handler.controller.sendMessage(response, IWampConnectionPromise.Empty); } else if (msg instanceof SubscribeMessage) { // The client wants to subscribe to a procedure // Verify the message SubscribeMessage sub = (SubscribeMessage) msg; String err = null; // Find subscription match type SubscriptionFlags flags = SubscriptionFlags.Exact; if (sub.options != null) { JsonNode match = sub.options.get("match"); if (match != null) { String matchValue = match.asText(); if ("prefix".equals(matchValue)) { flags = SubscriptionFlags.Prefix; } else if ("wildcard".equals(matchValue)) { flags = SubscriptionFlags.Wildcard; } } } if (flags == SubscriptionFlags.Exact) { if (!UriValidator.tryValidate(sub.topic, handler.realm.config.useStrictUriValidation)) { // Client sent an invalid URI err = ApplicationError.INVALID_URI; } } else if (flags == SubscriptionFlags.Prefix) { if (!UriValidator.tryValidatePrefix(sub.topic, handler.realm.config.useStrictUriValidation)) { // Client sent an invalid URI err = ApplicationError.INVALID_URI; } } else if (flags == SubscriptionFlags.Wildcard) { if (!UriValidator.tryValidateWildcard(sub.topic, handler.realm.config.useStrictUriValidation)) { // Client sent an invalid URI err = ApplicationError.INVALID_URI; } } if (err == null && !(IdValidator.isValidId(sub.requestId))) { // Client sent an invalid request ID err = ApplicationError.INVALID_ARGUMENT; } if (err != null) { // If we have an error send that to the client ErrorMessage errMsg = new ErrorMessage(SubscribeMessage.ID, sub.requestId, null, err, null, null); handler.controller.sendMessage(errMsg, IWampConnectionPromise.Empty); return; } // Create a new subscription map for the client if it was not subscribed before if (handler.subscriptionsById == null) { handler.subscriptionsById = new HashMap<Long, WampRouter.Subscription>(); } // Search if a subscription from any client on the realm to this topic exists Map<String, Subscription> subscriptionMap = handler.realm.subscriptionsByFlags.get(flags); Subscription subscription = subscriptionMap.get(sub.topic); if (subscription == null) { // No client was subscribed to this URI up to now // Create a new subscription id long subscriptionId = IdGenerator.newLinearId(handler.realm.lastUsedSubscriptionId, handler.realm.subscriptionsById); handler.realm.lastUsedSubscriptionId = subscriptionId; // Create and add the new subscription subscription = new Subscription(sub.topic, flags, subscriptionId); subscriptionMap.put(sub.topic, subscription); handler.realm.subscriptionsById.put(subscriptionId, subscription); } // We check if the client is already subscribed to this topic by trying to add the // new client as a receiver. If the client is already a receiver we do nothing // (already subscribed and already stored in handler.subscriptionsById). Calling // add to check and add is more efficient than checking with contains first. // If the client was already subscribed this will return the same subscriptionId // than as for the last subscription. // See discussion in https://groups.google.com/forum/#!topic/wampws/kC878Ngc9Z0 if (subscription.subscribers.add(handler)) { // Add the subscription on the client handler.subscriptionsById.put(subscription.subscriptionId, subscription); } SubscribedMessage response = new SubscribedMessage(sub.requestId, subscription.subscriptionId); handler.controller.sendMessage(response, IWampConnectionPromise.Empty); } else if (msg instanceof UnsubscribeMessage) { // The client wants to cancel a subscription // Verify the message UnsubscribeMessage unsub = (UnsubscribeMessage) msg; String err = null; if (!(IdValidator.isValidId(unsub.requestId)) || !(IdValidator.isValidId(unsub.subscriptionId))) { // Client sent an invalid request or registration ID err = ApplicationError.INVALID_ARGUMENT; } Subscription s = null; if (err == null) { // Check whether such a subscription exists and fetch the topic name if (handler.subscriptionsById != null) { s = handler.subscriptionsById.get(unsub.subscriptionId); } if (s == null) { err = ApplicationError.NO_SUCH_SUBSCRIPTION; } } if (err != null) { // If we have an error send that to the client ErrorMessage errMsg = new ErrorMessage(UnsubscribeMessage.ID, unsub.requestId, null, err, null, null); handler.controller.sendMessage(errMsg, IWampConnectionPromise.Empty); return; } // Remove the channel as an receiver from the subscription s.subscribers.remove(handler); // Remove the subscription from the handler handler.subscriptionsById.remove(s.subscriptionId); if (handler.subscriptionsById.isEmpty()) { handler.subscriptionsById = null; } // Remove the subscription from the realm if no subscriber is left if (s.subscribers.isEmpty()) { handler.realm.subscriptionsByFlags.get(s.flags).remove(s.topic); handler.realm.subscriptionsById.remove(s.subscriptionId); } // Send the acknowledge UnsubscribedMessage response = new UnsubscribedMessage(unsub.requestId); handler.controller.sendMessage(response, IWampConnectionPromise.Empty); } else if (msg instanceof PublishMessage) { // The client wants to publish something to all subscribers (apart from himself) PublishMessage pub = (PublishMessage) msg; // Check whether the client wants an acknowledgement for the publication // Default is no boolean sendAcknowledge = false; JsonNode ackOption = pub.options.get("acknowledge"); if (ackOption != null && ackOption.asBoolean() == true) sendAcknowledge = true; String err = null; if (!UriValidator.tryValidate(pub.topic, handler.realm.config.useStrictUriValidation)) { // Client sent an invalid URI err = ApplicationError.INVALID_URI; } if (err == null && !(IdValidator.isValidId(pub.requestId))) { // Client sent an invalid request ID err = ApplicationError.INVALID_ARGUMENT; } if (err != null) { // If we have an error send that to the client ErrorMessage errMsg = new ErrorMessage(PublishMessage.ID, pub.requestId, null, err, null, null); if (sendAcknowledge) { handler.controller.sendMessage(errMsg, IWampConnectionPromise.Empty); } return; } long publicationId = IdGenerator.newRandomId(null); // Store that somewhere? // Get the subscriptions for this topic on the realm Subscription exactSubscription = handler.realm.subscriptionsByFlags.get(SubscriptionFlags.Exact) .get(pub.topic); if (exactSubscription != null) { publishEvent(handler, pub, publicationId, exactSubscription); } Map<String, Subscription> prefixSubscriptionMap = handler.realm.subscriptionsByFlags .get(SubscriptionFlags.Prefix); for (Subscription prefixSubscription : prefixSubscriptionMap.values()) { if (pub.topic.startsWith(prefixSubscription.topic)) { publishEvent(handler, pub, publicationId, prefixSubscription); } } Map<String, Subscription> wildcardSubscriptionMap = handler.realm.subscriptionsByFlags .get(SubscriptionFlags.Wildcard); String[] components = pub.topic.split("\\.", -1); for (Subscription wildcardSubscription : wildcardSubscriptionMap.values()) { boolean matched = true; if (components.length == wildcardSubscription.components.length) { for (int i = 0; i < components.length; i++) { if (wildcardSubscription.components[i].length() > 0 && !components[i].equals(wildcardSubscription.components[i])) { matched = false; break; } } } else matched = false; if (matched) { publishEvent(handler, pub, publicationId, wildcardSubscription); } } if (sendAcknowledge) { PublishedMessage response = new PublishedMessage(pub.requestId, publicationId); handler.controller.sendMessage(response, IWampConnectionPromise.Empty); } } } private void publishEvent(ClientHandler publisher, PublishMessage pub, long publicationId, Subscription subscription) { ObjectNode details = null; if (subscription.flags != SubscriptionFlags.Exact) { details = objectMapper.createObjectNode(); details.put("topic", pub.topic); } EventMessage ev = new EventMessage(subscription.subscriptionId, publicationId, details, pub.arguments, pub.argumentsKw); for (ClientHandler receiver : subscription.subscribers) { if (receiver == publisher) { // Potentially skip the publisher boolean skipPublisher = true; if (pub.options != null) { JsonNode excludeMeNode = pub.options.get("exclude_me"); if (excludeMeNode != null) { skipPublisher = excludeMeNode.asBoolean(true); } } if (skipPublisher) continue; } // Publish the event to the subscriber receiver.controller.sendMessage(ev, IWampConnectionPromise.Empty); } } private void onMessageFromUnregisteredChannel(ClientHandler channelHandler, WampMessage msg) { // Only HELLO is allowed when a channel is not registered if (!(msg instanceof HelloMessage)) { // Close the connection closePassiveClient(channelHandler); return; } HelloMessage hello = (HelloMessage) msg; String errorMsg = null; Realm realm = null; if (!UriValidator.tryValidate(hello.realm, false)) { errorMsg = ApplicationError.INVALID_URI; } else { realm = realms.get(hello.realm); if (realm == null) { errorMsg = ApplicationError.NO_SUCH_REALM; } } if (errorMsg != null) { AbortMessage abort = new AbortMessage(null, errorMsg); channelHandler.controller.sendMessage(abort, IWampConnectionPromise.Empty); return; } Set<WampRoles> roles = new HashSet<WampRoles>(); boolean hasUnsupportedRoles = false; JsonNode n = hello.details.get("roles"); if (n != null && n.isObject()) { ObjectNode rolesNode = (ObjectNode) n; Iterator<String> roleKeys = rolesNode.fieldNames(); while (roleKeys.hasNext()) { WampRoles role = WampRoles.fromString(roleKeys.next()); if (!SUPPORTED_CLIENT_ROLES.contains(role)) hasUnsupportedRoles = true; if (role != null) roles.add(role); } } if (roles.size() == 0 || hasUnsupportedRoles) { AbortMessage abort = new AbortMessage(null, ApplicationError.NO_SUCH_ROLE); channelHandler.controller.sendMessage(abort, IWampConnectionPromise.Empty); return; } long sessionId = IdGenerator.newRandomId(realm.channelsBySessionId); // Include the channel into the realm realm.includeChannel(channelHandler, sessionId, roles); // Remove the channel from the idle channel list - It is no longer idle idleChannels.remove(channelHandler.controller); // Respond with the WELCOME message WelcomeMessage welcome = new WelcomeMessage(channelHandler.sessionId, realm.welcomeDetails); channelHandler.controller.sendMessage(welcome, IWampConnectionPromise.Empty); } private void closeActiveClient(ClientHandler channel, WampMessage closeMessage) { if (channel == null) return; channel.realm.removeChannel(channel, true); channel.markAsClosed(); if (channel.controller != null) { if (closeMessage != null) channel.controller.sendMessage(closeMessage, IWampConnectionPromise.Empty); closeConnection(channel.controller, true); } } private void closePassiveClient(ClientHandler channelHandler) { idleChannels.remove(channelHandler.controller); channelHandler.markAsClosed(); closeConnection(channelHandler.controller, false); } }