jun-puma 1.0.1-java → 1.0.2-java

data/lib/puma/plugin/tmp_restart.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../plugin'
-
-Puma::Plugin.create do
-  def start(launcher)
-    path = File.join("tmp", "restart.txt")
-
-    orig = nil
-
-    # If we can't write to the path, then just don't bother with this plugin
-    begin
-      File.write(path, "") unless File.exist?(path)
-      orig = File.stat(path).mtime
-    rescue SystemCallError
-      return
-    end
-
-    in_background do
-      while true
-        sleep 2
-
-        begin
-          mtime = File.stat(path).mtime
-        rescue SystemCallError
-          # If the file has disappeared, assume that means don't restart
-        else
-          if mtime > orig
-            launcher.restart
-            break
-          end
-        end
-      end
-    end
-  end
-end

data/lib/puma/plugin.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module Puma
-  class UnknownPlugin < RuntimeError; end
-
-  class PluginLoader
-    def initialize
-      @instances = []
-    end
-
-    def create(name)
-      if cls = Plugins.find(name)
-        plugin = cls.new
-        @instances << plugin
-        return plugin
-      end
-
-      raise UnknownPlugin, "File failed to register properly named plugin"
-    end
-
-    def fire_starts(launcher)
-      @instances.each do |i|
-        if i.respond_to? :start
-          i.start(launcher)
-        end
-      end
-    end
-  end
-
-  class PluginRegistry
-    def initialize
-      @plugins = {}
-      @background = []
-    end
-
-    def register(name, cls)
-      @plugins[name] = cls
-    end
-
-    def find(name)
-      name = name.to_s
-
-      if cls = @plugins[name]
-        return cls
-      end
-
-      begin
-        require "puma/plugin/#{name}"
-      rescue LoadError
-        raise UnknownPlugin, "Unable to find plugin: #{name}"
-      end
-
-      if cls = @plugins[name]
-        return cls
-      end
-
-      raise UnknownPlugin, "file failed to register a plugin"
-    end
-
-    def add_background(blk)
-      @background << blk
-    end
-
-    def fire_background
-      @background.each_with_index do |b, i|
-        Thread.new do
-          Puma.set_thread_name "plgn bg #{i}"
-          b.call
-        end
-      end
-    end
-  end
-
-  Plugins = PluginRegistry.new
-
-  class Plugin
-    # Matches
-    #  "C:/Ruby22/lib/ruby/gems/2.2.0/gems/puma-3.0.1/lib/puma/plugin/tmp_restart.rb:3:in `<top (required)>'"
-    #  AS
-    #  C:/Ruby22/lib/ruby/gems/2.2.0/gems/puma-3.0.1/lib/puma/plugin/tmp_restart.rb
-    CALLER_FILE = /
-      \A       # start of string
-      .+       # file path (one or more characters)
-      (?=      # stop previous match when
-        :\d+     # a colon is followed by one or more digits
-        :in      # followed by a colon followed by in
-      )
-    /x
-
-    def self.extract_name(ary)
-      path = ary.first[CALLER_FILE]
-
-      m = %r!puma/plugin/([^/]*)\.rb$!.match(path)
-      m[1]
-    end
-
-    def self.create(&blk)
-      name = extract_name(caller)
-
-      cls = Class.new(self)
-
-      cls.class_eval(&blk)
-
-      Plugins.register name, cls
-    end
-
-    def in_background(&blk)
-      Plugins.add_background blk
-    end
-  end
-end

data/lib/puma/rack/builder.rb

