From Code to Community: Sponsoring The Perl and Raku Conference 2025 Learn more

SRI / Mojolicious-3.96 / lib / Mojolicious / Command / prefork.pm 

            

              
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
—
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

              
package Mojolicious::Command::prefork;
use Mojo::Base 'Mojolicious::Command';
use Getopt::Long qw(GetOptionsFromArray :config no_auto_abbrev no_ignore_case);
use Mojo::Server::Prefork;
has description =>
  "Start application with preforking HTTP and WebSocket server.\n";
has usage => <<"EOF";
usage: $0 prefork [OPTIONS]
These options are available:
  -A, --accepts <number>               Number of connections for workers to
                                       accept, defaults to 1000.
  -a, --accept-interval <seconds>      Accept interval, defaults to 0.025.
  -b, --backlog <size>                 Listen backlog size, defaults to
                                       SOMAXCONN.
  -c, --clients <number>               Maximum number of concurrent clients,
                                       defaults to 1000.
  -G, --graceful-timeout <seconds>     Graceful timeout, defaults to 20.
  -g, --group <name>                   Group name for process.
      --heartbeat-interval <seconds>   Heartbeat interval, defaults to 5.
  -H, --heartbeat-timeout <seconds>    Heartbeat timeout, defaults to 20.
  -i, --inactivity <seconds>           Inactivity timeout, defaults to the
                                       value of MOJO_INACTIVITY_TIMEOUT or 15.
      --lock-file <path>               Path to lock file, defaults to a random
                                       file.
  -L, --lock-timeout <seconds>         Lock timeout, defaults to 0.5.
  -l, --listen <location>              One or more locations you want to
                                       listen on, defaults to the value of
                                       MOJO_LISTEN or "http://*:3000".
      --multi-accept <number>          Number of connection to accept at once,
                                       defaults to 50.
  -P, --pid-file <path>                Path to process id file, defaults to a
                                       random file.
  -p, --proxy                          Activate reverse proxy support,
                                       defaults to the value of
                                       MOJO_REVERSE_PROXY.
  -r, --requests <number>              Maximum number of requests per
                                       keep-alive connection, defaults to 25.
  -u, --user <name>                    Username for process.
  -w, --workers <number>               Number of workers, defaults to 4.
EOF
sub run {
  my ($self, @args) = @_;
  my $prefork = Mojo::Server::Prefork->new(app => $self->app);
  GetOptionsFromArray \@args,
    'A|accepts=i'           => sub { $prefork->accepts($_[1]) },
    'a|accept-interval=f'   => sub { $prefork->accept_interval($_[1]) },
    'b|backlog=i'           => sub { $prefork->backlog($_[1]) },
    'c|clients=i'           => sub { $prefork->max_clients($_[1]) },
    'G|graceful-timeout=i'  => sub { $prefork->graceful_timeout($_[1]) },
    'g|group=s'             => sub { $prefork->group($_[1]) },
    'heartbeat-interval=i'  => sub { $prefork->heartbeat_interval($_[1]) },
    'H|heartbeat-timeout=i' => sub { $prefork->heartbeat_timeout($_[1]) },
    'i|inactivity=i'        => sub { $prefork->inactivity_timeout($_[1]) },
    'lock-file=s'           => sub { $prefork->lock_file($_[1]) },
    'L|lock-timeout=f'      => sub { $prefork->lock_timeout($_[1]) },
    'l|listen=s'     => \my @listen,
    'multi-accept=i' => sub { $prefork->multi_accept($_[1]) },
    'P|pid-file=s'   => sub { $prefork->pid_file($_[1]) },
    'p|proxy'        => sub { $ENV{MOJO_REVERSE_PROXY} = 1 },
    'r|requests=i' => sub { $prefork->max_requests($_[1]) },
    'u|user=s'     => sub { $prefork->user($_[1]) },
    'w|workers=i'  => sub { $prefork->workers($_[1]) };
  $prefork->listen(\@listen) if @listen;
  $prefork->run;
}
1;
=head1 NAME
Mojolicious::Command::prefork - Prefork command
=head1 SYNOPSIS
  use Mojolicious::Command::prefork;
  my $prefork = Mojolicious::Command::prefork->new;
  $prefork->run(@ARGV);
=head1 DESCRIPTION
L<Mojolicious::Command::prefork> starts applications with
L<Mojo::Server::Prefork> backend.
This is a core command, that means it is always enabled and its code a good
example for learning to build new commands, you're welcome to fork it.
=head1 ATTRIBUTES
L<Mojolicious::Command::prefork> inherits all attributes from
L<Mojolicious::Command> and implements the following new ones.
=head2 description
  my $description = $prefork->description;
  $prefork        = $prefork->description('Foo!');
Short description of this command, used for the command list.
=head2 usage
  my $usage = $prefork->usage;
  $prefork  = $prefork->usage('Foo!');
Usage information for this command, used for the help screen.
=head1 METHODS
L<Mojolicious::Command::prefork> inherits all methods from
L<Mojolicious::Command> and implements the following new ones.
=head2 run
  $prefork->run(@ARGV);
Run this command.
=head1 SEE ALSO
L<Mojolicious>, L<Mojolicious::Guides>, L<http://mojolicio.us>.
=cut