rsense-server 0.5.0

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

@@ -0,0 +1,251 @@
+require 'optparse'
+require 'puma/const'
+require 'puma/configuration'
+require 'yaml'
+require 'uri'
+require 'socket'
+module Puma
+  class ControlCLI
+
+    COMMANDS = %w{halt restart phased-restart start stats status stop}
+
+    def is_windows?
+      RUBY_PLATFORM =~ /(win|w)32$/ ? true : false
+    end
+
+    def initialize(argv, stdout=STDOUT, stderr=STDERR)
+      @argv = argv
+      @stdout = stdout
+      @stderr = stderr
+      @options = {}
+
+      opts = OptionParser.new do |o|
+        o.banner = "Usage: pumactl (-p PID | -P pidfile | -S status_file | -C url -T token | -F config.rb) (#{COMMANDS.join("|")})"
+
+        o.on "-S", "--state PATH", "Where the state file to use is" do |arg|
+          @options[:state] = arg
+        end
+
+        o.on "-Q", "--quiet", "Not display messages" do |arg|
+          @options[:quiet_flag] = true
+        end
+
+        o.on "-P", "--pidfile PATH", "Pid file" do |arg|
+          @options[:pidfile] = arg
+        end
+
+        o.on "-p", "--pid PID", "Pid" do |arg|
+          @options[:pid] = arg.to_i
+        end
+
+        o.on "-C", "--control-url URL", "The bind url to use for the control server" do |arg|
+          @options[:control_url] = arg
+        end
+
+        o.on "-T", "--control-token TOKEN", "The token to use as authentication for the control server" do |arg|
+          @options[:control_auth_token] = arg
+        end
+
+        o.on "-F", "--config-file PATH", "Puma config script" do |arg|
+          @options[:config_file] = arg
+        end
+
+        o.on_tail("-H", "--help", "Show this message") do
+          @stdout.puts o
+          exit
+        end
+
+        o.on_tail("-V", "--version", "Show version") do
+          puts Const::PUMA_VERSION
+          exit
+        end
+      end
+
+      opts.order!(argv) { |a| opts.terminate a }
+
+      command = argv.shift
+      @options[:command] = command if command
+
+      Puma::Configuration.new(@options).load if @options[:config_file]
+
+      # check present of command
+      unless @options[:command]
+        raise "Available commands: #{COMMANDS.join(", ")}"
+      end
+
+      unless COMMANDS.include? @options[:command]
+        raise "Invalid command: #{@options[:command]}"
+      end
+
+    rescue => e
+      @stdout.puts e.message
+      exit 1
+    end
+
+    def message(msg)
+      @stdout.puts msg unless @options[:quiet_flag]
+    end
+
+    def prepare_configuration
+      if @options.has_key? :state
+        unless File.exist? @options[:state]
+          raise "Status file not found: #{@options[:state]}"
+        end
+
+        status = YAML.load File.read(@options[:state])
+
+        if status.kind_of?(Hash) && status.has_key?("config")
+
+          conf = status["config"]
+
+          # get control_url
+          if url = conf.options[:control_url]
+            @options[:control_url] = url
+          end
+
+          # get control_auth_token
+          if token = conf.options[:control_auth_token]
+            @options[:control_auth_token] = token
+          end
+
+          # get pid
+          @options[:pid] = status["pid"].to_i
+        else
+          raise "Invalid status file: #{@options[:state]}"
+        end
+
+      elsif @options.has_key? :pidfile
+        # get pid from pid_file
+        @options[:pid] = File.open(@options[:pidfile]).gets.to_i
+      end
+    end
+
+    def send_request
+      uri = URI.parse @options[:control_url]
+
+      # create server object by scheme
+      @server = case uri.scheme
+                when "tcp"
+                  TCPSocket.new uri.host, uri.port
+                when "unix"
+                  UNIXSocket.new "#{uri.host}#{uri.path}"
+                else
+                  raise "Invalid scheme: #{uri.scheme}"
+                end
+
+      if @options[:command] == "status"
+        message "Puma is started"
+      else
+        url = "/#{@options[:command]}"
+
+        if @options.has_key?(:control_auth_token)
+          url = url + "?token=#{@options[:control_auth_token]}"
+        end
+
+        @server << "GET #{url} HTTP/1.0\r\n\r\n"
+
+        unless data = @server.read
+          raise "Server closed connection before responding"
+        end
+
+        response = data.split("\r\n")
+
+        if response.empty?
+          raise "Server sent empty response"
+        end
+
+        (@http,@code,@message) = response.first.split(" ",3)
+
+        if @code == "403"
+          raise "Unauthorized access to server (wrong auth token)"
+        elsif @code == "404"
+          raise "Command error: #{response.last}"
+        elsif @code != "200"
+          raise "Bad response from server: #{@code}"
+        end
+
+        message "Command #{@options[:command]} sent success"
+        message response.last if @options[:command] == "stats"
+      end
+
+      @server.close
+    end
+
+    def send_signal
+      unless pid = @options[:pid]
+        raise "Neither pid nor control url available"
+      end
+
+      begin
+        Process.getpgid pid
+      rescue SystemCallError
+        if @options[:command] == "restart"
+          @options.delete(:command)
+          start
+        else
+          raise "No pid '#{pid}' found"
+        end
+      end
+
+      case @options[:command]
+      when "restart"
+        Process.kill "SIGUSR2", pid
+
+      when "halt"
+        Process.kill "QUIT", pid
+
+      when "stop"
+        Process.kill "SIGTERM", pid
+
+      when "stats"
+        puts "Stats not available via pid only"
+        return
+
+      when "phased-restart"
+        Process.kill "SIGUSR1", pid
+
+      else
+        message "Puma is started"
+        return
+      end
+
+      message "Command #{@options[:command]} sent success"
+    end
+
+    def run
+      start if @options[:command] == "start"
+
+      prepare_configuration
+
+      if is_windows?
+        send_request
+      else
+        @options.has_key?(:control_url) ? send_request : send_signal
+      end
+
+    rescue => e
+      message e.message
+      exit 1
+    end
+
+  private
+    def start
+      require 'puma/cli'
+
+      run_args = @argv
+
+      if path = @options[:state]
+        run_args = ["-S", path] + run_args
+      end
+
+      if path = @options[:config_file]
+        run_args = ["-C", path] + run_args
+      end
+
+      events = Puma::Events.new @stdout, @stderr
+
+      cli = Puma::CLI.new run_args, events
+      cli.run
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Process
+
+  # This overrides the default version because it is broken if it
+  # exists.
+
+  def self.daemon(nochdir=false, noclose=false)
+    exit if fork                     # Parent exits, child continues.
+
+    Process.setsid                   # Become session leader.
+
+    exit if fork                     # Zap session leader. See [1].
+
+    Dir.chdir "/" unless nochdir     # Release old working directory.
+
+    if !noclose
+      STDIN.reopen File.open("/dev/null", "r")
+
+      null_out = File.open "/dev/null", "w"
+      STDOUT.reopen null_out
+      STDERR.reopen null_out
+    end
+
+    0
+  end
+end

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

