/** Removes the channel server proxy and binding for the node specified during construction. */
public void run() {
String channelServerKey = getChannelServerKey(nodeId);
DataService dataService = getDataService();
try {
dataService.removeObject(dataService.getServiceBinding(channelServerKey));
} catch (NameNotBoundException e) {
// already removed
return;
} catch (ObjectNotFoundException e) {
}
dataService.removeServiceBinding(channelServerKey);
}
/**
* Removes the client session server proxy and binding and also removes the protocol descriptors
* for the node specified during construction.
*/
public void run() {
String sessionServerKey = getClientSessionServerKey(nodeId);
DataService dataService = getDataService();
try {
dataService.removeObject(dataService.getServiceBinding(sessionServerKey));
getProtocolDescriptorsMap().remove(nodeId);
} catch (NameNotBoundException e) {
// already removed
return;
} catch (ObjectNotFoundException e) {
}
dataService.removeServiceBinding(sessionServerKey);
}
/**
* Invokes the {@code disconnected} callback on this session's {@code ClientSessionListener} (if
* present and {@code notify} is {@code true}), removes the listener and its binding (if present),
* and then removes this session and its bindings from the specified {@code dataService}. If the
* bindings have already been removed from the {@code dataService} this method takes no action.
* This method should only be called within a transaction.
*
* @param dataService a data service
* @param graceful {@code true} if disconnection is graceful, and {@code false} otherwise
* @param notify {@code true} if the {@code disconnected} callback should be invoked
* @throws TransactionException if there is a problem with the current transaction
*/
void notifyListenerAndRemoveSession(
final DataService dataService, final boolean graceful, boolean notify) {
String sessionKey = getSessionKey();
String sessionNodeKey = getSessionNodeKey();
String listenerKey = getListenerKey();
String eventQueueKey = getEventQueueKey();
/*
* Get ClientSessionListener, and remove its binding and
* wrapper if applicable. The listener may not be bound
* in the data service if: the AppListener.loggedIn callback
* either threw a non-retryable exception or returned a
* null listener, or the application removed the
* ClientSessionListener object from the data service.
*/
ClientSessionListener listener = null;
try {
ManagedObject obj = dataService.getServiceBinding(listenerKey);
dataService.removeServiceBinding(listenerKey);
if (obj instanceof ListenerWrapper) {
dataService.removeObject(obj);
listener = ((ListenerWrapper) obj).get();
} else {
listener = (ClientSessionListener) obj;
}
} catch (NameNotBoundException e) {
logger.logThrow(Level.FINE, e, "removing ClientSessionListener for session:{0} throws", this);
}
/*
* Remove event queue and associated binding.
*/
try {
ManagedObject eventQueue = dataService.getServiceBinding(eventQueueKey);
dataService.removeServiceBinding(eventQueueKey);
dataService.removeObject(eventQueue);
} catch (NameNotBoundException e) {
logger.logThrow(Level.FINE, e, "removing EventQueue for session:{0} throws", this);
}
/*
* Invoke listener's 'disconnected' callback if 'notify'
* is true and a listener exists for this client session. If the
* 'disconnected' callback throws a non-retryable exception,
* schedule a task to remove this session and its associated
* bindings without invoking the listener, and rethrow the
* exception so that the currently executing transaction aborts.
*/
if (notify && listener != null) {
try {
listener.disconnected(graceful);
} catch (RuntimeException e) {
if (!isRetryableException(e)) {
logger.logThrow(
Level.WARNING,
e,
"invoking disconnected callback on listener:{0} " + " for session:{1} throws",
listener,
this);
sessionService.scheduleTask(
new AbstractKernelRunnable() {
public void run() {
ClientSessionImpl sessionImpl = ClientSessionImpl.getSession(dataService, id);
sessionImpl.notifyListenerAndRemoveSession(dataService, graceful, false);
}
},
identity);
}
throw e;
}
}
/*
* Remove this session's state and bindings.
*/
try {
dataService.removeServiceBinding(sessionKey);
dataService.removeServiceBinding(sessionNodeKey);
dataService.removeObject(this);
} catch (NameNotBoundException e) {
logger.logThrow(Level.WARNING, e, "session binding already removed:{0}", sessionKey);
}
/*
* Remove this session's wrapper object, if it still exists.
*/
try {
dataService.removeObject(wrappedSessionRef.get());
} catch (ObjectNotFoundException e) {
// already removed
}
}
