/** * Perform the internal processing required to passivate * this session. */ public void passivate() { // Notify interested session event listeners fireSessionEvent(Session.SESSION_PASSIVATED_EVENT, null); // Notify ActivationListeners HttpSessionEvent event = null; String keys[] = keys(); for (int i = 0; i < keys.length; i++) { Object attribute = attributes.get(keys[i]); if (attribute instanceof HttpSessionActivationListener) { if (event == null) event = new HttpSessionEvent(getSession()); try { ((HttpSessionActivationListener)attribute) .sessionWillPassivate(event); } catch (Throwable t) { ExceptionUtils.handleThrowable(t); manager.getContainer().getLogger().error (sm.getString("standardSession.attributeEvent"), t); } } } }
/** * Perform the internal processing required to passivate * this session. */ public void passivate() { // Notify ActivationListeners HttpSessionEvent event = null; String keys[] = keys(); for (int i = 0; i < keys.length; i++) { Object attribute = getAttribute(keys[i]); if (attribute instanceof HttpSessionActivationListener) { if (event == null) event = new HttpSessionEvent(this); // FIXME: Should we catch throwables? ((HttpSessionActivationListener)attribute).sessionWillPassivate(event); } } }
/** * Perform internal processing required to activate this * session. */ public void activate() { // Notify ActivationListeners HttpSessionEvent event = null; String keys[] = keys(); for (int i = 0; i < keys.length; i++) { Object attribute = getAttribute(keys[i]); if (attribute instanceof HttpSessionActivationListener) { if (event == null) event = new HttpSessionEvent(this); // FIXME: Should we catch throwables? ((HttpSessionActivationListener)attribute).sessionDidActivate(event); } } }
/** * Simulate a passivate operation. */ public void passivate() { Enumeration<String> names = this.getAttributeNames(); String[] keys; synchronized(names) { List<String> nameList = Collections.list(names); keys = new String[nameList.size()]; for (int i = 0; i < nameList.size(); i++) { keys[i] = nameList.get(i); } } for (String key : keys) { Object value = this.getAttribute(key); if (value != null && value instanceof HttpSessionActivationListener) { ((HttpSessionActivationListener)value).sessionWillPassivate(new HttpSessionEvent(this)); } } active = false; }
private static boolean isWeb(final Class<?> beanClass) { if (Servlet.class.isAssignableFrom(beanClass) || Filter.class.isAssignableFrom(beanClass)) { return true; } if (EventListener.class.isAssignableFrom(beanClass)) { return HttpSessionAttributeListener.class.isAssignableFrom(beanClass) || ServletContextListener.class.isAssignableFrom(beanClass) || ServletRequestListener.class.isAssignableFrom(beanClass) || ServletContextAttributeListener.class.isAssignableFrom(beanClass) || HttpSessionListener.class.isAssignableFrom(beanClass) || HttpSessionBindingListener.class.isAssignableFrom(beanClass) || HttpSessionActivationListener.class.isAssignableFrom(beanClass) || HttpSessionIdListener.class.isAssignableFrom(beanClass) || ServletRequestAttributeListener.class.isAssignableFrom(beanClass); } return false; }
public void stop() { ClassLoader old = getTccl(); try { setTccl(servletContext.getClassLoader()); this.started = false; final Map<String, SessionPersistenceManager.PersistentSession> objectData = new HashMap<>(); for (String sessionId : sessionManager.getTransientSessions()) { Session session = sessionManager.getSession(sessionId); if (session != null) { final HttpSessionEvent event = new HttpSessionEvent(SecurityActions.forSession(session, servletContext, false)); final Map<String, Object> sessionData = new HashMap<>(); for (String attr : session.getAttributeNames()) { final Object attribute = session.getAttribute(attr); sessionData.put(attr, attribute); if (attribute instanceof HttpSessionActivationListener) { ((HttpSessionActivationListener) attribute).sessionWillPassivate(event); } } objectData.put(sessionId, new PersistentSession(new Date(session.getLastAccessedTime() + (session.getMaxInactiveInterval() * 1000)), sessionData)); } } sessionPersistenceManager.persistSessions(deploymentName, objectData); this.data.clear(); } finally { setTccl(old); } }
@Override public void handleRequest(HttpServerExchange exchange) throws Exception { final String incomingSessionId = servletContext.getSessionConfig().findSessionId(exchange); if (incomingSessionId == null || !data.containsKey(incomingSessionId)) { next.handleRequest(exchange); return; } //we have some old data PersistentSession result = data.remove(incomingSessionId); if (result != null) { long time = System.currentTimeMillis(); if (time < result.getExpiration().getTime()) { final HttpSessionImpl session = servletContext.getSession(exchange, true); final HttpSessionEvent event = new HttpSessionEvent(session); for (Map.Entry<String, Object> entry : result.getSessionData().entrySet()) { if (entry.getValue() instanceof HttpSessionActivationListener) { ((HttpSessionActivationListener) entry.getValue()).sessionDidActivate(event); } if(entry.getKey().startsWith(HttpSessionImpl.IO_UNDERTOW)) { session.getSession().setAttribute(entry.getKey(), entry.getValue()); } else { session.setAttribute(entry.getKey(), entry.getValue()); } } } } next.handleRequest(exchange); }
@Test public void testAttributeBeingStored() { HttpSessionActivationListener object = mock(HttpSessionActivationListener.class); notifier.attributeBeingStored(mock(RepositoryBackedSession.class), "Test", object); notifier.attributeBeingStored(session, "Test", "dummy"); verify(object, never()).sessionWillPassivate(any(HttpSessionEvent.class)); notifier.attributeBeingStored(session, "Test", object); verify(object).sessionWillPassivate(any(HttpSessionEvent.class)); }
@Test public void testAttributeHasBeenRestored() { HttpSessionActivationListener object = mock(HttpSessionActivationListener.class); notifier.attributeHasBeenRestored(mock(RepositoryBackedSession.class), "Test", object); notifier.attributeHasBeenRestored(mock(RepositoryBackedSession.class), "Test", "dummy"); notifier.attributeHasBeenRestored(session, "Test", "dummy"); verify(object, never()).sessionWillPassivate(any(HttpSessionEvent.class)); notifier.attributeHasBeenRestored(session, "Test", object); verify(object).sessionDidActivate(any(HttpSessionEvent.class)); }
public void valueUnbound(HttpSessionBindingEvent event) { for (EventListener listener: PluginWebInstanceRepository.getListeners()) { if (listener instanceof HttpSessionActivationListener) { ((HttpSessionBindingListener) listener).valueUnbound(event); } } }
public void sessionWillPassivate(HttpSessionEvent se) { for (EventListener listener: PluginWebInstanceRepository.getListeners()) { if (listener instanceof HttpSessionActivationListener) { ((HttpSessionActivationListener) listener).sessionWillPassivate(se); } } }
public void sessionDidActivate(HttpSessionEvent se) { for (EventListener listener: PluginWebInstanceRepository.getListeners()) { if (listener instanceof HttpSessionAttributeListener) { ((HttpSessionActivationListener) listener).sessionDidActivate(se); } } }
private void addListenerInstance(final Object listenerInstance, final List<ServletContextAttributeListener> contextAttributeListeners, final List<ServletContextListener> contextListeners, final List<ServletRequestAttributeListener> requestAttributeListeners, final List<ServletRequestListener> requestListeners, final List<HttpSessionActivationListener> sessionActivationListeners, final List<HttpSessionAttributeListener> sessionAttributeListeners, final List<HttpSessionListener> sessionListeners) { if (listenerInstance instanceof ServletContextAttributeListener) { contextAttributeListeners.add((ServletContextAttributeListener) listenerInstance); } if (listenerInstance instanceof ServletContextListener) { contextListeners.add((ServletContextListener) listenerInstance); } if (listenerInstance instanceof ServletRequestAttributeListener) { requestAttributeListeners.add((ServletRequestAttributeListener) listenerInstance); } if (listenerInstance instanceof ServletRequestListener) { requestListeners.add((ServletRequestListener) listenerInstance); } if (listenerInstance instanceof HttpSessionActivationListener) { sessionActivationListeners.add((HttpSessionActivationListener) listenerInstance); } if (listenerInstance instanceof HttpSessionAttributeListener) { sessionAttributeListeners.add((HttpSessionAttributeListener) listenerInstance); } if (listenerInstance instanceof HttpSessionListener) { sessionListeners.add((HttpSessionListener) listenerInstance); } }
/** * Perform internal processing required to activate this * session. */ public void activate() { // Initialize access count if (ACTIVITY_CHECK) { accessCount = new AtomicInteger(); } // Notify interested session event listeners fireSessionEvent(Session.SESSION_ACTIVATED_EVENT, null); // Notify ActivationListeners HttpSessionEvent event = null; String keys[] = keys(); for (int i = 0; i < keys.length; i++) { Object attribute = attributes.get(keys[i]); if (attribute instanceof HttpSessionActivationListener) { if (event == null) event = new HttpSessionEvent(getSession()); try { ((HttpSessionActivationListener)attribute) .sessionDidActivate(event); } catch (Throwable t) { ExceptionUtils.handleThrowable(t); manager.getContainer().getLogger().error (sm.getString("standardSession.attributeEvent"), t); } } } }
void save(Writer w) throws IOException { if (expired) return; // can't use append because old JDK w.write(id); w.write(':'); w.write(Integer.toString(inactiveInterval)); w.write(':'); w.write(servletContext == null || servletContext.getServletContextName() == null ? "" : servletContext .getServletContextName()); w.write(':'); w.write(Long.toString(lastAccessTime)); w.write("\r\n"); Enumeration e = getAttributeNames(); ByteArrayOutputStream os = new ByteArrayOutputStream(1024 * 16); while (e.hasMoreElements()) { String aname = (String) e.nextElement(); Object so = get(aname); if (so instanceof Serializable) { os.reset(); ObjectOutputStream oos = new ObjectOutputStream(os); try { oos.writeObject(so); w.write(aname); w.write(":"); w.write(Utils.base64Encode(os.toByteArray())); w.write("\r\n"); } catch (IOException ioe) { servletContext.log("TJWS: Can't replicate/store a session value of '" + aname + "' class:" + so.getClass().getName(), ioe); } } else servletContext.log("TJWS: Non serializable session object has been " + so.getClass().getName() + " skiped in storing of " + aname, null); if (so instanceof HttpSessionActivationListener) ((HttpSessionActivationListener) so).sessionWillPassivate(new HttpSessionEvent(this)); } w.write("$$\r\n"); }
/** * Simulate a activate operation. */ public void activate() { Enumeration<?> keys = this.getAttributeNames(); while (keys.hasMoreElements()) { String key = (String) keys.nextElement(); Object value = this.getAttribute(key); if (value != null && value instanceof HttpSessionActivationListener) { ((HttpSessionActivationListener)value).sessionDidActivate(new HttpSessionEvent(this)); } } active = true; }
@Override public void attributeBeingStored(RepositoryBackedSession session, String key, Object value) { if (session instanceof HttpSession && value instanceof HttpSessionActivationListener) { ((HttpSessionActivationListener)value).sessionWillPassivate(new HttpSessionEvent((HttpSession)session)); } }
@Override public void attributeHasBeenRestored(RepositoryBackedSession session, String key, Object value) { if (session instanceof HttpSession && value instanceof HttpSessionActivationListener) { ((HttpSessionActivationListener)value).sessionDidActivate(new HttpSessionEvent((HttpSession)session)); } }
@Override public void sessionWillPassivate(HttpSessionEvent event) { ((HttpSessionActivationListener)delegate).sessionWillPassivate(event); }
@Override public void sessionDidActivate(HttpSessionEvent event) { ((HttpSessionActivationListener)delegate).sessionDidActivate(event); }
public void setSessionActivationListeners(final HttpSessionActivationListener listeners[]) { sessionActivationListeners = listeners; }