@@ -0,0 +1,11 @@
+module Puma
+  module Delegation
+    def forward(what, who)
+      module_eval <<-CODE
+        def #{what}(*args, &block)
+          #{who}.#{what}(*args, &block)
+        end
+      CODE
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+module Puma
+  IS_JRUBY = defined?(JRUBY_VERSION)
+end
+

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

@@ -0,0 +1,130 @@
+require 'puma/const'
+require 'stringio'
+
+module Puma
+  # The default implement of an event sink object used by Server
+  # for when certain kinds of events occur in the life of the server.
+  #
+  # The methods available are the events that the Server fires.
+  #
+  class Events
+
+    include Const
+
+    # Create an Events object that prints to +stdout+ and +stderr+.
+    #
+    def initialize(stdout, stderr)
+      @stdout = stdout
+      @stderr = stderr
+
+      @stdout.sync = true
+      @stderr.sync = true
+
+      @debug = ENV.key? 'PUMA_DEBUG'
+
+      @on_booted = []
+
+      @hooks = Hash.new { |h,k| h[k] = [] }
+    end
+
+    attr_reader :stdout, :stderr
+
+    # Fire callbacks for the named hook
+    #
+    def fire(hook, *args)
+      @hooks[hook].each { |t| t.call(*args) }
+    end
+
+    # Register a callbock for a given hook
+    #
+    def register(hook, obj=nil, &blk)
+      if obj and blk
+        raise "Specify either an object or a block, not both"
+      end
+
+      h = obj || blk
+
+      @hooks[hook] << h
+
+      h
+    end
+
+    # Write +str+ to +@stdout+
+    #
+    def log(str)
+      @stdout.puts str
+    end
+
+    def write(str)
+      @stdout.write str
+    end
+
+    def debug(str)
+      log("% #{str}") if @debug
+    end
+
+    # Write +str+ to +@stderr+
+    #
+    def error(str)
+      @stderr.puts "ERROR: #{str}"
+      exit 1
+    end
+
+    # An HTTP parse error has occured.
+    # +server+ is the Server object, +env+ the request, and +error+ a
+    # parsing exception.
+    #
+    def parse_error(server, env, error)
+      @stderr.puts "#{Time.now}: HTTP parse error, malformed request (#{env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR]}): #{error.inspect}"
+      @stderr.puts "#{Time.now}: ENV: #{env.inspect}\n---\n"
+    end
+
+    # An unknown error has occured.
+    # +server+ is the Server object, +env+ the request, +error+ an exception
+    # object, and +kind+ some additional info.
+    #
+    def unknown_error(server, error, kind="Unknown")
+      if error.respond_to? :render
+        error.render "#{Time.now}: #{kind} error", @stderr
+      else
+        @stderr.puts "#{Time.now}: #{kind} error: #{error.inspect}"
+        @stderr.puts error.backtrace.join("\n")
+      end
+    end
+
+    def on_booted(&b)
+      @on_booted << b
+    end
+
+    def fire_on_booted!
+      @on_booted.each { |b| b.call }
+    end
+
+    DEFAULT = new(STDOUT, STDERR)
+
+    # Returns an Events object which writes it's status to 2 StringIO
+    # objects.
+    #
+    def self.strings
+      Events.new StringIO.new, StringIO.new
+    end
+
+    def self.stdio
+      Events.new $stdout, $stderr
+    end
+  end
+
+  class PidEvents < Events
+    def log(str)
+      super "[#{$$}] #{str}"
+    end
+
+    def write(str)
+      super "[#{$$}] #{str}"
+    end
+
+    def error(str)
+      super "[#{$$}] #{str}"
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+require 'puma/detect'
+
+if Puma::IS_JRUBY
+  require 'puma/java_io_buffer'
+else
+  require 'puma/puma_http11'
+end

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

