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

Class StaticHandler

java.lang.Object
io.vertx.mutiny.ext.web.handler.StaticHandler
All Implemented Interfaces:
MutinyDelegate, io.vertx.core.Handler<RoutingContext>, Consumer<RoutingContext>
public class StaticHandler extends Object implements io.vertx.core.Handler<RoutingContext>, Consumer<RoutingContext>, MutinyDelegate
A handler for serving static resources from the file system or classpath.

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

Author:
Tim Fox
See Also:
  • StaticHandler

  • Field Details

    • DEFAULT_WEB_ROOT

      public static final String DEFAULT_WEB_ROOT
      Default value of the web-root, where files are served from
      See Also:

    • DEFAULT_FILES_READ_ONLY

      public static final boolean DEFAULT_FILES_READ_ONLY
      Default value of whether files are read -only and never will be updated
      See Also:

    • DEFAULT_MAX_AGE_SECONDS

      public static final long DEFAULT_MAX_AGE_SECONDS
      See Also:

    • DEFAULT_CACHING_ENABLED

      public static final boolean DEFAULT_CACHING_ENABLED
      Default of whether cache header handling is enabled

    • DEFAULT_DIRECTORY_LISTING

      public static final boolean DEFAULT_DIRECTORY_LISTING
      Default of whether directory listing is enabled
      See Also:

    • DEFAULT_DIRECTORY_TEMPLATE

      public static final String DEFAULT_DIRECTORY_TEMPLATE
      Default template file to use for directory listing
      See Also:

    • DEFAULT_INCLUDE_HIDDEN

      public static final boolean DEFAULT_INCLUDE_HIDDEN
      Default of whether hidden files can be served
      See Also:

    • DEFAULT_CACHE_ENTRY_TIMEOUT

      public static final long DEFAULT_CACHE_ENTRY_TIMEOUT
      See Also:

    • DEFAULT_INDEX_PAGE

      public static final String DEFAULT_INDEX_PAGE
      The default index page
      See Also:

    • DEFAULT_MAX_CACHE_SIZE

      public static final int DEFAULT_MAX_CACHE_SIZE
      The default max cache size
      See Also:

    • DEFAULT_ALWAYS_ASYNC_FS

      public static final boolean DEFAULT_ALWAYS_ASYNC_FS
      Default of whether async filesystem access should always be used
      See Also:

    • DEFAULT_ENABLE_FS_TUNING

      public static final boolean DEFAULT_ENABLE_FS_TUNING
      Default of whether fs async/sync tuning should be used
      See Also:

    • DEFAULT_MAX_AVG_SERVE_TIME_NS

      public static final long DEFAULT_MAX_AVG_SERVE_TIME_NS
      See Also:

    • DEFAULT_RANGE_SUPPORT

      public static final boolean DEFAULT_RANGE_SUPPORT
      Default of whether Range request handling support should be used
      See Also:

    • DEFAULT_ROOT_FILESYSTEM_ACCESS

      public static final boolean DEFAULT_ROOT_FILESYSTEM_ACCESS
      Default of whether access to the root of the file system should be allowed or just allow from the current working directory.
      See Also:

    • DEFAULT_SEND_VARY_HEADER

      public static final boolean DEFAULT_SEND_VARY_HEADER
      Default of whether vary header should be sent.
      See Also:

    • __TYPE_ARG

      public static final TypeArg<StaticHandler> __TYPE_ARG

  • Constructor Details

    • StaticHandler

      public StaticHandler(io.vertx.ext.web.handler.StaticHandler delegate)
      Create a new instance of StaticHandler delegating to the given (non-null) instance of StaticHandler.

    • StaticHandler

      public StaticHandler(Object delegate)

  • Method Details

    • accept

      public void accept(RoutingContext item)
      Handle an item. This method is generated from the original method."
      Specified by:
      accept in interface Consumer<RoutingContext>

    • handle

      public void handle(RoutingContext item)
      Handle an item. This method is generated from the original method."
      Specified by:
      handle in interface io.vertx.core.Handler<RoutingContext>

    • getDelegate

      public io.vertx.ext.web.handler.StaticHandler getDelegate()
      Get the delegate instance.

      This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.

      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate instance

    • create

      public static StaticHandler create()
      Create a handler using defaults
      Returns:
      the handler

    • create

      public static StaticHandler create(String root)
      Create a handler, specifying web-root
      Parameters:
      root - the web-root
      Returns:
      the handler

    • create

      public static StaticHandler create(io.vertx.ext.web.handler.FileSystemAccess handlerVisibility, String root)
      Create a handler, specifying web-root and access option: absolute path or relative
      Parameters:
      handlerVisibility - CWD or file system root
      root - the web-root
      Returns:
      the handler

    • setFilesReadOnly

      public StaticHandler setFilesReadOnly(boolean readOnly)
      Set whether files are read-only and will never change
      Parameters:
      readOnly - whether files are read-only
      Returns:
      a reference to this, so the API can be used fluently

    • setMaxAgeSeconds

      public StaticHandler setMaxAgeSeconds(long maxAgeSeconds)
      Set value for max age in caching headers
      Parameters:
      maxAgeSeconds - maximum time for browser to cache, in seconds
      Returns:
      a reference to this, so the API can be used fluently

    • setCachingEnabled

      public StaticHandler setCachingEnabled(boolean enabled)
      Set whether cache header handling is enabled
      Parameters:
      enabled - true if enabled
      Returns:
      a reference to this, so the API can be used fluently

    • setDirectoryListing

      public StaticHandler setDirectoryListing(boolean directoryListing)
      Set whether directory listing is enabled
      Parameters:
      directoryListing - true if enabled
      Returns:
      a reference to this, so the API can be used fluently

    • setIncludeHidden

      public StaticHandler setIncludeHidden(boolean includeHidden)
      Set whether hidden files should be served
      Parameters:
      includeHidden - true if hidden files should be served
      Returns:
      a reference to this, so the API can be used fluently

    • setCacheEntryTimeout

      public StaticHandler setCacheEntryTimeout(long timeout)
      Set the server cache entry timeout when caching is enabled
      Parameters:
      timeout - the timeout, in ms
      Returns:
      a reference to this, so the API can be used fluently

    • setIndexPage

      public StaticHandler setIndexPage(String indexPage)
      Set the index page
      Parameters:
      indexPage - the index page
      Returns:
      a reference to this, so the API can be used fluently

    • setMaxCacheSize

      public StaticHandler setMaxCacheSize(int maxCacheSize)
      Set the max cache size, when caching is enabled
      Parameters:
      maxCacheSize - the max cache size
      Returns:
      a reference to this, so the API can be used fluently

    • setHttp2PushMapping

      public StaticHandler setHttp2PushMapping(List<io.vertx.ext.web.Http2PushMapping> http2PushMappings)
      Set the file mapping for http2push and link preload
      Parameters:
      http2PushMappings - the mapping for http2 push
      Returns:
      a reference to this, so the API can be used fluently

    • skipCompressionForMediaTypes

      public StaticHandler skipCompressionForMediaTypes(Set<String> mediaTypes)
      Skip compression if the media type of the file to send is in the provided mediaTypes set. Content-Encoding header set to identity for the types present in the mediaTypes set
      Parameters:
      mediaTypes - the set of mime types that are already compressed
      Returns:
      a reference to this, so the API can be used fluently

    • skipCompressionForSuffixes

      public StaticHandler skipCompressionForSuffixes(Set<String> fileSuffixes)
      Skip compression if the suffix of the file to send is in the provided fileSuffixes set. Content-Encoding header set to identity for the suffixes present in the fileSuffixes set
      Parameters:
      fileSuffixes - the set of file suffixes that are already compressed
      Returns:
      a reference to this, so the API can be used fluently

    • setAlwaysAsyncFS

      public StaticHandler setAlwaysAsyncFS(boolean alwaysAsyncFS)
      Set whether async filesystem access should always be used
      Parameters:
      alwaysAsyncFS - true for always async FS access
      Returns:
      a reference to this, so the API can be used fluently

    • setEnableFSTuning

      public StaticHandler setEnableFSTuning(boolean enableFSTuning)
      Set whether async/sync filesystem tuning should enabled
      Parameters:
      enableFSTuning - true to enabled FS tuning
      Returns:
      a reference to this, so the API can be used fluently

    • setMaxAvgServeTimeNs

      public StaticHandler setMaxAvgServeTimeNs(long maxAvgServeTimeNanoSeconds)
      Set the max serve time in ns, above which serves are considered slow
      Parameters:
      maxAvgServeTimeNanoSeconds - max serve time, in ns
      Returns:
      a reference to this, so the API can be used fluently

    • setDirectoryTemplate

      public StaticHandler setDirectoryTemplate(String directoryTemplate)
      Set the directory template to be used when directory listing
      Parameters:
      directoryTemplate - the directory template
      Returns:
      a reference to this, so the API can be used fluently

    • setEnableRangeSupport

      public StaticHandler setEnableRangeSupport(boolean enableRangeSupport)
      Set whether range requests (resumable downloads; media streaming) should be enabled.
      Parameters:
      enableRangeSupport - true to enable range support
      Returns:
      a reference to this, so the API can be used fluently

    • setSendVaryHeader

      public StaticHandler setSendVaryHeader(boolean varyHeader)
      Set whether vary header should be sent with response.
      Parameters:
      varyHeader - true to sent vary header
      Returns:
      a reference to this, so the API can be used fluently

    • setDefaultContentEncoding

      public StaticHandler setDefaultContentEncoding(String contentEncoding)
      Set the default content encoding for text related files. This allows overriding the system settings default value.
      Parameters:
      contentEncoding - the desired content encoding e.g.: "UTF-8"
      Returns:
      a reference to this, so the API can be used fluently

    • newInstance

      public static StaticHandler newInstance(io.vertx.ext.web.handler.StaticHandler delegate)
      Creates a new instance of the StaticHandler.

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

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

    • toString

      public String toString()
      Overrides:
      toString in class Object