@@ -1,297 +0,0 @@
-# frozen_string_literal: true
-
-module Puma
-end
-
-module Puma::Rack
-  class Options
-    def parse!(args)
-      options = {}
-      opt_parser = OptionParser.new("", 24, '  ') do |opts|
-        opts.banner = "Usage: rackup [ruby options] [rack options] [rackup config]"
-
-        opts.separator ""
-        opts.separator "Ruby options:"
-
-        lineno = 1
-        opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
-          eval line, TOPLEVEL_BINDING, "-e", lineno
-          lineno += 1
-        }
-
-        opts.on("-b", "--builder BUILDER_LINE", "evaluate a BUILDER_LINE of code as a builder script") { |line|
-          options[:builder] = line
-        }
-
-        opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
-          options[:debug] = true
-        }
-        opts.on("-w", "--warn", "turn warnings on for your script") {
-          options[:warn] = true
-        }
-        opts.on("-q", "--quiet", "turn off logging") {
-          options[:quiet] = true
-        }
-
-        opts.on("-I", "--include PATH",
-                "specify $LOAD_PATH (may be used more than once)") { |path|
-          (options[:include] ||= []).concat(path.split(":"))
-        }
-
-        opts.on("-r", "--require LIBRARY",
-                "require the library, before executing your script") { |library|
-          options[:require] = library
-        }
-
-        opts.separator ""
-        opts.separator "Rack options:"
-        opts.on("-s", "--server SERVER", "serve using SERVER (thin/puma/webrick/mongrel)") { |s|
-          options[:server] = s
-        }
-
-        opts.on("-o", "--host HOST", "listen on HOST (default: localhost)") { |host|
-          options[:Host] = host
-        }
-
-        opts.on("-p", "--port PORT", "use PORT (default: 9292)") { |port|
-          options[:Port] = port
-        }
-
-        opts.on("-O", "--option NAME[=VALUE]", "pass VALUE to the server as option NAME. If no VALUE, sets it to true. Run '#{$0} -s SERVER -h' to get a list of options for SERVER") { |name|
-          name, value = name.split('=', 2)
-          value = true if value.nil?
-          options[name.to_sym] = value
-        }
-
-        opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development)") { |e|
-          options[:environment] = e
-        }
-
-        opts.on("-P", "--pid FILE", "file to store PID") { |f|
-          options[:pid] = ::File.expand_path(f)
-        }
-
-        opts.separator ""
-        opts.separator "Common options:"
-
-        opts.on_tail("-h", "-?", "--help", "Show this message") do
-          puts opts
-          puts handler_opts(options)
-
-          exit
-        end
-
-        opts.on_tail("--version", "Show version") do
-          puts "Rack #{Rack.version} (Release: #{Rack.release})"
-          exit
-        end
-      end
-
-      begin
-        opt_parser.parse! args
-      rescue OptionParser::InvalidOption => e
-        warn e.message
-        abort opt_parser.to_s
-      end
-
-      options[:config] = args.last if args.last
-      options
-    end
-
-    def handler_opts(options)
-      begin
-        info = []
-        server = Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
-        if server&.respond_to?(:valid_options)
-          info << ""
-          info << "Server-specific options for #{server.name}:"
-
-          has_options = false
-          server.valid_options.each do |name, description|
-            next if /^(Host|Port)[^a-zA-Z]/.match? name.to_s  # ignore handler's host and port options, we do our own.
-
-            info << "  -O %-21s %s" % [name, description]
-            has_options = true
-          end
-          return "" if !has_options
-        end
-        info.join("\n")
-      rescue NameError
-        return "Warning: Could not find handler specified (#{options[:server] || 'default'}) to determine handler-specific options"
-      end
-    end
-  end
-
-  # Rack::Builder implements a small DSL to iteratively construct Rack
-  # applications.
-  #
-  # Example:
-  #
-  #  require 'rack/lobster'
-  #  app = Rack::Builder.new do
-  #    use Rack::CommonLogger
-  #    use Rack::ShowExceptions
-  #    map "/lobster" do
-  #      use Rack::Lint
-  #      run Rack::Lobster.new
-  #    end
-  #  end
-  #
-  #  run app
-  #
-  # Or
-  #
-  #  app = Rack::Builder.app do
-  #    use Rack::CommonLogger
-  #    run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
-  #  end
-  #
-  #  run app
-  #
-  # +use+ adds middleware to the stack, +run+ dispatches to an application.
-  # You can use +map+ to construct a Rack::URLMap in a convenient way.
-
-  class Builder
-    def self.parse_file(config, opts = Options.new)
-      options = {}
-      if config =~ /\.ru$/
-        cfgfile = ::File.read(config)
-        if cfgfile[/^#\\(.*)/] && opts
-          options = opts.parse! $1.split(/\s+/)
-        end
-        cfgfile.sub!(/^__END__\n.*\Z/m, '')
-        app = new_from_string cfgfile, config
-      else
-        require config
-        app = Object.const_get(::File.basename(config, '.rb').capitalize)
-      end
-      [app, options]
-    end
-
-    def self.new_from_string(builder_script, file="(rackup)")
-      eval "Puma::Rack::Builder.new {\n" + builder_script + "\n}.to_app",
-        TOPLEVEL_BINDING, file, 0
-    end
-
-    def initialize(default_app = nil, &block)
-      @use, @map, @run, @warmup = [], nil, default_app, nil
-
-      # Conditionally load rack now, so that any rack middlewares,
-      # etc are available.
-      begin
-        require 'rack'
-      rescue LoadError
-      end
-
-      instance_eval(&block) if block
-    end
-
-    def self.app(default_app = nil, &block)
-      self.new(default_app, &block).to_app
-    end
-
-    # Specifies middleware to use in a stack.
-    #
-    #   class Middleware
-    #     def initialize(app)
-    #       @app = app
-    #     end
-    #
-    #     def call(env)
-    #       env["rack.some_header"] = "setting an example"
-    #       @app.call(env)
-    #     end
-    #   end
-    #
-    #   use Middleware
-    #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
-    #
-    # All requests through to this application will first be processed by the middleware class.
-    # The +call+ method in this example sets an additional environment key which then can be
-    # referenced in the application if required.
-    def use(middleware, *args, &block)
-      if @map
-        mapping, @map = @map, nil
-        @use << proc { |app| generate_map app, mapping }
-      end
-      @use << proc { |app| middleware.new(app, *args, &block) }
-    end
-
-    # Takes an argument that is an object that responds to #call and returns a Rack response.
-    # The simplest form of this is a lambda object:
-    #
-    #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
-    #
-    # However this could also be a class:
-    #
-    #   class Heartbeat
-    #     def self.call(env)
-    #      [200, { "Content-Type" => "text/plain" }, ["OK"]]
-    #    end
-    #   end
-    #
-    #   run Heartbeat
-    def run(app)
-      @run = app
-    end
-
-    # Takes a lambda or block that is used to warm-up the application.
-    #
-    #   warmup do |app|
-    #     client = Rack::MockRequest.new(app)
-    #     client.get('/')
-    #   end
-    #
-    #   use SomeMiddleware
-    #   run MyApp
-    def warmup(prc=nil, &block)
-      @warmup = prc || block
-    end
-
-    # Creates a route within the application.
-    #
-    #   Rack::Builder.app do
-    #     map '/' do
-    #       run Heartbeat
-    #     end
-    #   end
-    #
-    # The +use+ method can also be used here to specify middleware to run under a specific path:
-    #
-    #   Rack::Builder.app do
-    #     map '/' do
-    #       use Middleware
-    #       run Heartbeat
-    #     end
-    #   end
-    #
-    # This example includes a piece of middleware which will run before requests hit +Heartbeat+.
-    #
-    def map(path, &block)
-      @map ||= {}
-      @map[path] = block
-    end
-
-    def to_app
-      app = @map ? generate_map(@run, @map) : @run
-      fail "missing run or map statement" unless app
-      app = @use.reverse.inject(app) { |a,e| e[a] }
-      @warmup&.call app
-      app
-    end
-
-    def call(env)
-      to_app.call(env)
-    end
-
-    private
-
-    def generate_map(default_app, mapping)
-      require_relative 'urlmap'
-
-      mapped = default_app ? {'/' => default_app} : {}
-      mapping.each { |r,b| mapped[r] = self.class.new(default_app, &b).to_app }
-      URLMap.new(mapped)
-    end
-  end
-end

data/lib/puma/rack/urlmap.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module Puma::Rack
-  # Rack::URLMap takes a hash mapping urls or paths to apps, and
-  # dispatches accordingly.  Support for HTTP/1.1 host names exists if
-  # the URLs start with <tt>http://</tt> or <tt>https://</tt>.
-  #
-  # URLMap modifies the SCRIPT_NAME and PATH_INFO such that the part
-  # relevant for dispatch is in the SCRIPT_NAME, and the rest in the
-  # PATH_INFO.  This should be taken care of when you need to
-  # reconstruct the URL in order to create links.
-  #
-  # URLMap dispatches in such a way that the longest paths are tried
-  # first, since they are most specific.
-
-  class URLMap
-    NEGATIVE_INFINITY = -1.0 / 0.0
-    INFINITY = 1.0 / 0.0
-
-    def initialize(map = {})
-      remap(map)
-    end
-
-    def remap(map)
-      @mapping = map.map { |location, app|
-        if location =~ %r{\Ahttps?://(.*?)(/.*)}
-          host, location = $1, $2
-        else
-          host = nil
-        end
-
-        unless location[0] == ?/
-          raise ArgumentError, "paths need to start with /"
-        end
-
-        location = location.chomp('/')
-        match = Regexp.new("^#{Regexp.quote(location).gsub('/', '/+')}(.*)", Regexp::NOENCODING)
-
-        [host, location, match, app]
-      }.sort_by do |(host, location, _, _)|
-        [host ? -host.size : INFINITY, -location.size]
-      end
-    end
-
-    def call(env)
-      path = env['PATH_INFO']
-      script_name = env['SCRIPT_NAME']
-      http_host = env['HTTP_HOST']
-      server_name = env['SERVER_NAME']
-      server_port = env['SERVER_PORT']
-
-      is_same_server = casecmp?(http_host, server_name) ||
-                    casecmp?(http_host, "#{server_name}:#{server_port}")
-
-      @mapping.each do |host, location, match, app|
-        unless casecmp?(http_host, host) \
-            || casecmp?(server_name, host) \
-            || (!host && is_same_server)
-          next
-        end
-
-        next unless m = match.match(path.to_s)
-
-        rest = m[1]
-        next unless !rest || rest.empty? || rest[0] == ?/
-
-        env['SCRIPT_NAME'] = (script_name + location)
-        env['PATH_INFO'] = rest
-
-        return app.call(env)
-      end
-
-      [404, {'Content-Type' => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]
-
-    ensure
-      env['PATH_INFO'] = path
-      env['SCRIPT_NAME'] = script_name
-    end
-
-    private
-    def casecmp?(v1, v2)
-      # if both nil, or they're the same string
-      return true if v1 == v2
-
-      # if either are nil... (but they're not the same)
-      return false if v1.nil?
-      return false if v2.nil?
-
-      # otherwise check they're not case-insensitive the same
-      v1.casecmp(v2).zero?
-    end
-  end
-end

data/lib/puma/rack_default.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../rack/handler/puma'
-
-# rackup was removed in Rack 3, it is now a separate gem
-if Object.const_defined? :Rackup
-  module Rackup
-    module Handler
-      def self.default(options = {})
-        ::Rackup::Handler::Puma
-      end
-    end
-  end
-elsif Object.const_defined?(:Rack) && Rack.release < '3'
-  module Rack
-    module Handler
-      def self.default(options = {})
-        ::Rack::Handler::Puma
-      end
-    end
-  end
-else
-  raise "Rack 3 must be used with the Rackup gem"
-end

data/lib/puma/reactor.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Puma
-  class UnsupportedBackend < StandardError; end
-
-  # Monitors a collection of IO objects, calling a block whenever
-  # any monitored object either receives data or times out, or when the Reactor shuts down.
-  #
-  # The waiting/wake up is performed with nio4r, which will use the appropriate backend (libev,
-  # Java NIO or just plain IO#select). The call to `NIO::Selector#select` will
-  # 'wakeup' any IO object that receives data.
-  #
-  # This class additionally tracks a timeout for every added object,
-  # and wakes up any object when its timeout elapses.
-  #
-  # The implementation uses a Queue to synchronize adding new objects from the internal select loop.
-  class Reactor
-    # Create a new Reactor to monitor IO objects added by #add.
-    # The provided block will be invoked when an IO has data available to read,
-    # its timeout elapses, or when the Reactor shuts down.
-    def initialize(backend, &block)
-      require 'nio'
-      valid_backends = [:auto, *::NIO::Selector.backends]
-      unless valid_backends.include?(backend)
-        raise ArgumentError.new("unsupported IO selector backend: #{backend} (available backends: #{valid_backends.join(', ')})")
-      end
-
-      @selector = ::NIO::Selector.new(NIO::Selector.backends.delete(backend))
-      @input = Queue.new
-      @timeouts = []
-      @block = block
-    end
-
-    # Run the internal select loop, using a background thread by default.
-    def run(background=true)
-      if background
-        @thread = Thread.new do
-          Puma.set_thread_name "reactor"
-          select_loop
-        end
-      else
-        select_loop
-      end
-    end
-
-    # Add a new client to monitor.
-    # The object must respond to #timeout and #timeout_at.
-    # Returns false if the reactor is already shut down.
-    def add(client)
-      @input << client
-      @selector.wakeup
-      true
-    rescue ClosedQueueError, IOError # Ignore if selector is already closed
-      false
-    end
-
-    # Shutdown the reactor, blocking until the background thread is finished.
-    def shutdown
-      @input.close
-      begin
-        @selector.wakeup
-      rescue IOError # Ignore if selector is already closed
-      end
-      @thread&.join
-    end
-
-    private
-
-    def select_loop
-      close_selector = true
-      begin
-        until @input.closed? && @input.empty?
-          # Wakeup any registered object that receives incoming data.
-          # Block until the earliest timeout or Selector#wakeup is called.
-          timeout = (earliest = @timeouts.first) && earliest.timeout
-          @selector.select(timeout) {|mon| wakeup!(mon.value)}
-
-          # Wakeup all objects that timed out.
-          timed_out = @timeouts.take_while {|t| t.timeout == 0}
-          timed_out.each { |c| wakeup! c }
-
-          unless @input.empty?
-            until @input.empty?
-              client = @input.pop
-              register(client) if client.io_ok?
-            end
-            @timeouts.sort_by!(&:timeout_at)
-          end
-        end
-      rescue StandardError => e
-        STDERR.puts "Error in reactor loop escaped: #{e.message} (#{e.class})"
-        STDERR.puts e.backtrace
-
-        # NoMethodError may be rarely raised when calling @selector.select, which
-        # is odd.  Regardless, it may continue for thousands of calls if retried.
-        # Also, when it raises, @selector.close also raises an error.
-        if NoMethodError === e
-          close_selector = false
-        else
-          retry
-        end
-      end
-      # Wakeup all remaining objects on shutdown.
-      @timeouts.each(&@block)
-      @selector.close if close_selector
-    end
-
-    # Start monitoring the object.
-    def register(client)
-      @selector.register(client.to_io, :r).value = client
-      @timeouts << client
-    rescue ArgumentError
-      # unreadable clients raise error when processed by NIO
-    end
-
-    # 'Wake up' a monitored object by calling the provided block.
-    # Stop monitoring the object if the block returns `true`.
-    def wakeup!(client)
-      if @block.call client
-        @selector.deregister client.to_io
-        @timeouts.delete client
-      end
-    end
-  end
-end