tessl/maven-org-eclipse-jetty--jetty-server

Core server component of Eclipse Jetty web server providing HTTP server functionality, request handling, and connection management

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Eclipse Jetty Server

Name: tessl/maven-org-eclipse-jetty--jetty-server
Author: tessl

Eclipse Jetty Server is the core HTTP server component of the Eclipse Jetty web server. It provides a comprehensive API for building HTTP servers, handling HTTP requests and responses, managing connections, and serving static and dynamic content. The server supports HTTP/1.1, HTTP/2, and HTTP/3 protocols with extensive configuration options and handler-based request processing.

Package Information

Package Name: org.eclipse.jetty:jetty-server
Package Type: maven
Language: Java
Installation: Add Maven dependency

<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-server</artifactId>
    <version>12.0.21</version>
</dependency>

Core Imports

// Core server classes
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.HttpConnectionFactory;
import org.eclipse.jetty.server.HttpConfiguration;

// Handler interfaces and implementations
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Response;
import org.eclipse.jetty.util.Callback;

// Context and resource handling
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.handler.ResourceHandler;

// Optional components
import org.eclipse.jetty.server.handler.gzip.GzipHandler;

Basic Usage

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Response;
import org.eclipse.jetty.util.Callback;

public class SimpleJettyServer {
    public static void main(String[] args) throws Exception {
        // Create server instance
        Server server = new Server();
        
        // Create and configure HTTP connector
        ServerConnector connector = new ServerConnector(server);
        connector.setPort(8080);
        server.addConnector(connector);
        
        // Create a simple handler
        Handler handler = new Handler.Abstract() {
            @Override
            public boolean handle(Request request, Response response, Callback callback) 
                    throws Exception {
                response.setStatus(200);
                response.getHeaders().put("Content-Type", "text/plain");
                response.write(true, "Hello, Jetty!".getBytes(), callback);
                return true;
            }
        };
        
        server.setHandler(handler);
        
        // Start the server
        server.start();
        server.join(); // Wait for server to finish
    }
}

Architecture

Eclipse Jetty Server follows a component-based architecture with these key concepts:

Core Components

Server: Central coordinator that manages connectors, handlers, and lifecycle
Connector: Manages network connections and protocol support (HTTP/1.1, HTTP/2, HTTP/3)
Handler: Processes HTTP requests in a chain-of-responsibility pattern
Request/Response: Interfaces representing HTTP request and response with lifecycle callbacks

Request Processing Flow

Connection: Connector accepts network connections and creates protocol-specific connections
Request Parsing: Connection parses HTTP protocol into Request objects
Handler Chain: Server delegates requests through handler chain for processing
Response Generation: Handlers generate responses through Response interface
Completion: Callback mechanism signals request completion and cleanup

Threading Model

Acceptor Threads: Accept new connections (configurable count)
Selector Threads: Manage I/O operations on connections (NIO-based)
Handler Threads: Execute request processing logic (from thread pool)
Async Support: Non-blocking I/O with callback-based completion

Capabilities

Server Core

Core server functionality including server lifecycle, connector management, and basic configuration.

public final class Server extends Handler.Wrapper implements Attributes {
    // Constructors
    public Server();
    public Server(int port);
    public Server(InetSocketAddress addr);
    public Server(ThreadPool threadPool);
    
    // Core server operations
    public static String getVersion();
    public URI getURI();
    public void join() throws InterruptedException;
    
    // Connector management
    public Connector[] getConnectors();
    public void addConnector(Connector connector);
    public void setConnectors(Connector[] connectors);
    
    // Handler management  
    public void setHandler(Handler handler);
    public Handler getHandler();
    public Request.Handler getErrorHandler();
    public void setErrorHandler(Request.Handler errorHandler);
}

Server Core APIs

Request and Response Processing

HTTP request and response interfaces with content handling, headers, and lifecycle management.

public interface Request extends Attributes, Content.Source {
    String getId();
    String getMethod();
    HttpURI getHttpURI();
    HttpFields getHeaders();
    List<HttpCookie> getCookies();
    Session getSession(boolean create);
    Context getContext();
    ConnectionMetaData getConnectionMetaData();
    
    interface Handler {
        boolean handle(Request request, Response response, Callback callback) throws Exception;
    }
}

public interface Response extends Content.Sink {
    Request getRequest();
    int getStatus();
    void setStatus(int code);
    HttpFields.Mutable getHeaders();
    void write(boolean last, ByteBuffer byteBuffer, Callback callback);
}

Request and Response APIs

Handler Framework

Flexible handler system for processing HTTP requests with support for wrapping, containers, and conditional processing.

public interface Handler extends LifeCycle, Destroyable, Request.Handler {
    Server getServer();
    void setServer(Server server);
    
    interface Container extends Handler {
        List<Handler> getHandlers();
        boolean insertHandler(Handler handler);
        boolean removeHandler(Handler handler);
    }
    
    abstract class Abstract extends AbstractLifeCycle implements Handler {
        protected abstract boolean handle(Request request, Response response, Callback callback) throws Exception;
    }
}

Handler System

Connection Management

Network connection handling with protocol factories, SSL support, and connection lifecycle management.

public interface Connector extends LifeCycle, Container, Graceful {
    Server getServer();
    Executor getExecutor();
    Scheduler getScheduler();
    ByteBufferPool getByteBufferPool();
    ConnectionFactory getConnectionFactory(String protocol);
    Collection<ConnectionFactory> getConnectionFactories();
}

