puma 6.4.1 → 7.2.1

data/ext/puma_http11/puma_http11.c

@@ -7,25 +7,13 @@
 #define RSTRING_NOT_MODIFIED 1
 
 #include "ruby.h"
-#include "ext_help.h"
+#include "ruby/encoding.h"
 #include <assert.h>
 #include <string.h>
 #include <ctype.h>
 #include "http11_parser.h"
 
-#ifndef MANAGED_STRINGS
-
-#ifndef RSTRING_PTR
-#define RSTRING_PTR(s) (RSTRING(s)->ptr)
-#endif
-#ifndef RSTRING_LEN
-#define RSTRING_LEN(s) (RSTRING(s)->len)
-#endif
-
-#define rb_extract_chars(e, sz) (*sz = RSTRING_LEN(e), RSTRING_PTR(e))
-#define rb_free_chars(e) /* nothing */
-
-#endif
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
 
 static VALUE eHttpParserError;
 
@@ -48,8 +36,11 @@ static VALUE global_request_path;
 #define VALIDATE_MAX_LENGTH(len, N) if(len > MAX_##N##_LENGTH) { rb_raise(eHttpParserError, MAX_##N##_LENGTH_ERR, len); }
 
 /** Defines global strings in the init method. */
-#define DEF_GLOBAL(N, val)   global_##N = rb_str_new2(val); rb_global_variable(&global_##N)
-
+static inline void DEF_GLOBAL(VALUE *var, const char *cstr)
+{
+  rb_global_variable(var);
+  *var = rb_enc_interned_str_cstr(cstr, rb_utf8_encoding());
+}
 
 /* Defines the maximum allowed lengths for various input elements.*/
 #ifndef PUMA_REQUEST_URI_MAX_LENGTH
@@ -73,10 +64,10 @@ DEF_MAX_LENGTH(QUERY_STRING, PUMA_QUERY_STRING_MAX_LENGTH);
 DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
 
 struct common_field {
-	const size_t len;
-	const char *name;
+  const size_t len;
+  const char *name;
   int raw;
-	VALUE value;
+  VALUE value;
 };
 
 /*
@@ -87,42 +78,42 @@ struct common_field {
 static struct common_field common_http_fields[] = {
 # define f(N) { (sizeof(N) - 1), N, 0, Qnil }
 # define fr(N) { (sizeof(N) - 1), N, 1, Qnil }
-	f("ACCEPT"),
-	f("ACCEPT_CHARSET"),
-	f("ACCEPT_ENCODING"),
-	f("ACCEPT_LANGUAGE"),
-	f("ALLOW"),
-	f("AUTHORIZATION"),
-	f("CACHE_CONTROL"),
-	f("CONNECTION"),
-	f("CONTENT_ENCODING"),
-	fr("CONTENT_LENGTH"),
-	fr("CONTENT_TYPE"),
-	f("COOKIE"),
-	f("DATE"),
-	f("EXPECT"),
-	f("FROM"),
-	f("HOST"),
-	f("IF_MATCH"),
-	f("IF_MODIFIED_SINCE"),
-	f("IF_NONE_MATCH"),
-	f("IF_RANGE"),
-	f("IF_UNMODIFIED_SINCE"),
-	f("KEEP_ALIVE"), /* Firefox sends this */
-	f("MAX_FORWARDS"),
-	f("PRAGMA"),
-	f("PROXY_AUTHORIZATION"),
-	f("RANGE"),
-	f("REFERER"),
-	f("TE"),
-	f("TRAILER"),
-	f("TRANSFER_ENCODING"),
-	f("UPGRADE"),
-	f("USER_AGENT"),
-	f("VIA"),
-	f("X_FORWARDED_FOR"), /* common for proxies */
-	f("X_REAL_IP"), /* common for proxies */
-	f("WARNING")
+  f("ACCEPT"),
+  f("ACCEPT_CHARSET"),
+  f("ACCEPT_ENCODING"),
+  f("ACCEPT_LANGUAGE"),
+  f("ALLOW"),
+  f("AUTHORIZATION"),
+  f("CACHE_CONTROL"),
+  f("CONNECTION"),
+  f("CONTENT_ENCODING"),
+  fr("CONTENT_LENGTH"),
+  fr("CONTENT_TYPE"),
+  f("COOKIE"),
+  f("DATE"),
+  f("EXPECT"),
+  f("FROM"),
+  f("HOST"),
+  f("IF_MATCH"),
+  f("IF_MODIFIED_SINCE"),
+  f("IF_NONE_MATCH"),
+  f("IF_RANGE"),
+  f("IF_UNMODIFIED_SINCE"),
+  f("KEEP_ALIVE"), /* Firefox sends this */
+  f("MAX_FORWARDS"),
+  f("PRAGMA"),
+  f("PROXY_AUTHORIZATION"),
+  f("RANGE"),
+  f("REFERER"),
+  f("TE"),
+  f("TRAILER"),
+  f("TRANSFER_ENCODING"),
+  f("UPGRADE"),
+  f("USER_AGENT"),
+  f("VIA"),
+  f("X_FORWARDED_FOR"), /* common for proxies */
+  f("X_REAL_IP"), /* common for proxies */
+  f("WARNING")
 # undef f
 };
 
