kirk 0.1.8-java → 0.2.0.beta.1-java

data/lib/kirk/builder.rb

@@ -1,143 +0,0 @@
-module Kirk
-  class MissingConfigFile < RuntimeError ; end
-  class MissingRackupFile < RuntimeError ; end
-
-  class Builder
-
-    VALID_LOG_LEVELS = %w(severe warning info config fine finer finest all)
-
-    attr_reader :options
-
-    def initialize(root = nil)
-      @root    = root || Dir.pwd
-      @current = nil
-      @configs = []
-      @options = {
-        :watcher => Applications::DeployWatcher.new("/tmp/kirk.sock")
-      }
-    end
-
-    def load(glob)
-      glob = expand_path(glob)
-
-      files = Dir[glob].select { |f| File.file?(f) }
-
-      if files.empty?
-        raise MissingConfigFile, "glob `#{glob}` did not match any files"
-      end
-
-      files.each do |file|
-        with_root File.dirname(file) do
-          instance_eval(File.read(file), file)
-        end
-      end
-    end
-
-    def log(opts = {})
-      level = opts[:level]
-      raise "Invalid log level" unless VALID_LOG_LEVELS.include?(level.to_s)
-      @options[:log_level] = level.to_s
-    end
-
-    def rack(rackup)
-      rackup = expand_path(rackup)
-
-      unless File.exist?(rackup)
-        raise MissingRackupFile, "rackup file `#{rackup}` does not exist"
-      end
-
-      @current = new_config
-      @current.rackup = rackup
-
-      yield if block_given?
-
-    ensure
-      @configs << @current
-      @current = nil
-    end
-
-    def env(env)
-      @current.env.merge!(env)
-    end
-
-    def hosts(*hosts)
-      @current.hosts.concat hosts
-    end
-
-    def listen(listen)
-      listen = listen.to_s
-      listen = ":#{listen}" unless listen.index(':')
-      listen = "0.0.0.0#{listen}" if listen.index(':') == 0
-
-      @current.listen = listen
-    end
-
-    def watch(*watch)
-      @current.watch = watch
-    end
-
-    def to_handler
-      handlers = @configs.map do |c|
-        Jetty::ContextHandler.new.tap do |ctx|
-          # Set the virtual hosts
-          unless c.hosts.empty?
-            ctx.set_virtual_hosts(c.hosts)
-          end
-
-          application = Applications::HotDeployable.new(c)
-          application.add_watcher(watcher)
-
-          ctx.set_connector_names [c.listen]
-          ctx.set_handler application
-        end
-      end
-
-      Jetty::ContextHandlerCollection.new.tap do |collection|
-        collection.set_handlers(handlers)
-      end
-    end
-
-    def to_connectors
-      @connectors = {}
-
-      @configs.each do |config|
-        next if @connectors.key?(config.listen)
-
-        host, port = config.listen.split(':')
-
-        connector = Jetty::SelectChannelConnector.new
-        connector.set_host(host)
-        connector.set_port(port.to_i)
-
-        @connectors[config.listen] = connector
-      end
-
-      @connectors.values
-    end
-
-  private
-
-    def watcher
-      @options[:watcher]
-    end
-
-    def with_root(root)
-      old, @root = @root, root
-      yield
-    ensure
-      @root = old
-    end
-
-    def expand_path(path)
-      File.expand_path(path, @root)
-    end
-
-    def new_config
-      Applications::Config.new.tap do |config|
-        config.listen         = '0.0.0.0:9090'
-        config.watch          = [ ]
-        config.bootstrap_path = File.expand_path('../bootstrap.rb', __FILE__)
-      end
-    end
-  end
-end

data/lib/kirk/client/connection.rb

@@ -1,18 +0,0 @@
-class Kirk::Client
-  class Connection
-    attr_reader :request
-
-    def initialize
-      @request = nil
-      @writing = false
-      @client = HttpClient.new
-      @client.set_connector_type(HttpClient::CONNECTOR_SELECT_CHANNEL);
-      @client.start
-    end
-
-    def process(request)
-      exchange = Exchange.from_request(request)
-      @client.send(exchange)
-    end
-  end
-end

