rsense-server 0.5.0

data/vendor/gems/puma-2.8.2-java/lib/puma/null_io.rb

@@ -0,0 +1,34 @@
+module Puma
+
+  # Provides an IO-like object that always appears to contain no data.
+  # Used as the value for rack.input when the request has no body.
+  #
+  class NullIO
+    # Always returns nil
+    #
+    def gets
+      nil
+    end
+
+    # Never yields
+    #
+    def each
+    end
+
+    # Mimics IO#read with no data
+    #
+    def read(count=nil,buffer=nil)
+      (count && count > 0) ? nil : ""
+    end
+
+    # Does nothing
+    #
+    def rewind
+    end
+
+    # Does nothing
+    #
+    def close
+    end
+  end
+end

data/vendor/gems/puma-2.8.2-java/lib/puma/rack_default.rb

@@ -0,0 +1,7 @@
+require 'rack/handler/puma'
+
+module Rack::Handler
+  def self.default(options = {})
+    Rack::Handler::Puma
+  end
+end

data/vendor/gems/puma-2.8.2-java/lib/puma/rack_patch.rb

@@ -0,0 +1,45 @@
+require 'rack/commonlogger'
+
+module Rack
+  # Patch CommonLogger to use after_reply.
+  #
+  # Simply request this file and CommonLogger will be a bit more 
+  # efficient.
+  class CommonLogger
+    remove_method :call
+
+    def call(env)
+      began_at = Time.now
+      status, header, body = @app.call(env)
+      header = Utils::HeaderHash.new(header)
+
+      # If we've been hijacked, then output a special line
+      if env['rack.hijack_io']
+        log_hijacking(env, 'HIJACK', header, began_at)
+      elsif ary = env['rack.after_reply']
+        ary << lambda { log(env, status, header, began_at) }
+      else
+        body = BodyProxy.new(body) { log(env, status, header, began_at) }
+      end
+
+      [status, header, body]
+    end
+
+    HIJACK_FORMAT = %{%s - %s [%s] "%s %s%s %s" HIJACKED -1 %0.4f\n}
+
+    def log_hijacking(env, status, header, began_at)
+      now = Time.now
+
+      logger = @logger || env['rack.errors']
+      logger.write HIJACK_FORMAT % [
+        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
+        env["REMOTE_USER"] || "-",
+        now.strftime("%d/%b/%Y %H:%M:%S"),
+        env["REQUEST_METHOD"],
+        env["PATH_INFO"],
+        env["QUERY_STRING"].empty? ? "" : "?"+env["QUERY_STRING"],
+        env["HTTP_VERSION"],
+        now - began_at ]
+    end
+  end
+end

data/vendor/gems/puma-2.8.2-java/lib/puma/reactor.rb

@@ -0,0 +1,183 @@
+require 'puma/util'
+
+module Puma
+  class Reactor
+    DefaultSleepFor = 5
+
+    def initialize(server, app_pool)
+      @server = server
+      @events = server.events
+      @app_pool = app_pool
+
+      @mutex = Mutex.new
+      @ready, @trigger = Puma::Util.pipe
+      @input = []
+      @sleep_for = DefaultSleepFor
+      @timeouts = []
+
+      @sockets = [@ready]
+    end
+
+    private
+
+    def run_internal
+      sockets = @sockets
+
+      while true
+        begin
+          ready = IO.select sockets, nil, nil, @sleep_for
+        rescue IOError => e
+          if sockets.any? { |socket| socket.closed? }
+            STDERR.puts "Error in select: #{e.message} (#{e.class})"
+            STDERR.puts e.backtrace
+            sockets = sockets.reject { |socket| socket.closed? }
+            retry
+          else
+            raise
+          end
+        end
+
+        if ready and reads = ready[0]
+          reads.each do |c|
+            if c == @ready
+              @mutex.synchronize do
+                case @ready.read(1)
+                when "*"
+                  sockets += @input
+                  @input.clear
+                when "c"
+                  sockets.delete_if do |s|
+                    if s == @ready
+                      false
+                    else
+                      s.close
+                      true
+                    end
+                  end
+                when "!"
+                  return
+                end
+              end
+            else
+              # We have to be sure to remove it from the timeout
+              # list or we'll accidentally close the socket when
+              # it's in use!
+              if c.timeout_at
+                @mutex.synchronize do
+                  @timeouts.delete c
+                end
+              end
+
+              begin
+                if c.try_to_finish
+                  @app_pool << c
+                  sockets.delete c
+                end
+
+              # The client doesn't know HTTP well
+              rescue HttpParserError => e
+                c.write_400
+                c.close
+
+                sockets.delete c
+
+                @events.parse_error @server, c.env, e
+              rescue StandardError => e
+                c.write_500
+                c.close
+
+                sockets.delete c
+              end
+            end
+          end
+        end
+
+        unless @timeouts.empty?
+          @mutex.synchronize do
+            now = Time.now
+
+            while @timeouts.first.timeout_at < now
+              c = @timeouts.shift
+              c.write_408 if c.in_data_phase
+              c.close
+              sockets.delete c
+
+              break if @timeouts.empty?
+            end
+
+            calculate_sleep
+          end
+        end
+      end
+    end
+
+    public
+
+    def run
+      run_internal
+    ensure
+      @trigger.close
+      @ready.close
+    end
+
+    def run_in_thread
+      @thread = Thread.new do
+        begin
+          run_internal
+        rescue StandardError => e
+          STDERR.puts "Error in reactor loop escaped: #{e.message} (#{e.class})"
+          STDERR.puts e.backtrace
+          retry
+        ensure
+          @trigger.close
+          @ready.close
+        end
+      end
+    end
+
+    def calculate_sleep
+      if @timeouts.empty?
+        @sleep_for = DefaultSleepFor
+      else
+        diff = @timeouts.first.timeout_at.to_f - Time.now.to_f
+
+        if diff < 0.0
+          @sleep_for = 0
+        else
+          @sleep_for = diff
+        end
+      end
+    end
+
+    def add(c)
+      @mutex.synchronize do
+        @input << c
+        @trigger << "*"
+
+        if c.timeout_at
+          @timeouts << c
+          @timeouts.sort! { |a,b| a.timeout_at <=> b.timeout_at }
+
+          calculate_sleep
+        end
+      end
+    end
+
+    # Close all watched sockets and clear them from being watched
+    def clear!
+      begin
+        @trigger << "c"
+      rescue IOError
+      end
+    end
+
+    def shutdown
+      begin
+        @trigger << "!"
+      rescue IOError
+      end
+
+      @thread.join
+    end
+  end
+end