@@ -134,13 +125,13 @@ static void init_common_fields(void)
   memcpy(tmp, HTTP_PREFIX, HTTP_PREFIX_LEN);
 
   for(i = 0; i < ARRAY_SIZE(common_http_fields); cf++, i++) {
+    rb_global_variable(&cf->value);
     if(cf->raw) {
-      cf->value = rb_str_new(cf->name, cf->len);
+      cf->value = rb_enc_interned_str(cf->name, cf->len, rb_utf8_encoding());
     } else {
       memcpy(tmp + HTTP_PREFIX_LEN, cf->name, cf->len + 1);
-      cf->value = rb_str_new(tmp, HTTP_PREFIX_LEN + cf->len);
+      cf->value = rb_enc_interned_str(tmp, HTTP_PREFIX_LEN + cf->len, rb_utf8_encoding());
     }
-    rb_global_variable(&cf->value);
   }
 }
 
@@ -155,7 +146,11 @@ static VALUE find_common_field_value(const char *field, size_t flen)
   return Qnil;
 }
 
-void http_field(puma_parser* hp, const char *field, size_t flen,
+static int is_ows(const char c) {
+    return c == ' ' || c == '\t';
+}
+
+static void http_field(puma_parser* hp, const char *field, size_t flen,
                                  const char *value, size_t vlen)
 {
   VALUE f = Qnil;
@@ -178,10 +173,14 @@ void http_field(puma_parser* hp, const char *field, size_t flen,
     memcpy(hp->buf, HTTP_PREFIX, HTTP_PREFIX_LEN);
     memcpy(hp->buf + HTTP_PREFIX_LEN, field, flen);
 
-    f = rb_str_new(hp->buf, new_size);
+    f = rb_enc_interned_str(hp->buf, new_size, rb_utf8_encoding());
   }
 
-  while (vlen > 0 && isspace(value[vlen - 1])) vlen--;
+  while (vlen > 0 && is_ows(value[vlen - 1])) vlen--;
+  while (vlen > 0 && is_ows(value[0])) {
+      vlen--;
+      value++;
+  }
 
   /* check for duplicate header */
   v = rb_hash_aref(hp->request, f);
@@ -196,7 +195,7 @@ void http_field(puma_parser* hp, const char *field, size_t flen,
   }
 }
 
-void request_method(puma_parser* hp, const char *at, size_t length)
+static void request_method(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = Qnil;
 
@@ -204,7 +203,7 @@ void request_method(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_request_method, val);
 }
 
-void request_uri(puma_parser* hp, const char *at, size_t length)
+static void request_uri(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = Qnil;
 
@@ -214,7 +213,7 @@ void request_uri(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_request_uri, val);
 }
 
-void fragment(puma_parser* hp, const char *at, size_t length)
+static void fragment(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = Qnil;
 
@@ -224,7 +223,7 @@ void fragment(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_fragment, val);
 }
 
-void request_path(puma_parser* hp, const char *at, size_t length)
+static void request_path(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = Qnil;
 
@@ -234,7 +233,7 @@ void request_path(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_request_path, val);
 }
 
-void query_string(puma_parser* hp, const char *at, size_t length)
+static void query_string(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = Qnil;
 
@@ -244,7 +243,7 @@ void query_string(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_query_string, val);
 }
 
-void server_protocol(puma_parser* hp, const char *at, size_t length)
+static void server_protocol(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = rb_str_new(at, length);
   rb_hash_aset(hp->request, global_server_protocol, val);
@@ -253,36 +252,42 @@ void server_protocol(puma_parser* hp, const char *at, size_t length)
 /** Finalizes the request header to have a bunch of stuff that's
   needed. */
 
-void header_done(puma_parser* hp, const char *at, size_t length)
+static void header_done(puma_parser* hp, const char *at, size_t length)
 {
   hp->body = rb_str_new(at, length);
 }
 
 
-void HttpParser_free(void *data) {
-  TRACE();
+static void HttpParser_mark(void *ptr) {
+  puma_parser *hp = ptr;
+  rb_gc_mark_movable(hp->request);
+  rb_gc_mark_movable(hp->body);
+}
 
-  if(data) {
-    xfree(data);
-  }
+static size_t HttpParser_size(const void *ptr) {
+  return sizeof(puma_parser);
 }
 
-void HttpParser_mark(void *ptr) {
+static void HttpParser_compact(void *ptr) {
   puma_parser *hp = ptr;
-  if(hp->request) rb_gc_mark(hp->request);
-  if(hp->body) rb_gc_mark(hp->body);
+  hp->request = rb_gc_location(hp->request);
+  hp->body = rb_gc_location(hp->body);
 }
 
-const rb_data_type_t HttpParser_data_type = {
-    "HttpParser",
-    { HttpParser_mark, HttpParser_free, 0 },
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+static const rb_data_type_t HttpParser_data_type = {
+    .wrap_struct_name = "Puma::HttpParser",
+    .function = {
+      .dmark = HttpParser_mark,
+      .dfree = RUBY_TYPED_DEFAULT_FREE,
+      .dsize = HttpParser_size,
+      .dcompact = HttpParser_compact,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-VALUE HttpParser_alloc(VALUE klass)
+static VALUE HttpParser_alloc(VALUE klass)
 {
   puma_parser *hp = ALLOC_N(puma_parser, 1);
-  TRACE();
   hp->http_field = http_field;
   hp->request_method = request_method;
   hp->request_uri = request_uri;
@@ -298,16 +303,25 @@ VALUE HttpParser_alloc(VALUE klass)
   return TypedData_Wrap_Struct(klass, &HttpParser_data_type, hp);
 }
 
+static inline puma_parser *HttpParser_unwrap(VALUE self)
+{
+  puma_parser *http;
+  TypedData_Get_Struct(self, puma_parser, &HttpParser_data_type, http);
+  if (http == NULL) {
+    rb_raise(rb_eArgError, "%s", "NULL http_parser found");
+  }
+  return http;
+}
+
 /**
  * call-seq:
  *    parser.new -> parser
  *
  * Creates a new parser.
  */
-VALUE HttpParser_init(VALUE self)
+static VALUE HttpParser_init(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
   puma_parser_init(http);
 
   return self;
@@ -321,10 +335,9 @@ VALUE HttpParser_init(VALUE self)
  * Resets the parser to it's initial state so that you can reuse it
  * rather than making new ones.
  */
-VALUE HttpParser_reset(VALUE self)
+static VALUE HttpParser_reset(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
   puma_parser_init(http);
 
   return Qnil;
@@ -338,10 +351,9 @@ VALUE HttpParser_reset(VALUE self)
  * Finishes a parser early which could put in a "good" or bad state.
  * You should call reset after finish it or bad things will happen.
  */
-VALUE HttpParser_finish(VALUE self)
+static VALUE HttpParser_finish(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
   puma_parser_finish(http);
 
   return puma_parser_is_finished(http) ? Qtrue : Qfalse;
@@ -365,26 +377,22 @@ VALUE HttpParser_finish(VALUE self)
  * the parsing from that position.  It needs all of the original data as well
  * so you have to append to the data buffer as you read.
  */
-VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
+static VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
 {
-  puma_parser *http = NULL;
+  puma_parser *http = HttpParser_unwrap(self);
   int from = 0;
   char *dptr = NULL;
   long dlen = 0;
 
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
-
   from = FIX2INT(start);
-  dptr = rb_extract_chars(data, &dlen);
+  RSTRING_GETMEM(data, dptr, dlen);
 
   if(from >= dlen) {
-    rb_free_chars(dptr);
     rb_raise(eHttpParserError, "%s", "Requested start is after data buffer end.");
   } else {
     http->request = req_hash;
     puma_parser_execute(http, dptr, dlen, from);
 
-    rb_free_chars(dptr);
     VALIDATE_MAX_LENGTH(puma_parser_nread(http), HEADER);
 
     if(puma_parser_has_error(http)) {
@@ -403,10 +411,9 @@ VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
  *
  * Tells you whether the parser is in an error state.
  */
-VALUE HttpParser_has_error(VALUE self)
+static VALUE HttpParser_has_error(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
 
   return puma_parser_has_error(http) ? Qtrue : Qfalse;
 }
@@ -418,10 +425,9 @@ VALUE HttpParser_has_error(VALUE self)
  *
  * Tells you whether the parser is finished or not and in a good state.
  */
-VALUE HttpParser_is_finished(VALUE self)
+static VALUE HttpParser_is_finished(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
 
   return puma_parser_is_finished(http) ? Qtrue : Qfalse;
 }
@@ -434,10 +440,9 @@ VALUE HttpParser_is_finished(VALUE self)
  * Returns the amount of data processed so far during this processing cycle.  It is
  * set to 0 on initialize or reset calls and is incremented each time execute is called.
  */
-VALUE HttpParser_nread(VALUE self)
+static VALUE HttpParser_nread(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
 
   return INT2FIX(http->nread);
 }
@@ -448,9 +453,8 @@ VALUE HttpParser_nread(VALUE self)
  *
  * If the request included a body, returns it.
  */
-VALUE HttpParser_body(VALUE self) {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+static VALUE HttpParser_body(VALUE self) {
+  puma_parser *http = HttpParser_unwrap(self);
 
   return http->body;
 }
@@ -459,21 +463,24 @@ VALUE HttpParser_body(VALUE self) {
 void Init_mini_ssl(VALUE mod);
 #endif
 
-void Init_puma_http11(void)
+RUBY_FUNC_EXPORTED void Init_puma_http11(void)
 {
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+  rb_ext_ractor_safe(true);
+#endif
 
   VALUE mPuma = rb_define_module("Puma");
   VALUE cHttpParser = rb_define_class_under(mPuma, "HttpParser", rb_cObject);
 
-  DEF_GLOBAL(request_method, "REQUEST_METHOD");
-  DEF_GLOBAL(request_uri, "REQUEST_URI");
-  DEF_GLOBAL(fragment, "FRAGMENT");
-  DEF_GLOBAL(query_string, "QUERY_STRING");
-  DEF_GLOBAL(server_protocol, "SERVER_PROTOCOL");
-  DEF_GLOBAL(request_path, "REQUEST_PATH");
+  DEF_GLOBAL(&global_request_method, "REQUEST_METHOD");
+  DEF_GLOBAL(&global_request_uri, "REQUEST_URI");
+  DEF_GLOBAL(&global_fragment, "FRAGMENT");
+  DEF_GLOBAL(&global_query_string, "QUERY_STRING");
+  DEF_GLOBAL(&global_server_protocol, "SERVER_PROTOCOL");
+  DEF_GLOBAL(&global_request_path, "REQUEST_PATH");
 
-  eHttpParserError = rb_define_class_under(mPuma, "HttpParserError", rb_eIOError);
   rb_global_variable(&eHttpParserError);
+  eHttpParserError = rb_define_class_under(mPuma, "HttpParserError", rb_eStandardError);
 
   rb_define_alloc_func(cHttpParser, HttpParser_alloc);
   rb_define_method(cHttpParser, "initialize", HttpParser_init, 0);

data/lib/puma/app/status.rb

@@ -7,13 +7,16 @@ module Puma
     # can respond to.
     class Status
       OK_STATUS = '{ "status": "ok" }'.freeze
+      READ_ONLY_COMMANDS = %w[gc-stats stats].freeze
 
       # @param launcher [::Puma::Launcher]
       # @param token [String, nil] the token used for authentication
+      # @param data_only [Boolean] if true, restrict to read-only data commands
       #
-      def initialize(launcher, token = nil)
+      def initialize(launcher, token: nil, data_only: false)
         @launcher = launcher
         @auth_token = token
+        @enabled_commands = READ_ONLY_COMMANDS if data_only
       end
 
       # most commands call methods in `::Puma::Launcher` based on command in
@@ -25,8 +28,13 @@ module Puma
 
         # resp_type is processed by following case statement, return
         # is a number (status) or a string used as the body of a 200 response
+        command = env['PATH_INFO'][/\/([^\/]+)$/, 1]
+        if @enabled_commands && !@enabled_commands.include?(command)
+          return rack_response(404, "Command #{command.inspect} unavailable", 'text/plain')
+        end
+
         resp_type =
-          case env['PATH_INFO'][/\/([^\/]+)$/, 1]
+          case command
           when 'stop'
             @launcher.stop ; 200
 
@@ -80,7 +88,7 @@ module Puma
 
       def authenticate(env)
         return true unless @auth_token
-        env['QUERY_STRING'].to_s.split('&;').include? "token=#{@auth_token}"
+        env['QUERY_STRING'].to_s.split(/[&;]/).include? "token=#{@auth_token}"
       end
 
       def rack_response(status, body, content_type='application/json')

data/lib/puma/binder.rb

@@ -5,7 +5,6 @@ require 'socket'
 
 require_relative 'const'
 require_relative 'util'
-require_relative 'configuration'
 
 module Puma
 
@@ -19,22 +18,23 @@ module Puma
 
     RACK_VERSION = [1,6].freeze
 
-    def initialize(log_writer, conf = Configuration.new)
+    def initialize(log_writer, options, env: ENV)
       @log_writer = log_writer
-      @conf = conf
+      @options = options
       @listeners = []
       @inherited_fds = {}
       @activated_sockets = {}
       @unix_paths = []
+      @env = env
 
       @proto_env = {
         "rack.version".freeze => RACK_VERSION,
         "rack.errors".freeze => log_writer.stderr,
-        "rack.multithread".freeze => conf.options[:max_threads] > 1,
-        "rack.multiprocess".freeze => conf.options[:workers] >= 1,
+        "rack.multithread".freeze => options[:max_threads] > 1,
+        "rack.multiprocess".freeze => options[:workers] >= 1,
         "rack.run_once".freeze => false,
-        RACK_URL_SCHEME => conf.options[:rack_url_scheme],
-        "SCRIPT_NAME".freeze => ENV['SCRIPT_NAME'] || "",
+        RACK_URL_SCHEME => options[:rack_url_scheme],
+        "SCRIPT_NAME".freeze => env['SCRIPT_NAME'] || "",
 
         # I'd like to set a default CONTENT_TYPE here but some things
         # depend on their not being a default set and inferring
@@ -43,7 +43,10 @@ module Puma
 
         "QUERY_STRING".freeze => "",
         SERVER_SOFTWARE => PUMA_SERVER_STRING,
-        GATEWAY_INTERFACE => CGI_VER
+        GATEWAY_INTERFACE => CGI_VER,
+
+        RACK_AFTER_REPLY => nil,
+        RACK_RESPONSE_FINISHED => nil,
       }
 
       @envs = {}
@@ -87,7 +90,7 @@ module Puma
     # @version 5.0.0
     #
     def create_activated_fds(env_hash)
-      @log_writer.debug "ENV['LISTEN_FDS'] #{ENV['LISTEN_FDS'].inspect}  env_hash['LISTEN_PID'] #{env_hash['LISTEN_PID'].inspect}"
+      @log_writer.debug "ENV['LISTEN_FDS'] #{@env['LISTEN_FDS'].inspect}  env_hash['LISTEN_PID'] #{env_hash['LISTEN_PID'].inspect}"
       return [] unless env_hash['LISTEN_FDS'] && env_hash['LISTEN_PID'].to_i == $$
       env_hash['LISTEN_FDS'].to_i.times do |index|
         sock = TCPServer.for_fd(socket_activation_fd(index))
@@ -141,7 +144,14 @@ module Puma
       end
     end
 
+    def before_parse(&block)
+      @before_parse ||= []
+      @before_parse << block if block
+      @before_parse
+    end
+
     def parse(binds, log_writer = nil, log_msg = 'Listening')
+      before_parse.each(&:call)
       log_writer ||= @log_writer
       binds.each do |str|
         uri = URI.parse str
@@ -183,7 +193,7 @@ module Puma
             io = inherit_unix_listener path, fd
             log_writer.log "* Inherited #{str}"
           elsif sock = @activated_sockets.delete([ :unix, path ]) ||
-              @activated_sockets.delete([ :unix, File.realdirpath(path) ])
+              !abstract && @activated_sockets.delete([ :unix, File.realdirpath(path) ])
             @unix_paths << path unless abstract || File.exist?(path)
             io = inherit_unix_listener path, sock
             log_writer.log "* Activated #{str}"
@@ -235,7 +245,7 @@ module Puma
               cert_key.each do |v|
                 if params[v]&.start_with?('store:')
                   index = Integer(params.delete(v).split('store:').last)
-                  params["#{v}_pem"] = @conf.options[:store][index]
+                  params["#{v}_pem"] = @options[:store][index]
                 end
               end
               MiniSSL::ContextBuilder.new(params, @log_writer).context

data/lib/puma/cli.rb

@@ -24,7 +24,7 @@ module Puma
     # Create a new CLI object using +argv+ as the command line
     # arguments.
     #
-    def initialize(argv, log_writer = LogWriter.stdio, events = Events.new)
+    def initialize(argv, log_writer = LogWriter.stdio, events = Events.new, env: ENV)
       @debug = false
       @argv = argv.dup
       @log_writer = log_writer
@@ -39,10 +39,8 @@ module Puma
       @control_url = nil
       @control_options = {}
 
-      setup_options
-
       begin
-        @parser.parse! @argv
+        setup_options env
 
         if file = @argv.shift
           @conf.configure do |user_config, file_config|
@@ -63,7 +61,7 @@ module Puma
         end
       end
 
-      @launcher = Puma::Launcher.new(@conf, :log_writer => @log_writer, :events => @events, :argv => argv)
+      @launcher = Puma::Launcher.new(@conf, env: ENV, log_writer: @log_writer, events: @events, argv: argv)
     end
 
     attr_reader :launcher
@@ -92,8 +90,8 @@ module Puma
     # Build the OptionParser object to handle the available options.
     #
 
-    def setup_options
-      @conf = Configuration.new({}, {events: @events}) do |user_config, file_config|
+    def setup_options(env = ENV)
+      @conf = Configuration.new({}, { events: @events }, env) do |user_config, file_config|
         @parser = OptionParser.new do |o|
           o.on "-b", "--bind URI", "URI to bind to (tcp://, unix://, ssl://)" do |arg|
             user_config.bind arg
@@ -157,6 +155,10 @@ module Puma
             user_config.pidfile arg
           end
 
+          o.on "--plugin PLUGIN", "Load the given PLUGIN. Can be used multiple times to load multiple plugins." do |arg|
+            user_config.plugin arg
+          end
+
           o.on "--preload", "Preload the app. Cluster mode only" do
             user_config.preload_app!
           end
@@ -236,7 +238,7 @@ module Puma
             $stdout.puts o
             exit 0
           end
-        end
+        end.parse! @argv
       end
     end
   end