data/lib/kirk/client/session.rb

@@ -1,40 +0,0 @@
-class Kirk::Client
-  class Session
-
-    attr_reader :responses, :queue
-
-    def initialize
-      @queue = LinkedBlockingQueue.new
-      @executor = ThreadPoolExecutor.new(thread_count, thread_count, 0, TimeUnit::SECONDS, @queue)
-      @connection = Connection.new
-      @requests_count = 0
-      @responses = []
-      yield(self)
-
-      get_responses
-    end
-
-    def request(method, url, handler = nil, headers = nil)
-      request = Request.new(self, method, url, handler, headers)
-      yield request if block_given?
-      queue_request(request)
-      request
-    end
-
-    def thread_count
-      3
-    end
-
-    def queue_request(request)
-      @connection.process(request)
-      @requests_count += 1
-    end
-
-    def get_responses
-      while @requests_count > 0
-        @responses << @queue.take
-        @requests_count -= 1
-      end
-    end
-  end
-end

data/lib/kirk/handler.rb

@@ -1,129 +0,0 @@
-module Kirk
-  class Handler
-    import "java.util.zip.GZIPInputStream"
-    import "java.util.zip.InflaterInputStream"
-
-    # Required environment variable keys
-    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
-    SCRIPT_NAME    = 'SCRIPT_NAME'.freeze
-    PATH_INFO      = 'PATH_INFO'.freeze
-    QUERY_STRING   = 'QUERY_STRING'.freeze
-    SERVER_NAME    = 'SERVER_NAME'.freeze
-    SERVER_PORT    = 'SERVER_PORT'.freeze
-    CONTENT_TYPE   = 'CONTENT_TYPE'.freeze
-    CONTENT_LENGTH = 'CONTENT_LENGTH'.freeze
-    REQUEST_URI    = 'REQUEST_URI'.freeze
-    REMOTE_HOST    = 'REMOTE_HOST'.freeze
-    REMOTE_ADDR    = 'REMOTE_ADDR'.freeze
-    REMOTE_USER    = 'REMOTE_USER'.freeze
-
-    # Rack specific variable keys
-    RACK_VERSION      = 'rack.version'.freeze
-    RACK_URL_SCHEME   = 'rack.url_scheme'.freeze
-    RACK_INPUT        = 'rack.input'.freeze
-    RACK_ERRORS       = 'rack.errors'.freeze
-    RACK_MULTITHREAD  = 'rack.multithread'.freeze
-    RACK_MULTIPROCESS = 'rack.multiprocess'.freeze
-    RACK_RUN_ONCE     = 'rack.run_once'.freeze
-    HTTP_PREFIX       = 'HTTP_'.freeze
-
-    # Rack response header names
-    CONTENT_TYPE_RESP   = 'Content-Type'
-    CONTENT_LENGTH_RESP = 'Content-Length'
-
-    # Kirk information
-    SERVER          = "#{NAME} #{VERSION}".freeze
-    SERVER_SOFTWARE = 'SERVER_SOFTWARE'.freeze
-
-    DEFAULT_RACK_ENV = {
-      SERVER_SOFTWARE => SERVER,
-
-      # Rack stuff
-      RACK_ERRORS       => STDERR,
-      RACK_MULTITHREAD  => true,
-      RACK_MULTIPROCESS => false,
-      RACK_RUN_ONCE     => false,
-    }
-
-    CONTENT_LENGTH_TYPE_REGEXP = /^Content-(?:Type|Length)$/i
-
-    def initialize(app)
-      @app = app
-    end
-
-    def handle(target, base_request, request, response)
-      begin
-        env = DEFAULT_RACK_ENV.merge(
-          REQUEST_URI     => request.getRequestURI,
-          PATH_INFO       => request.get_path_info,
-          REQUEST_METHOD  => request.get_method       || "GET",
-          RACK_URL_SCHEME => request.get_scheme       || "http",
-          QUERY_STRING    => request.get_query_string || "",
-          SERVER_NAME     => request.get_server_name  || "",
-          REMOTE_HOST     => request.get_remote_host  || "",
-          REMOTE_ADDR     => request.get_remote_addr  || "",
-          REMOTE_USER     => request.get_remote_user  || "",
-          SERVER_PORT     => request.get_server_port.to_s,
-          RACK_VERSION    => ::Rack::VERSION)
-
-        # Process the content length
-        if (content_length = request.get_content_length) >= 0
-          env[CONTENT_LENGTH] = content_length.to_s
-        else
-          env[CONTENT_LENGTH] = "0"
-        end
-
-        if (content_type = request.get_content_type)
-          env[CONTENT_TYPE] = content_type unless content_type == ''
-        end
-
-        request.get_header_names.each do |header|
-          next if header =~ CONTENT_LENGTH_TYPE_REGEXP
-          value = request.get_header(header)
-
-          header.tr! '-', '_'
-          header.upcase!
-
-          header      = "#{HTTP_PREFIX}#{header}"
-          env[header] = value unless env.key?(header) || value == ''
-        end
-
-        input = request.get_input_stream
-
-        case env['HTTP_CONTENT_ENCODING']
-        when 'deflate' then input = InflaterInputStream.new(input)
-        when 'gzip'    then input = GZIPInputStream.new(input)
-        end
-
-        input = InputStream.new(input)
-        env[RACK_INPUT] = input
-
-        # Dispatch the request
-        status, headers, body = @app.call(env)
-
-        response.set_status(status.to_i)
-
-        headers.each do |header, value|
-          case header
-          when CONTENT_TYPE_RESP
-            response.set_content_type(value)
-          when CONTENT_LENGTH_RESP
-            response.set_content_length(value.to_i)
-          else
-            response.set_header(header, value)
-          end
-        end
-
-        buffer = response.get_output_stream
-        body.each do |s|
-          buffer.write(s.to_java_bytes)
-        end
-
-        body.close if body.respond_to?(:close)
-      ensure
-        input.recycle if input
-        request.set_handled(true)
-      end
-    end
-  end
-end