@@ -0,0 +1,45 @@
+require 'java'
+
+# Conservative native JRuby/Java implementation of IOBuffer
+# backed by a ByteArrayOutputStream and conversion between
+# Ruby String and Java bytes
+module Puma
+  class JavaIOBuffer < java.io.ByteArrayOutputStream
+    field_reader :buf
+  end
+
+  class IOBuffer
+    BUF_DEFAULT_SIZE = 4096
+
+    def initialize
+      @buf = JavaIOBuffer.new(BUF_DEFAULT_SIZE)
+    end
+
+    def reset
+      @buf.reset
+    end
+
+    def <<(str)
+      bytes = str.to_java_bytes
+      @buf.write(bytes, 0, bytes.length)
+    end
+
+    def append(*strs)
+      strs.each { |s| self << s; }
+    end
+
+    def to_s
+      String.from_java_bytes @buf.to_byte_array
+    end
+
+    alias_method :to_str, :to_s
+
+    def used
+      @buf.size
+    end
+
+    def capacity
+      @buf.buf.length
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+require 'ffi'
+
+module Puma
+  module JRubyRestart
+    extend FFI::Library
+    ffi_lib 'c'
+
+    attach_function :execlp, [:string, :varargs], :int
+    attach_function :chdir, [:string], :int
+    attach_function :fork, [], :int
+    attach_function :exit, [:int], :void
+    attach_function :setsid, [], :int
+
+    def self.chdir_exec(dir, argv)
+      chdir(dir)
+      cmd = argv.first
+      argv = ([:string] * argv.size).zip(argv).flatten
+      argv << :string
+      argv << nil
+      execlp(cmd, *argv)
+      raise SystemCallError.new(FFI.errno)
+    end
+
+    PermKey = 'PUMA_DAEMON_PERM'
+    RestartKey = 'PUMA_DAEMON_RESTART'
+
+    # Called to tell things "Your now always in daemon mode,
+    # don't try to reenter it."
+    #
+    def self.perm_daemonize
+      ENV[PermKey] = "1"
+    end
+
+    def self.daemon?
+      ENV.key?(PermKey) || ENV.key?(RestartKey)
+    end
+
+    def self.daemon_init
+      return true if ENV.key?(PermKey)
+
+      return false unless ENV.key? RestartKey
+
+      master = ENV[RestartKey]
+
+      # In case the master disappears early
+      begin
+        Process.kill "SIGUSR2", master.to_i
+      rescue SystemCallError => e
+      end
+
+      ENV[RestartKey] = ""
+
+      setsid
+
+      null = File.open "/dev/null", "w+"
+      STDIN.reopen null
+      STDOUT.reopen null
+      STDERR.reopen null
+
+      true
+    end
+
+    def self.daemon_start(dir, argv)
+      ENV['PUMA_DAEMON_RESTART'] = Process.pid.to_s
+
+      if k = ENV['PUMA_JRUBY_DAEMON_OPTS']
+        ENV['JRUBY_OPTS'] = k
+      end
+
+      cmd = argv.first
+      argv = ([:string] * argv.size).zip(argv).flatten
+      argv << :string
+      argv << nil
+
+      chdir(dir)
+      ret = fork
+      return ret if ret != 0
+      execlp(cmd, *argv)
+      raise SystemCallError.new(FFI.errno)
+    end
+  end
+end
+

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

