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

data/lib/kirk/client/response.rb

@@ -1,10 +1,26 @@
 class Kirk::Client
   class Response
-    attr_reader :status, :content
+    attr_accessor :version, :status, :body, :headers, :exception
 
-    def initialize(content, status)
-      @content = content
-      @status  = status
+    def initialize(buffer_body)
+      @status       = nil
+      @version      = nil
+      @headers      = {}
+      @buffer_body  = buffer_body
+      @body         = buffer_body ? "" : nil
+      @exception    = nil
+    end
+
+    def buffer_body?
+      @buffer_body
+    end
+
+    def success?
+      @status && @status < 400 && !@exception
+    end
+
+    def exception?
+      @exception
     end
   end
 end

data/lib/kirk/jetty.rb

@@ -1,23 +1,31 @@
-require "kirk/jetty/jetty-client-7.2.2.v20101205"
-require "kirk/jetty/jetty-server-7.2.2.v20101205"
-require "kirk/jetty/servlet-api-2.5"
+# Only require jars if in the "master" process
+unless Kirk.sub_process?
+  require "kirk/jetty/servlet-api-2.5"
+
+  %w(util http io continuation server client).each do |mod|
+    require "kirk/jetty/jetty-#{mod}-7.3.0.v20110203"
+  end
+end
 
 module Kirk
   module Jetty
     # Gimme Jetty
-    import "org.eclipse.jetty.client.HttpClient"
-    import "org.eclipse.jetty.client.HttpExchange"
+    java_import "org.eclipse.jetty.client.HttpClient"
+    java_import "org.eclipse.jetty.client.HttpExchange"
+    java_import "org.eclipse.jetty.client.ContentExchange"
+
+    java_import "org.eclipse.jetty.io.ByteArrayBuffer"
 
-    import "org.eclipse.jetty.server.nio.SelectChannelConnector"
-    import "org.eclipse.jetty.server.handler.AbstractHandler"
-    import "org.eclipse.jetty.server.handler.ContextHandler"
-    import "org.eclipse.jetty.server.handler.ContextHandlerCollection"
-    import "org.eclipse.jetty.server.Server"
+    java_import "org.eclipse.jetty.server.nio.SelectChannelConnector"
+    java_import "org.eclipse.jetty.server.handler.AbstractHandler"
+    java_import "org.eclipse.jetty.server.handler.ContextHandler"
+    java_import "org.eclipse.jetty.server.handler.ContextHandlerCollection"
+    java_import "org.eclipse.jetty.server.Server"
 
-    import "org.eclipse.jetty.util.component.LifeCycle"
-    import "org.eclipse.jetty.util.log.Log"
-    import "org.eclipse.jetty.util.log.JavaUtilLog"
+    java_import "org.eclipse.jetty.util.component.LifeCycle"
+    java_import "org.eclipse.jetty.util.log.Log"
+    java_import "org.eclipse.jetty.util.log.JavaUtilLog"
 
-    Log.set_log Jetty::JavaUtilLog.new
+    Log.set_log Jetty::JavaUtilLog.new unless Kirk.sub_process?
   end
 end

data/lib/kirk/native.rb

@@ -0,0 +1,12 @@
+require 'kirk/native.jar'
+
+module Kirk
+  Jetty # Trigger the jetty autoload
+
+  module Native
+    java_import "com.strobecorp.kirk.ApplicationConfig"
+    java_import "com.strobecorp.kirk.HotDeployableApplication"
+    java_import "com.strobecorp.kirk.LogFormatter"
+    java_import "com.strobecorp.kirk.RewindableInputStream"
+  end
+end

data/lib/kirk/server.rb

@@ -1,5 +1,15 @@
+require 'kirk'
+
 module Kirk
   class Server
+    autoload :ApplicationConfig,  'kirk/server/application_config'
+    autoload :Builder,            'kirk/server/builder'
+    autoload :DeployWatcher,      'kirk/server/deploy_watcher'
+    autoload :Handler,            'kirk/server/handler'
+    autoload :HotDeployable,      'kirk/server/hot_deployable'
+    autoload :InputStream,        'kirk/server/input_stream'
+    autoload :RedeployClient,     'kirk/server/redeploy_client'
+
     def self.build(file = nil, &blk)
       root    = File.dirname(file) if file
       builder = Builder.new(root)
