File Coverage

bin/pagi-server

Criterion	Covered	Total	%
statement	32	56	57.1
branch	8	34	23.5
condition	1	6	16.6
subroutine	5	5	100.0
pod			n/a
total	46	101	45.5

#!/usr/bin/env perl

# Handle compile-time options before loading any modules
# Future::XS must be loaded before Future, so check early
BEGIN {
    my @to_splice;
    for my $i (0 .. $#ARGV) {
        if ($ARGV[$i] eq '--future-xs') {
            $ENV{PAGI_FUTURE_XS} = 1;
            push @to_splice, $i;
        }
        elsif ($ARGV[$i] eq '--http2') {
            $ENV{_PAGI_SERVER_HTTP2} = 1;
            push @to_splice, $i;
        }
    }
    # Remove processed flags in reverse order to preserve indices
    for my $i (reverse @to_splice) {
        splice @ARGV, $i, 1;
    }

    # Capture original args for hot restart re-exec (USR2)
    $ENV{PAGI_ARGV} = join("\0", @ARGV) unless exists $ENV{PAGI_ARGV};
}

use strict;
use warnings;

use Getopt::Long qw(GetOptionsFromArray :config pass_through no_auto_abbrev);
use PAGI::Runner;

# Parse PAGI::Server-specific options before passing to Runner
# This keeps Runner server-agnostic
my %server_opts;

GetOptionsFromArray(
    \@ARGV,
    # Network (Unix socket / multi-listener)
    'socket=s'              => \$server_opts{socket},
    'socket-mode=s'         => \$server_opts{_socket_mode},
    'listen=s@'             => \$server_opts{_listen},

    # Workers/scaling
    'w|workers=i'           => \$server_opts{workers},
    'reuseport'             => \$server_opts{reuseport},
    'max-requests=i'        => \$server_opts{max_requests},
    'max-connections=i'     => \$server_opts{max_connections},

    # TLS
    'ssl-cert=s'            => \$server_opts{_ssl_cert},
    'ssl-key=s'             => \$server_opts{_ssl_key},

    # Timeouts
    'timeout=i'             => \$server_opts{timeout},
    'shutdown-timeout=i'    => \$server_opts{shutdown_timeout},
    'request-timeout=i'     => \$server_opts{request_timeout},
    'ws-idle-timeout=i'     => \$server_opts{ws_idle_timeout},
    'sse-idle-timeout=i'    => \$server_opts{sse_idle_timeout},
    'heartbeat-timeout=i'   => \$server_opts{heartbeat_timeout},

    # Limits
    'max-body-size=i'       => \$server_opts{max_body_size},
    'max-header-size=i'     => \$server_opts{max_header_size},
    'max-header-count=i'    => \$server_opts{max_header_count},
    'max-receive-queue=i'   => \$server_opts{max_receive_queue},
    'max-ws-frame-size=i'   => \$server_opts{max_ws_frame_size},
    'b|listener-backlog=i'  => \$server_opts{listener_backlog},

    # Misc
    'log-level=s'           => \$server_opts{log_level},
    'sync-file-threshold=i' => \$server_opts{sync_file_threshold},
    'access-log-format=s'   => \$server_opts{access_log_format},
);

# Build ssl hash if certs provided
if ($server_opts{_ssl_cert} || $server_opts{_ssl_key}) {
    die "--ssl-cert and --ssl-key must be specified together\n"
        unless $server_opts{_ssl_cert} && $server_opts{_ssl_key};

    die "SSL cert not found: $server_opts{_ssl_cert}\n"
        unless -f $server_opts{_ssl_cert};
    die "SSL key not found: $server_opts{_ssl_key}\n"
        unless -f $server_opts{_ssl_key};

    $server_opts{ssl} = {
        cert_file => delete $server_opts{_ssl_cert},
        key_file  => delete $server_opts{_ssl_key},
    };
}
delete $server_opts{_ssl_cert};
delete $server_opts{_ssl_key};

# Handle --socket-mode (octal string to numeric)
if (defined $server_opts{_socket_mode}) {
    my $mode_str = $server_opts{_socket_mode};
    die "--socket-mode must be an octal value like 0660, got: $mode_str\n"
        unless $mode_str =~ /^0[0-7]{3}$/;
    $server_opts{socket_mode} = oct($mode_str);
}
delete $server_opts{_socket_mode};

# Handle --listen (build listen array from repeated --listen flags)
# Detection: contains ':' -> TCP host:port, otherwise -> Unix socket path
if (my $listen_specs = delete $server_opts{_listen}) {
    my @listeners;
    for my $spec (@$listen_specs) {
        if ($spec =~ m{^[./]}) {
            # Starts with / or . — always a Unix socket path
            # (even if it contains colons, e.g. /var/run/app:8080)
            my %entry = (socket => $spec);
            $entry{socket_mode} = $server_opts{socket_mode}
                if defined $server_opts{socket_mode};
            push @listeners, \%entry;
        } elsif ($spec =~ /^\[([^\]]+)\]:(\d+)$/) {
            # IPv6: [::1]:5000
            push @listeners, { host => $1, port => int($2) };
        } elsif ($spec =~ /^(.+):(\d+)$/) {
            # IPv4/hostname: 127.0.0.1:5000
            push @listeners, { host => $1, port => int($2) };
        } else {
            # Bare name without / or . prefix — treat as Unix socket
            my %entry = (socket => $spec);
            $entry{socket_mode} = $server_opts{socket_mode}
                if defined $server_opts{socket_mode};
            push @listeners, \%entry;
        }
    }
    $server_opts{listen} = \@listeners;
    delete $server_opts{socket_mode};  # Applied per-listener above
}

# Handle workers (0 for single-process, >1 for multi-worker)
if (defined $server_opts{workers}) {
    $server_opts{workers} = $server_opts{workers} > 1 ? $server_opts{workers} : 0;
}

# Remove undefined options
%server_opts = map { $_ => $server_opts{$_} } grep { defined $server_opts{$_} } keys %server_opts;

# Pass server options to Runner
PAGI::Runner->run(@ARGV, server_options => \%server_opts);

__END__