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

data/lib/kirk.rb

@@ -8,42 +8,40 @@ module Kirk
   end
 
   require 'java'
-  require 'kirk/native'
-  require 'kirk/jetty'
   require 'kirk/version'
 
-  import "java.util.concurrent.LinkedBlockingQueue"
-  import "java.util.concurrent.TimeUnit"
-  import "java.util.logging.Logger"
-  import "java.util.logging.Level"
-  import "java.util.logging.ConsoleHandler"
+  autoload :Client, 'kirk/client'
+  autoload :Jetty,  'kirk/jetty'
+  autoload :Native, 'kirk/native'
+  autoload :Server, 'kirk/server'
 
-  module Native
-    import "com.strobecorp.kirk.ApplicationConfig"
-    import "com.strobecorp.kirk.HotDeployableApplication"
-    import "com.strobecorp.kirk.LogFormatter"
-  end
+  java_import "java.net.InetSocketAddress"
+  java_import "java.nio.ByteBuffer"
 
-  module Applications
-    autoload :Config,         'kirk/applications/config'
-    autoload :DeployWatcher,  'kirk/applications/deploy_watcher'
-    autoload :HotDeployable,  'kirk/applications/hot_deployable'
-    autoload :Rack,           'kirk/applications/rack'
-    autoload :RedeployClient, 'kirk/applications/redeploy_client'
-  end
+  java_import "java.util.concurrent.AbstractExecutorService"
+  java_import "java.util.concurrent.ExecutorCompletionService"
+  java_import "java.util.concurrent.LinkedBlockingQueue"
+  java_import "java.util.concurrent.TimeUnit"
+  java_import "java.util.concurrent.ThreadPoolExecutor"
+
+  java_import "java.util.logging.Logger"
+  java_import "java.util.logging.Level"
+  java_import "java.util.logging.ConsoleHandler"
 
-  require 'kirk/builder'
-  require 'kirk/client'
-  require 'kirk/handler'
-  require 'kirk/input_stream'
-  require 'kirk/server'
+  def self.sub_process?
+    !!defined?(Kirk::PARENT_VERSION)
+  end
 
   # Configure the logger
   def self.logger
     @logger ||= begin
       logger = Logger.get_logger("org.eclipse.jetty.util.log")
-      logger.set_use_parent_handlers(false)
-      logger.add_handler logger_handler
+
+      unless sub_process?
+        logger.set_use_parent_handlers(false)
+        logger.add_handler logger_handler
+      end
+
       logger
     end
   end

data/lib/kirk/cli.rb

@@ -42,7 +42,7 @@ module Kirk
 
     def handle_redeploy
       rackup = File.expand_path(@options[:rackup] || "#{Dir.pwd}/config.ru")
-      client = Applications::RedeployClient.new('/tmp/kirk.sock')
+      client = Server::RedeployClient.new('/tmp/kirk.sock')
 
       unless File.exist?(rackup)
         raise MissingRackupFile, "rackup file `#{rackup}` does not exist"

data/lib/kirk/client.rb

@@ -1,25 +1,64 @@
+require 'kirk'
+
 module Kirk
   class Client