public class ServerConnector extends AbstractNetworkConnector {
    public ServerConnector(Server server);
    public ServerConnector(Server server, ConnectionFactory... factories);
    
    public void setPort(int port);
    public int getPort();
    public void setHost(String host);
    public String getHost();
}

Connection Management

HTTP Configuration

HTTP protocol configuration including buffer sizes, timeouts, security settings, and protocol customizers.

public class HttpConfiguration implements Dumpable {
    public HttpConfiguration();
    public HttpConfiguration(HttpConfiguration config);
    
    public void addCustomizer(Customizer customizer);
    public List<Customizer> getCustomizers();
    public int getOutputBufferSize();
    public void setOutputBufferSize(int outputBufferSize);
    public int getRequestHeaderSize();
    public void setRequestHeaderSize(int requestHeaderSize);
    public boolean getSendServerVersion();
    public void setSendServerVersion(boolean sendServerVersion);
    
    interface Customizer {
        Request customize(Request request, HttpConfiguration configuration);
    }
}

HTTP Configuration

Context and Resource Handling

Context-based request routing with virtual hosts, resource serving, and servlet-like contexts.

public class ContextHandler extends Handler.Wrapper implements Attributes, AliasCheck {
    public String getContextPath();
    public void setContextPath(String contextPath);
    public Resource getBaseResource();
    public void setBaseResource(Resource resource);
    public List<String> getVirtualHosts();
    public void setVirtualHosts(String... vhosts);
    public ClassLoader getClassLoader();
    public void setClassLoader(ClassLoader classLoader);
}

public class ResourceHandler extends Handler.Wrapper {
    public Resource getBaseResource();
    public void setBaseResource(Resource baseResource);
    public List<String> getWelcomeFiles();
    public void setWelcomeFiles(String... welcomeFiles);
}

Context and Resources

Session Management

HTTP session management with creation, invalidation, and attribute storage.

public interface Session extends Attributes {
    String getId();
    Context getContext();
    long getCreationTime();
    long getLastAccessedTime();
    void setMaxInactiveInterval(int interval);
    int getMaxInactiveInterval();
    void invalidate();
    boolean isNew();
}

Session Management

Request Logging

Comprehensive request logging with customizable formats, file rotation, and SLF4J integration.

public interface RequestLog {
    void log(Request request, Response response);
    
    interface Writer {
        void write(String requestEntry) throws IOException;
    }
}

public class CustomRequestLog extends ContainerLifeCycle implements RequestLog {
    public CustomRequestLog(RequestLog.Writer writer, String format);
    public void setLogFormat(String format);
    public String getLogFormat();
}

Request Logging

Security and SSL

SSL/TLS support, security customizers, and connection encryption.

public class SslConnectionFactory extends AbstractConnectionFactory 
        implements ConnectionFactory.Detecting, ConnectionFactory.Configuring {
    public SslConnectionFactory(SslContextFactory.Server sslContextFactory, String nextProtocol);
    public SslContextFactory.Server getSslContextFactory();
}

public class SecureRequestCustomizer implements HttpConfiguration.Customizer {
    public void setSniRequired(boolean sniRequired);
    public void setStsMaxAge(long stsMaxAge);
    public void setStsIncludeSubDomains(boolean stsIncludeSubDomains);
}

Security and SSL

Utility Handlers

Specialized handlers for common functionality like GZIP compression, CORS, statistics, and error handling.

public class GzipHandler extends Handler.Wrapper implements GzipFactory {
    public int getMinGzipSize();
    public void setMinGzipSize(int minGzipSize);
    public int getCompressionLevel();
    public void setCompressionLevel(int compressionLevel);
    public Set<String> getIncludedMimeTypes();
    public void setIncludedMimeTypes(String... types);
}

public class StatisticsHandler extends EventsHandler {
    public int getRequests();
    public int getRequestsActive();
    public long getBytesReceived();
    public long getBytesSent();
}

Utility Handlers

Types

// Core callback interface for async operations
public interface Callback {
    void succeeded();
    void failed(Throwable x);
    
    static Callback NOOP = new Callback() {
        public void succeeded() {}
        public void failed(Throwable x) {}
    };
}

// HTTP URI representation
public interface HttpURI {
    String getScheme();
    String getHost();
    int getPort();
    String getPath();
    String getQuery();
    String getFragment();
}

// HTTP fields for headers
public interface HttpFields extends Iterable<HttpField> {
    HttpField getField(String name);
    String get(String name);
    List<String> getValuesList(String name);
    int size();
    
    interface Mutable extends HttpFields {
        HttpField put(String name, String value);
        HttpField add(String name, String value);
        boolean remove(String name);
        void clear();
    }
}

// Context for request processing
public interface Context extends Attributes, Decorator, Executor {
    String getContextPath();
    ClassLoader getClassLoader();
    Resource getBaseResource();
    List<String> getVirtualHosts();
    MimeTypes getMimeTypes();
    void run(Runnable runnable);
    Request.Handler getErrorHandler();
}

// Thread pool interface
public interface ThreadPool extends Executor {
    void join() throws InterruptedException;
    int getThreads();
    int getIdleThreads();
    boolean isLowOnThreads();
}

// Graceful shutdown interface
public interface Graceful {
    CompletableFuture<Void> shutdown();
    boolean isShutdown();
}

// Resource abstraction
public interface Resource {
    String getName();
    boolean exists();
    boolean isDirectory();
    long length();
    long lastModified();
    InputStream newInputStream() throws IOException;
    ReadableByteChannel newReadableByteChannel() throws IOException;
}