data/vendor/gems/puma-2.8.2-java/lib/puma/runner.rb

@@ -0,0 +1,146 @@
+module Puma
+  class Runner
+    def initialize(cli)
+      @cli = cli
+      @options = cli.options
+      @app = nil
+      @control = nil
+    end
+
+    def daemon?
+      @options[:daemon]
+    end
+
+    def development?
+      @options[:environment] == "development"
+    end
+
+    def log(str)
+      @cli.log str
+    end
+
+    def error(str)
+      @cli.error str
+    end
+
+    def before_restart
+      @control.stop(true) if @control
+    end
+
+    def start_control
+      str = @options[:control_url]
+      return unless str
+
+      require 'puma/app/status'
+
+      uri = URI.parse str
+
+      app = Puma::App::Status.new @cli
+
+      if token = @options[:control_auth_token]
+        app.auth_token = token unless token.empty? or token == :none
+      end
+
+      control = Puma::Server.new app, @cli.events
+      control.min_threads = 0
+      control.max_threads = 1
+
+      case uri.scheme
+      when "tcp"
+        log "* Starting control server on #{str}"
+        control.add_tcp_listener uri.host, uri.port
+      when "unix"
+        log "* Starting control server on #{str}"
+        path = "#{uri.host}#{uri.path}"
+
+        control.add_unix_listener path
+      else
+        error "Invalid control URI: #{str}"
+      end
+
+      control.run
+      @control = control
+    end
+
+    def ruby_engine
+      if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
+        "ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+      else
+        "#{RUBY_ENGINE} #{RUBY_VERSION}"
+      end
+    end
+
+    def output_header(mode)
+      min_t = @options[:min_threads]
+      max_t = @options[:max_threads]
+
+      log "Puma starting in #{mode} mode..."
+      log "* Version #{Puma::Const::PUMA_VERSION} (#{ruby_engine}), codename: #{Puma::Const::CODE_NAME}"
+      log "* Min threads: #{min_t}, max threads: #{max_t}"
+      log "* Environment: #{ENV['RACK_ENV']}"
+
+      if @options[:mode] == :tcp
+        log "* Mode: Lopez Express (tcp)"
+      end
+    end
+
+    def redirect_io
+      stdout = @options[:redirect_stdout]
+      stderr = @options[:redirect_stderr]
+      append = @options[:redirect_append]
+
+      if stdout
+        STDOUT.reopen stdout, (append ? "a" : "w")
+        STDOUT.sync = true
+        STDOUT.puts "=== puma startup: #{Time.now} ==="
+      end
+
+      if stderr
+        STDERR.reopen stderr, (append ? "a" : "w")
+        STDERR.sync = true
+        STDERR.puts "=== puma startup: #{Time.now} ==="
+      end
+    end
+
+    def load_and_bind
+      unless @cli.config.app_configured?
+        error "No application configured, nothing to run"
+        exit 1
+      end
+
+      # Load the app before we daemonize.
+      begin
+        @app = @cli.config.app
+      rescue Exception => e
+        log "! Unable to load application"
+        raise e
+      end
+
+      @cli.binder.parse @options[:binds], self
+    end
+
+    def app
+      @app ||= @cli.config.app
+    end
+
+    def start_server
+      min_t = @options[:min_threads]
+      max_t = @options[:max_threads]
+
+      server = Puma::Server.new app, @cli.events, @options
+      server.min_threads = min_t
+      server.max_threads = max_t
+      server.inherit_binder @cli.binder
+
+      if @options[:mode] == :tcp
+        server.tcp_mode!
+      end
+
+      unless development?
+        server.leak_stack_on_error = false
+      end
+
+      server
+    end
+  end
+end