@@ -0,0 +1,148 @@
+module Puma
+  module MiniSSL
+    class Socket
+      def initialize(socket, engine)
+        @socket = socket
+        @engine = engine
+      end
+
+      def to_io
+        @socket
+      end
+
+      def readpartial(size)
+        while true
+          output = @engine.read
+          return output if output
+
+          data = @socket.readpartial(size)
+          @engine.inject(data)
+          output = @engine.read
+
+          return output if output
+
+          while neg_data = @engine.extract
+            @socket.write neg_data
+          end
+        end
+      end
+
+      def engine_read_all
+        output = @engine.read
+        while output and additional_output = @engine.read
+          output << additional_output
+        end
+        output
+      end
+
+      def read_nonblock(size)
+        while true
+          output = engine_read_all
+          return output if output
+
+          data = @socket.read_nonblock(size)
+
+          @engine.inject(data)
+          output = engine_read_all
+
+          return output if output
+
+          while neg_data = @engine.extract
+            @socket.write neg_data
+          end
+        end
+      end
+
+      def write(data)
+        need = data.bytesize
+
+        while true
+          wrote = @engine.write data
+          enc = @engine.extract
+
+          while enc
+            @socket.write enc
+            enc = @engine.extract
+          end
+
+          need -= wrote
+
+          return data.bytesize if need == 0
+
+          data = data[need..-1]
+        end
+      end
+
+      alias_method :syswrite, :write
+
+      def flush
+        @socket.flush
+      end
+
+      def close
+        @socket.close
+      end
+
+      def peeraddr
+        @socket.peeraddr
+      end
+    end
+
+    class Context
+      attr_accessor :verify_mode
+
+      attr_reader :key
+      attr_reader :cert
+
+      def key=(key)
+        raise ArgumentError, "No such key file '#{key}'" unless File.exist? key
+        @key = key
+      end
+
+      def cert=(cert)
+        raise ArgumentError, "No such cert file '#{cert}'" unless File.exist? cert
+        @cert = cert
+      end
+    end
+
+    VERIFY_NONE = 0
+    VERIFY_PEER = 1
+
+    #if defined?(JRUBY_VERSION)
+    #class Engine
+    #def self.server(key, cert)
+    #new(key, cert)
+    #end
+    #end
+    #end
+
+    class Server
+      def initialize(socket, ctx)
+        @socket = socket
+        @ctx = ctx
+      end
+
+      def to_io
+        @socket
+      end
+
+      def accept
+        io = @socket.accept
+        engine = Engine.server @ctx.key, @ctx.cert
+
+        Socket.new io, engine
+      end
+
+      def accept_nonblock
+        io = @socket.accept_nonblock
+        engine = Engine.server @ctx.key, @ctx.cert
+
+        Socket.new io, engine
+      end
+
+      def close
+        @socket.close
+      end
+    end
+  end
+end