-    import org.eclipse.jetty.client.HttpClient
-    import org.eclipse.jetty.client.HttpExchange
-    import java.net.InetSocketAddress
-    import java.util.concurrent.LinkedBlockingQueue
-    import org.eclipse.jetty.client.ContentExchange
-    import java.util.concurrent.AbstractExecutorService
-    import java.util.concurrent.TimeUnit
-    import java.util.concurrent.ThreadPoolExecutor
-    import java.util.concurrent.ExecutorCompletionService
+    require 'kirk/client/group'
+    require 'kirk/client/response'
+    require 'kirk/client/request'
+    require 'kirk/client/exchange'
+
+    def self.client
+      @client ||= new
+    end
+
+    def self.stop
+      @client.stop if @client
+      @client = nil
+    end
+
+    def self.group(opts = {}, &blk)
+      client.group(opts, &blk)
+    end
+
+    %w(request head get post put delete).each do |method|
+      class_eval <<-RUBY
+        def self.#{method}(*args, &blk)
+          g = group { |g| g.#{method}(*args, &blk) }
+          g.responses.first
+        end
+      RUBY
+    end
+
+    def group(opts = {}, &blk)
+      Group.new(self, opts).tap do |group|
+        group.start(&blk)
+      end
+    end
+
+    def initialize(opts = {})
+      @options = opts
+    end
+
+    def client
+      @client ||= Jetty::HttpClient.new.tap do |client|
+        client.set_connector_type(Jetty::HttpClient::CONNECTOR_SELECT_CHANNEL)
+        client.set_thread_pool(thread_pool) if thread_pool
+        client.start
+      end
+    end
 
-    def self.session
-      Session.new(&Proc.new)
+    def process(request)
+      client.send Exchange.build(request)
     end
 
-    private
+    def stop
+      client.stop
+    end
+
+  private
+
+    def thread_pool
+      @options[:thread_pool]
+    end
   end
 end
-
-require 'kirk/client/session'
-require 'kirk/client/response'
-require 'kirk/client/request'
-require 'kirk/client/connection'
-require 'kirk/client/exchange'

data/lib/kirk/client/exchange.rb

@@ -1,33 +1,153 @@
-class Kirk::Client
-  class Exchange < ContentExchange
-    include java.util.concurrent.Callable
-
-    def initialize(session, handler)
-      @handler = handler
-      @session = session
-      super()
-    end
+module Kirk
+  class Client
+    class Exchange < Jetty::HttpExchange
 
-    def onException(ex)
-      puts ex.inspect
-    end
+      def self.build(request)
+        inst = new
+        inst.prepare! request
+        inst
+      end
 
-    def onResponseComplete
-      @session.queue.offer(response)
-      @handler.on_response_complete(response) if @handler
-    end
+      attr_accessor :request, :response
 
-    def response
-      @response = begin
-                    Response.new(get_response_content, get_response_status)
-                  end
-    end
+      def group
+        request.group
+      end
+
+      def handler
+        request.handler
+      end
+
+      def prepare!(request)
+        self.request  = request
+        self.response = Response.new(!handler.respond_to?(:on_response_body))
+        self.method   = request.method
+        self.url      = request.url
+
+        if request.headers
+          request.headers.each do |name, val|
+            self.set_request_header(name.to_s, val.to_s)
+          end
+        end
+
+        if request.body
+          #
+          # If the body is already an InputStream (thus in the correct
+          # format), just run with it.
+          if Java::JavaIo::InputStream === request.body
+            self.request_content_source = request.body
+          #
+          # If the body responds to the JRuby method that converts
+          # an object to an InputStream, then use that
+          elsif request.body.respond_to?(:to_inputstream)
+            self.request_content_source = request.body.to_inputstream
+          #
+          # If it responds to :read but not to :to_inputstream, then
+          # it is a ruby object that is trying to look like an IO but
+          # hasn't implemented the magic JRuby conversion method, so
+          # we have to make it work.
+          #
+          # XXX Implement an InputStream subclass that can wrap ruby
+          # IO like objects
+          elsif request.body.respond_to?(:read)
+            self.request_content = bufferize(request.body.read)
+          #
+          # The fallback plan is to just call #to_s on the object
+          else
+            self.request_content = bufferize(request.body.to_s)
+          end
+        end
+
+        @buffer_body = handler.respond_to?(:on_response_content)
+      end
+
+      # Java callbacks
+      #
+      # def onConnectionFailed(ex)
+      #   if handler.respond_to?(:on_connection_failed)
+      #     handler.on_connection_failed(ex)
+      #   end
+      # end
+
+      def onException(ex)
+        if handler.respond_to?(:on_exception)
+          handler.on_exception(ex)
+        end
+
+        response.exception = true
+        group.respond(response)
+      end
+
+      # def onExpire
+      #   # p [ :onExpire ]
+      #   if handler.respond_to?(:on_timeout)
+      #     handler.on_timeout
+      #   end
+      # end
+
+      def onRequestComplete
+        if handler.respond_to?(:on_request_complete)
+          handler.on_request_complete
+        end
+      end
+
+      def onResponseComplete
+        if handler.respond_to?(:on_response_complete)
+          handler.on_response_complete(response)
+        end
+
+        # Need to return the response after the handler
+        # is done with it
+        group.respond(response)
+      end
+
+      def onResponseContent(buf)
+        chunk = stringify(buf)
+
+        if handler.respond_to?(:on_response_body)
+          handler.on_response_body(response, chunk)
+        else
+          response.body << chunk
+        end
+      end
+
+      def onResponseHeader(name, value)
+        response.headers[name.to_s] = value.to_s
+      end
+
+      def onResponseHeaderComplete
+        if handler.respond_to?(:on_response_head)
+          handler.on_response_head(response)
+        end
+      end
+
+      def onResponseStatus(version, status, reason)
+        response.status = status
+      end
+
+      def onRetry
+        if handler.respond_to?(:on_retry)
+          handler.on_retry
+        end
+
+        super
+      end
+
+      def onSwitchProtocol(end_point)
+        # What is this exactly?
+      end
+
+    private
+
+      def bufferize(obj)
+        Jetty::ByteArrayBuffer.new(obj.to_s)
+      end
 
-    def self.from_request(request)
-      exchange = new(request.session, request.handler)
-      exchange.set_method(request.method)
-      exchange.set_url(request.url)
-      exchange
+      def stringify(buf)
+        bytes = Java::byte[buf.length].new
+        buf.get(bytes, 0, buf.length)
+        String.from_java_bytes(bytes)
+      end
     end
   end
 end

data/lib/kirk/client/group.rb

@@ -0,0 +1,94 @@
+require 'uri'
+
+module Kirk
+  class Client
+    class Group
+      attr_reader :client, :host, :options, :responses
+
+      def initialize(client = Client.new, options = {})
+        @options = options
+        @client  = client
+        @queue   = LinkedBlockingQueue.new
+
+        @requests_count = 0
+        @responses      = []
+
+        if @options[:host]
+          @host = @options.delete(:host).chomp('/')
+          @host = "http://#{@host}" unless @host =~ /^https?:\/\//
+        end
+      end
+
+      def block?
+        options.key?(:block) ? options[:block] : true
+      end
+
+      def start
+        ret = yield self
+        join if block?
+        ret
+      end
+
+      def join
+        get_responses
+      end
+
+      def complete(&blk)
+        @complete = blk if blk
+        @complete
+      end
+
+      def request(method = nil, url = nil, handler = nil, body = nil, headers = {})
+        request = Request.new(self, method, url, handler, body, headers)
+
+        yield request if block_given?
+
+        request.url URI.join(host, request.url).to_s if host
+        request.validate!
+
+        process(request)
+        request
+      end
+
+      def respond(response)
+        @queue.put(response)
+      end
+
+      %w/get post put delete head/.each do |method|
+        class_eval <<-RUBY
+          def #{method}(url, headers = nil, handler = nil)
+            request(:#{method.upcase}, url, headers, handler)
+          end
+        RUBY
+      end
+
+      def process(request)
+        @client.process(request)
+        @requests_count += 1
+      end
+
+      def get_responses
+        while @requests_count > 0
+          if resp = @queue.poll(timeout, TimeUnit::SECONDS)
+            @responses << resp
+            @requests_count -= 1
+          else
+            raise "timed out"
+          end
+        end
+
+        completed
+      end
+
+    private
+
+      def completed
+        complete.call if complete
+      end
+
+      def timeout
+        @options[:timeout] || 30
+      end
+    end
+  end
+end

data/lib/kirk/client/request.rb

@@ -1,12 +1,48 @@
 class Kirk::Client
+  class InvalidRequestError < ArgumentError ; end
+
   class Request
-    attr_reader :method, :url, :handler, :session
+    attr_reader :group
+
+    def initialize(group, method = nil, url = nil, handler = nil, body = nil, headers = {})
+      @group    = group
+      @url      = url
+      @handler  = handler
+      @body     = body
+      @headers  = headers
+      @method   = normalize_method(method)
+
+      yield self if block_given?
+    end
+
+    %w/url headers handler body/.each do |method|
+      class_eval <<-RUBY
+        def #{method}(*args)
+          @#{method} = args.first unless args.empty?
+          @#{method}
+        end
+      RUBY
+    end
+
+    def method(*args)
+      @method = normalize_method(args.first) unless args.empty?
+      @method
+    end
+
+    def validate!
+      unless method
+        raise InvalidRequestError, "Must specify an HTTP method for the request"
+      end
+
+      unless url
+        raise InvalidRequestError, "Must specify a URL for the request"
+      end
+    end
+
+  private
 
-    def initialize(session, method, url, handler, headers)
-      @session = session
-      @method  = method.to_s.upcase
-      @url     = url
-      @handler = handler
+    def normalize_method(method)
+      method.to_s.upcase if method
     end
   end
 end