data/lib/kirk/input_stream.rb

@@ -1,264 +0,0 @@
-require 'java'
-
-module Kirk
-  class InputStream
-    READL_SIZE  = 1_024
-    CHUNK_SIZE  = 8_192
-    BUFFER_SIZE = 1_024 * 50
-
-    import "java.io.File"
-    import "java.io.RandomAccessFile"
-    import "java.nio.ByteBuffer"
-    import "java.nio.channels.Channels"
-
-    # For our ROFL scale needs
-    import "java.util.concurrent.LinkedBlockingQueue"
-
-    BUFFER_POOL    = LinkedBlockingQueue.new
-    TMPFILE_PREFIX = "rackinput".to_java_string
-    TMPFILE_SUFFIX = "".to_java_string
-
-    def initialize(io)
-      @io       = channelize(io)
-      @buffer   = grab_buffer
-      @filebuf  = nil
-      @read     = 0
-      @position = 0
-      @eof      = false
-    end
-
-    def read(size = nil, buffer = nil)
-      one_loop = nil
-      read_all = size.nil?
-
-      buffer ? buffer.slice!(0..-1) : buffer = ''
-
-      raise ArgumentError, "negative length #{size} given" if size && size < 0
-
-      loop do
-        limit = size && size < CHUNK_SIZE ? size : CHUNK_SIZE
-
-        len = read_chunk(limit, buffer)
-
-        break unless len
-
-        one_loop = true
-
-        break if size && ( size -= len ) <= 0
-      end
-
-      return "" if read_all && !one_loop
-
-      one_loop && buffer
-    end
-
-    def gets(sep = $/)
-      return read unless sep
-
-      sep    = "#{$/}#{$/}" if sep == ""
-      buffer = ''
-      curpos = pos
-
-      while chunk = read(READL_SIZE)
-        buffer << chunk
-
-        if i = buffer.index(sep, 0)
-          i += sep.bytesize
-          buffer.slice!(i..-1)
-          seek(curpos + buffer.bytesize)
-          break
-        end
-      end
-
-      buffer
-    end
-
-    def each
-      while chunk = read(CHUNK_SIZE)
-        yield chunk
-      end
-
-      self
-    end
-
-    def pos
-      @position
-    end
-
-    def seek(pos)
-      raise Errno::EINVAL, "Invalid argument - invalid seek value" if pos < 0
-      @position = pos
-    end
-
-    def rewind
-      seek(0)
-    end
-
-    def close
-      nil
-    end
-
-    def recycle
-      BUFFER_POOL.put(@buffer)
-      @buffer = nil
-      nil
-    end
-
-  private
-
-    def channelize(stream)
-      Channels.new_channel(stream)
-    end
-
-    def grab_buffer
-      BUFFER_POOL.poll || ByteBuffer.allocate(BUFFER_SIZE)
-    end
-
-    def read_chunk(size, string)
-      missing = size - ( @read - @position )
-
-      if @filebuf || @read + missing > BUFFER_SIZE
-
-        rotate_to_tmp_file unless @filebuf
-        read_chunk_from_tmp_file(size, string)
-
-      else
-
-        read_chunk_from_mem(size, string, missing)
-
-      end
-    end
-
-    def read_chunk_from_mem(size, string, missing)
-      # We gonna have to read from the input stream
-      if missing > 0 && !@eof
-
-        # Set the new buffer limit to the amount that is going
-        # to be read
-        @buffer.limit(@read + missing).position(@read)
-
-        # Read into the buffer
-        len = @io.read(@buffer)
-
-        # Bail if we're at the EOF
-        if len == -1
-          @eof = true
-          return
-        end
-
-        @read += len
-
-      # We're at the end
-      elsif @position == @read
-
-        return
-
-      end
-
-      limit = @position + size
-      limit = @read if @read < limit
-
-      # Now move the amount read into the string
-      @buffer.position(@position).limit(limit)
-
-      append_buffer_to_string(@buffer, string)
-    end
-
-    def read_chunk_from_tmp_file(size, string)
-
-      if @read < @position && !@eof
-
-        return unless buffer_to(@position)
-
-      end
-
-      @buffer.clear.limit(size)
-
-      if @read > @position
-
-        @filebuf.position(@position)
-        @filebuf.read(@buffer)
-
-      elsif @eof
-
-        return
-
-      end
-
-      unless @eof
-
-        offset = @buffer.position
-        len    = @io.read(@buffer)
-
-        if len == -1
-
-          @eof = true
-          return if offset == 0
-
-        else
-
-          @filebuf.position(@read)
-          @filebuf.write(@buffer.flip.position(offset))
-
-          @read += len
-
-        end
-
-        @buffer.position(0)
-
-      end
-
-      append_buffer_to_string(@buffer, string)
-    end
-
-    def buffer_to(position)
-      until @read == position
-        limit = position - @read
-        limit = BUFFER_SIZE if limit > BUFFER_SIZE
-
-        @buffer.clear.limit(limit)
-
-        len = @io.read(@buffer)
-
-        if len == -1
-          @eof = true
-          return
-        end
-
-        @buffer.flip
-
-        @filebuf.position(@read)
-        @filebuf.write(@buffer)
-
-        @read += len
-      end
-
-      true
-    end
-
-    def append_buffer_to_string(buffer, string)
-      len   = buffer.limit - buffer.position
-      bytes = Java::byte[len].new
-      buffer.get(bytes)
-      string << String.from_java_bytes(bytes)
-      @position += len
-      len
-    end
-
-    def rotate_to_tmp_file
-      @buffer.position(0).limit(@read)
-
-      @filebuf = create_tmp_file
-      @filebuf.write @buffer
-
-      @buffer.clear
-    end
-
-    def create_tmp_file
-      file = File.create_temp_file(TMPFILE_PREFIX, TMPFILE_SUFFIX)
-      file.delete_on_exit
-
-      RandomAccessFile.new(file, "rw").channel
-    end
-  end
-end