@@ -27,7 +37,7 @@ module Kirk
       if Jetty::AbstractHandler === handler
         @handler = handler
       elsif handler.respond_to?(:call)
-        @handler = Applications::Rack.new(handler)
+        @handler = Handler.new(handler)
       else
         raise "#{handler.inspect} is not a valid Rack application"
       end

data/lib/kirk/server/application_config.rb

@@ -0,0 +1,56 @@
+module Kirk
+  class Server::ApplicationConfig
+    include Native::ApplicationConfig
+
+    attr_accessor :env,
+                  :hosts,
+                  :listen,
+                  :watch,
+                  :rackup,
+                  :application_path,
+                  :bootstrap_path
+
+    def initialize
+      @env    = {}
+      @hosts  = []
+      @listen = listen
+    end
+
+    def application_path
+      @application_path || File.dirname(rackup)
+    end
+
+    # Handle the java interface
+    alias getApplicationPath    application_path
+    alias getRackupPath         rackup
+    alias getBootstrapPath      bootstrap_path
+
+    def getEnvironment
+      map = java.util.HashMap.new
+      env = ENV.dup
+
+      self.env.each do |key, val|
+        env[key.to_s] = val
+      end
+
+      env.each do |key, val|
+        next unless val
+
+        key = key.to_java_string
+        val = val.to_s.to_java_string
+
+        map.put(key, val)
+      end
+
+      map
+    end
+
+    def getKirkVersionStamper
+      <<-RUBY
+        module Kirk
+          PARENT_VERSION = #{VERSION.inspect}.freeze
+        end
+      RUBY
+    end
+  end
+end

data/lib/kirk/server/bootstrap.rb

@@ -0,0 +1,59 @@
+require 'java'
+
+module Kirk
+  class Server
+    class Bootstrap
+      def warmup(application_path)
+        Dir.chdir File.expand_path(application_path)
+
+        load_rubygems
+
+        load_bundle.tap do
+          add_kirk_to_load_path
+
+          load_rack
+          load_kirk
+        end
+      end
+
+      def run(rackup)
+        app, options = Rack::Builder.parse_file(rackup)
+
+        Handler.new(app)
+      end
+
+    private
+
+      def load_rubygems
+        require 'rubygems'
+      end
+
+      def load_bundle
+        if File.exist?('Gemfile')
+          require 'bundler/setup'
+
+          if File.exist?('Gemfile.lock')
+            require 'digest/sha1'
+            str = File.read('Gemfile') + File.read('Gemfile.lock')
+            Digest::SHA1.hexdigest(str)
+          end
+        end
+      end
+
+      def add_kirk_to_load_path
+        $:.unshift File.expand_path('../../..', __FILE__)
+      end
+
+      def load_rack
+        gem "rack", ">= 1.0.0"
+        require 'rack'
+      end
+
+      def load_kirk
+        require 'kirk/server'
+      end
+    end
+  end
+end
+
+Kirk::Server::Bootstrap.new

data/lib/kirk/server/builder.rb

@@ -0,0 +1,145 @@
+module Kirk
+  class MissingConfigFile < RuntimeError ; end
+  class MissingRackupFile < RuntimeError ; end
+
+  class Server
+    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 => 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 = 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
+        ApplicationConfig.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
+end

data/lib/kirk/{applications → server}/deploy_watcher.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 module Kirk
-  class Applications::DeployWatcher
+  class Server::DeployWatcher
     include Jetty::LifeCycle::Listener
 
     def initialize(unix_socket_path = nil)

data/lib/kirk/server/handler.rb

@@ -0,0 +1,140 @@
+module Kirk
+  class Server
+    class Handler < Jetty::AbstractHandler
+      java_import 'java.util.zip.GZIPInputStream'
+      java_import 'java.util.zip.InflaterInputStream'
+
+      # Trigger the autoload so that the first access to the class
+      # does not happen in a thread.
+      InputStream
+
+      # 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 self.new(app)
+        inst = super()
+        inst.app = app
+        inst
+      end
+
+      attr_accessor :app
+
+      def handle(target, base_request, request, response)
+        begin
+          env = DEFAULT_RACK_ENV.merge(
+            SCRIPT_NAME     => "",
+            PATH_INFO       => request.get_path_info,
+            REQUEST_URI     => request.getRequestURI,
+            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.respond_to?(:recycle)
+          request.set_handled(true)
+        end
+      end
+    end
+  end
+end