LaunchPad Self-Contained Apps

Deploy Oorian applications as a single executable JAR. No Tomcat, no Glassfish—just compile and run.

Simplify Your Deployment

LaunchPad wraps Jetty to provide a zero-configuration embedded server for Oorian applications.

Single JAR Deployment

Package your entire application as a single executable JAR. No WAR files, no deployment descriptors.

Zero Configuration

Start with sensible defaults. Configure only what you need to customize.

Ideal for Microservices

Perfect for microservice architectures. Lightweight footprint with fast startup times.

HTTP & HTTPS

Built-in support for both HTTP and HTTPS with easy SSL keystore configuration.

Full Communication Support

AJAX, SSE, and WebSocket all work out of the box. No extra configuration needed.

GZIP Compression

Automatic GZIP compression for text content. Enabled by default for optimal performance.

Health Endpoint

Built-in /health endpoint for load balancer health checks. Perfect for container orchestration.

Built-in Monitoring

JMX support out of the box, optional Prometheus metrics endpoint. Monitor with JConsole, VisualVM, or Grafana.

IDE Hot Restart

Automatic shutdown of previous instance when restarting from your IDE. No port conflicts.

Quick Start

Get your Oorian application running standalone in just a few lines of code.

Java
public static void main(String[] args)
{
    LaunchPad launcher = new LaunchPad();
    launcher.setPort(8080);
    launcher.launch(MyApplication.class);  // Your Oorian Application class
}

// That's it! Run the main method and browse to http://localhost:8080

Configuration Options

LaunchPad provides a fluent API for configuring your embedded server.

Java
LaunchPad launcher = new LaunchPad();

// Basic configuration
launcher.setPort(8080)                           // HTTP port (default: 8080)
        .setContextPath("/myapp")                // Context path (default: /)
        .setShutdownPort(8005);                  // Shutdown port for IDE restart

// SSL/HTTPS
launcher.enableSsl("/path/to/keystore.jks", "password")
        .setSslPort(8443);                       // HTTPS port (default: 8443)

// Thread pool
launcher.setThreadPool(10, 200)                  // Min and max threads
        .setIdleTimeout(30000);                  // Connection idle timeout in ms

// Features
launcher.setGzipEnabled(true)                    // GZIP compression (default: true)
        .setHealthEndpointEnabled(true)          // Health check endpoint (default: true)
        .setHealthEndpointPath("/health");       // Health endpoint path

// Static resources
launcher.setResourceBase("/var/www/static")      // Serve static files
        .setTempDirectory("/tmp/myapp");         // Temp directory for uploads

// Configuration file (optional)
launcher.setConfigFile("/etc/myapp/server.properties");

launcher.launch(MyApplication.class);

Configuration File

For production deployments, you can externalize configuration to a properties file.

properties
# server.properties
server.port=8080
server.shutdown.port=8005
server.context.path=/
server.threads.min=10
server.threads.max=200
server.idle.timeout=30000

# SSL (optional)
server.ssl.enabled=true
server.ssl.port=8443
server.ssl.keystore.path=/etc/myapp/keystore.jks
server.ssl.keystore.password=changeit

# Features
server.gzip.enabled=true
server.health.enabled=true
server.health.path=/health

# Resources
server.resource.base=/var/www/myapp/static
server.temp.directory=/tmp/myapp

Why Use LaunchPad?

Simplified Deployment

No need to install and configure Tomcat, Jetty, or any other servlet container. Your application is self-contained.

Container-Ready

Perfect for Docker deployments. Just build a JAR with dependencies and run it. The health endpoint makes Kubernetes integration seamless.

Development Friendly

The shutdown port mechanism automatically stops the previous instance when you restart from your IDE. No more 'port already in use' errors.

Production Proven

Built on Jetty, one of the most battle-tested embedded servers. LaunchPad adds a simple API on top without sacrificing reliability.

Flexible Configuration

Configure programmatically for development, via properties files for production, or mix both approaches as needed.

Full Feature Support

All Oorian features work with LaunchPad: AJAX, SSE, WebSocket, file uploads, sessions, and more.