Package io.vertx.mutiny.ext.web.handler

Class SessionHandler

java.lang.Object
io.vertx.mutiny.ext.web.handler.SessionHandler
All Implemented Interfaces:
MutinyDelegate, io.vertx.core.Handler<RoutingContext>, PlatformHandler, Consumer<RoutingContext>
public class SessionHandler extends Object implements MutinyDelegate, PlatformHandler, io.vertx.core.Handler<RoutingContext>, Consumer<RoutingContext>
A handler that maintains a Session for each browser session.

It looks up the session for each request based on a session cookie which contains a session ID. It stores the session when the response is ended in the session store.

The session is available on the routing context with .

NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

  • Field Details

    • __TYPE_ARG

      public static final TypeArg<SessionHandler> __TYPE_ARG

    • DEFAULT_SESSION_TIMEOUT

      public static final long DEFAULT_SESSION_TIMEOUT
      Default time, in ms, that a session lasts for without being accessed before expiring.
      See Also:

    • DEFAULT_NAG_HTTPS

      public static final boolean DEFAULT_NAG_HTTPS
      Default of whether a nagging log warning should be written if the session handler is accessed over HTTP, not HTTPS
      See Also:

    • DEFAULT_SESSIONID_MIN_LENGTH

      public static final int DEFAULT_SESSIONID_MIN_LENGTH
      Default min length for a session id. More info: https://www.owasp.org/index.php/Session_Management_Cheat_Sheet
      See Also:

    • DEFAULT_LAZY_SESSION

      public static final boolean DEFAULT_LAZY_SESSION
      Default of whether the session should be created lazily.
      See Also:

  • Constructor Details

    • SessionHandler

      public SessionHandler(io.vertx.ext.web.handler.SessionHandler delegate)

    • SessionHandler

      public SessionHandler(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.ext.web.handler.SessionHandler getDelegate()
      Specified by:
      getDelegate in interface MutinyDelegate
      Specified by:
      getDelegate in interface PlatformHandler
      Returns:
      the delegate used by this Mutiny object of generated type

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • handle

      public void handle(RoutingContext arg0)
      Specified by:
      handle in interface io.vertx.core.Handler<RoutingContext>
      Specified by:
      handle in interface PlatformHandler

    • create

      public static SessionHandler create(SessionStore sessionStore)
      Parameters:
      sessionStore - the session store
      Returns:
      the handler

    • setSessionTimeout

      public SessionHandler setSessionTimeout(long timeout)
      Parameters:
      timeout - the timeout, in ms.
      Returns:
      a reference to this, so the API can be used fluently

    • setNagHttps

      public SessionHandler setNagHttps(boolean nag)
      Parameters:
      nag - true to nag
      Returns:
      a reference to this, so the API can be used fluently

    • setCookieSecureFlag

      public SessionHandler setCookieSecureFlag(boolean secure)
      Parameters:
      secure - true to set the secure flag on the cookie
      Returns:
      a reference to this, so the API can be used fluently

    • setCookieHttpOnlyFlag

      public SessionHandler setCookieHttpOnlyFlag(boolean httpOnly)
      Parameters:
      httpOnly - true to set the HttpOnly flag on the cookie
      Returns:
      a reference to this, so the API can be used fluently

    • setSessionCookieName

      public SessionHandler setSessionCookieName(String sessionCookieName)
      Parameters:
      sessionCookieName - the session cookie name
      Returns:
      a reference to this, so the API can be used fluently

    • setSessionCookiePath

      public SessionHandler setSessionCookiePath(String sessionCookiePath)
      Parameters:
      sessionCookiePath - the session cookie path
      Returns:
      a reference to this, so the API can be used fluently

    • setMinLength

      public SessionHandler setMinLength(int minLength)
      Parameters:
      minLength - the session id minimal length
      Returns:
      a reference to this, so the API can be used fluently

    • setCookieSameSite

      public SessionHandler setCookieSameSite(io.vertx.core.http.CookieSameSite policy)
      Parameters:
      policy - to use, null for no policy.
      Returns:
      a reference to this, so the API can be used fluently

    • setLazySession

      public SessionHandler setLazySession(boolean lazySession)
      Parameters:
      lazySession - true to have a lazy session creation.
      Returns:
      a reference to this, so the API can be used fluently

    • setCookieMaxAge

      public SessionHandler setCookieMaxAge(long cookieMaxAge)
      Parameters:
      cookieMaxAge - a non negative max-age, note that 0 means expire now.
      Returns:
      a reference to this, so the API can be used fluently

    • flush

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> flush(RoutingContext ctx)
      Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level. Once a session is flushed no automatic save will be performed at end of request.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      ctx - the current context
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • flushAndAwait

      public Void flushAndAwait(RoutingContext ctx)
      Blocking variant of flush(io.vertx.mutiny.ext.web.RoutingContext).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      ctx - the current context
      Returns:
      the Void instance produced by the operation.

    • flushAndForget

      public SessionHandler flushAndForget(RoutingContext ctx)
      Variant of flush(io.vertx.mutiny.ext.web.RoutingContext) that ignores the result of the operation.

      This method subscribes on the result of flush(io.vertx.mutiny.ext.web.RoutingContext), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from flush(io.vertx.mutiny.ext.web.RoutingContext) but you don't need to compose it with other operations.

      Parameters:
      ctx - the current context
      Returns:
      the instance of SessionHandler to chain method calls.

    • flush

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> flush(RoutingContext ctx, boolean ignoreStatus)
      Flush a context session earlier to the store, this will allow the end user to have full control on the event of a failure at the store level. Once a session is flushed no automatic save will be performed at end of request.

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      ctx - the current context
      ignoreStatus - flush regardless of response status code
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • flushAndAwait

      public Void flushAndAwait(RoutingContext ctx, boolean ignoreStatus)
      Blocking variant of flush(io.vertx.mutiny.ext.web.RoutingContext,boolean).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      ctx - the current context
      ignoreStatus - flush regardless of response status code
      Returns:
      the Void instance produced by the operation.

    • flushAndForget

      public SessionHandler flushAndForget(RoutingContext ctx, boolean ignoreStatus)
      Variant of flush(io.vertx.mutiny.ext.web.RoutingContext,boolean) that ignores the result of the operation.

      This method subscribes on the result of flush(io.vertx.mutiny.ext.web.RoutingContext,boolean), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from flush(io.vertx.mutiny.ext.web.RoutingContext,boolean) but you don't need to compose it with other operations.

      Parameters:
      ctx - the current context
      ignoreStatus - flush regardless of response status code
      Returns:
      the instance of SessionHandler to chain method calls.

    • setCookieless

      public SessionHandler setCookieless(boolean cookieless)
      Parameters:
      cookieless - true if a cookieless session should be used
      Returns:
      a reference to this, so the API can be used fluently

    • newSession

      public Session newSession(RoutingContext context)
      Parameters:
      context - the routing context
      Returns:
      the session

    • setUser

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> setUser(RoutingContext context, User user)
      Set the user for the session

      Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

      Parameters:
      context - the routing context
      user - the user
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • setUserAndAwait

      public Void setUserAndAwait(RoutingContext context, User user)
      Blocking variant of setUser(io.vertx.mutiny.ext.web.RoutingContext,io.vertx.mutiny.ext.auth.User).

      This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      context - the routing context
      user - the user
      Returns:
      the Void instance produced by the operation.

    • setUserAndForget

      public SessionHandler setUserAndForget(RoutingContext context, User user)
      Variant of setUser(io.vertx.mutiny.ext.web.RoutingContext,io.vertx.mutiny.ext.auth.User) that ignores the result of the operation.

      This method subscribes on the result of setUser(io.vertx.mutiny.ext.web.RoutingContext,io.vertx.mutiny.ext.auth.User), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from setUser(io.vertx.mutiny.ext.web.RoutingContext,io.vertx.mutiny.ext.auth.User) but you don't need to compose it with other operations.

      Parameters:
      context - the routing context
      user - the user
      Returns:
      the instance of SessionHandler to chain method calls.

    • accept

      public void accept(RoutingContext item)
      Specified by:
      accept in interface Consumer<RoutingContext>
      Specified by:
      accept in interface PlatformHandler

    • newInstance

      public static SessionHandler newInstance(io.vertx.ext.web.handler.SessionHandler arg)