wildnet-server 0.0.1-java

data/lib/version.rb

@@ -0,0 +1,5 @@
+module Wildnet
+  module Server
+    VERSION = "0.0.1" unless defined?(::Wildnet::Server::VERSION)
+  end
+end

data/lib/wildnet-server/http_handler.rb

@@ -0,0 +1,147 @@
+module Wildnet::Server
+
+  java_import "org.jboss.netty.channel.ChannelHandlerContext"
+  java_import "org.jboss.netty.channel.ExceptionEvent"
+  java_import "org.jboss.netty.channel.MessageEvent"
+  java_import "org.jboss.netty.channel.SimpleChannelUpstreamHandler"
+  java_import "org.jboss.netty.handler.codec.http.HttpChunk"
+  java_import "org.jboss.netty.handler.codec.http.HttpHeaders"
+  java_import "org.jboss.netty.handler.codec.http.HttpRequest"
+  java_import "org.jboss.netty.handler.codec.http.HttpResponseStatus"
+  java_import "org.jboss.netty.handler.codec.http.HttpVersion"
+
+  java_import "java.io.FileOutputStream"
+
+  class HttpHandler < SimpleChannelUpstreamHandler
+
+    attr_accessor :app
+
+    def message_received context, event
+
+      unless event.message.kind_of?(HttpRequest)
+
+        chunk = event.message
+
+        chunk.content.readBytes(@upload_stream, chunk.content.capacity)
+
+        if chunk.isLast
+          @upload_stream.close
+          handle
+        end
+
+        return
+      end
+
+      request                       = event.message
+      @request                      = Request.new
+
+      @request["REQUEST_METHOD"]    = request.getMethod.getName
+      @request["SCRIPT_NAME"]       = ""
+      @request["PATH_INFO"]         = request.getUri
+      @request["QUERY_STRING"]      = ""
+      @request["SERVER_NAME"]       = HttpHeaders.getHost request, "localhost"
+      @request["SERVER_PORT"]       = 80
+
+      @request["rack.url_scheme"]   = "http"
+      @request["rack.input"]        = File.new(java.io.File.createTempFile("wildnet.", ".request", java.io.File.new(File.join(Rails.root, "tmp"))).getAbsolutePath())
+      @request["rack.errors"]       = $stderr
+      @request["rack.multithread"]  = true
+      @request["rack.multiprocess"] = false
+      @request["rack.run_once"]     = false
+
+      @upload_stream                = FileOutputStream.new(java.io.File.new(@request["rack.input"].path))
+      unless request.isChunked
+        request.content.readBytes(@upload_stream, request.getContent.capacity)
+        @upload_stream.close
+      end
+
+      if request.containsHeader "X-For-Host"
+        @request["SERVER_NAME"] = request.getHeader "X-For-Host"
+      end
+
+      if request.containsHeader "X-For-Scheme"
+        @request["rack.url_scheme"] = request.getHeader "X-For-Scheme"
+      end
+
+      if server_name = %r{(.+):([0-9]+)}.match(@request["SERVER_NAME"])
+        @request["SERVER_NAME"] = server_name[1]
+        @request["SERVER_PORT"] = server_name[2].to_i
+      end
+
+      if path_info = %r{(.+)\?(.+)}.match(@request["PATH_INFO"])
+        @request["PATH_INFO"]    = path_info[1]
+        @request["QUERY_STRING"] = path_info[2]
+      end
+
+      if (@request["SERVER_PORT"] != 80 and @request["rack.url_scheme"] != "http") and (@request["SERVER_PORT"] != 443 and @request["rack.url_scheme"] != "https")
+        request.removeHeader "Host"
+        request.addHeader "Host", @request["SERVER_NAME"] + ":" + @request["SERVER_PORT"]
+      else
+        request.removeHeader "Host"
+        request.addHeader "Host", @request["SERVER_NAME"]
+      end
+
+      request.getHeaderNames.each do |header|
+        name = header.gsub("-", "_").upcase
+        if (name != "CONTENT_TYPE" and name != "CONTENT_LENGTH")
+          name = "HTTP_#{name}"
+        end
+        @request[name] = request.getHeader(header)
+      end
+
+      @request["rack.version"] = ::Rack::VERSION
+
+      @request["wildnet.context"] = context
+      @request["wildnet.response"] = HttpResponse.new(@request["wildnet.context"])
+
+      unless request.isChunked
+        handle
+      end
+
+    end
+
+    def handle
+
+      public_file = File.join(Rails.root, "public", @request["PATH_INFO"])
+      if File.exists?(public_file) and not File.directory?(public_file)
+        respond [200, {"X-Wildnet-Send-File" => public_file, "Content-Type" => "wildnet/detect"}, nil]
+      else
+        respond @app.call(@request)
+      end
+
+    end
+
+    def respond response
+
+      status, headers, body = response
+
+      @request["wildnet.response"].status = status
+
+      complete = headers.delete("X-Wildnet-Complete")
+      send_file = headers.delete("X-Wildnet-Send-File")
+
+      headers.each_pair do |header, value|
+        @request["wildnet.response"][header] = value
+      end
+
+      if send_file
+        @request["wildnet.response"].send_file(send_file)
+      else
+        body.each do |line|
+          @request["wildnet.response"] << line
+        end
+        @request["wildnet.response"].flush
+      end
+
+      @request["wildnet.response"].close(complete)
+
+      @request["rack.input"].close
+      File.delete(@request["rack.input"].path)
+
+    end
+
+    alias_method :messageReceived, :message_received
+
+  end
+
+end

data/lib/wildnet-server/http_response.rb

@@ -0,0 +1,89 @@
+require "mime/types"
+
+module Wildnet::Server
+
+  java_import "org.jboss.netty.handler.codec.http.DefaultHttpResponse"
+  java_import "org.jboss.netty.channel.ChannelFutureListener"
+  java_import "org.jboss.netty.buffer.ChannelBuffers"
+  java_import "org.jboss.netty.handler.codec.http.HttpResponseStatus"
+  java_import "org.jboss.netty.handler.codec.http.HttpVersion"
+  java_import "org.jboss.netty.channel.DefaultFileRegion"
+  java_import "java.io.RandomAccessFile"
+  java_import "org.jboss.netty.channel.ChannelFutureProgressListener"
+
+  class Finisher
+
+    import ChannelFutureProgressListener
+
+    def initialize proc
+      @proc = proc
+    end
+
+    def operationComplete future
+      @proc.call
+    end
+
+  end
+
+  class HttpResponse < DefaultHttpResponse
+
+    def initialize context
+      super(HttpVersion::HTTP_1_1, HttpResponseStatus.valueOf(200))
+      @buffer       = ChannelBuffers.dynamicBuffer
+      @context      = context
+      @future       = nil
+      @headers_sent = false
+      @closed       = false
+    end
+
+    def status
+      getStatus().getCode()
+    end
+
+    def status= code
+      setStatus(HttpResponseStatus.valueOf(code))
+    end
+
+    def [] name
+      getHeader(name)
+    end
+
+    def []= name, value
+      setHeader(name, value)
+    end
+
+    def send_file path
+      if getHeader("Content-Type") == "wildnet/detect"
+        ct = ::MIME::Types.type_for(path).first
+        self["Content-Type"] =  "text/plain"
+        self["Content-Type"] =  ct.content_type if ct
+      end
+      raf = RandomAccessFile.new(path, "r")
+      region = DefaultFileRegion.new(raf.channel, 0, raf.length)
+      HttpHeaders.setContentLength(self, raf.length)
+      @future = @context.channel.write(self)
+      @future = @context.channel.write(region)
+    end
+
+    def << data
+      @buffer.writeBytes(data.to_s.to_java_bytes)
+    end
+
+    def flush
+      unless @headers_sent
+        @future = @context.channel.write(self)
+      end
+      if @buffer.writerIndex > 0
+        @future = @context.channel.write(@buffer)
+        @buffer = ChannelBuffers.dynamicBuffer
+      end
+    end
+
+    def close proc = nil
+      @future.addListener(Finisher.new(proc)) if proc
+      @future.addListener(ChannelFutureListener::CLOSE)
+    end
+
+  end
+
+end

data/lib/wildnet-server/kernel.rb

@@ -0,0 +1,36 @@
+module Wildnet::Server
+
+  java_import "org.jboss.netty.bootstrap.ServerBootstrap"
+  java_import "org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory"
+
+  java_import "java.net.InetSocketAddress"
+  java_import "java.util.concurrent.Executors"
+
+  class Kernel
+
+    def self.run app, options = {}
+      options[:Port] ||= 3000
+      options[:Host] ||= "0.0.0.0"
+      @@server       = self.new(app, options)
+      @@server.start
+      Thread.new do
+        while true
+          sleep 10
+        end
+      end.join
+    end
+
+    def initialize app, options = {}
+      @app     = app
+      @options = options
+    end
+
+    def start
+      @bootstrap = ServerBootstrap.new(NioServerSocketChannelFactory.new(Executors.newCachedThreadPool, Executors.newCachedThreadPool))
+      @bootstrap.setPipelineFactory(PipeLineFactory.new(@app))
+      @bootstrap.bind(InetSocketAddress.new(@options[:Host], @options[:Port]))
+    end
+
+  end
+
+end

data/lib/wildnet-server/pipe_line_factory.rb

@@ -0,0 +1,45 @@
+module Wildnet::Server
+
+  java_import "org.jboss.netty.channel.ChannelPipeline"
+  java_import "org.jboss.netty.channel.ChannelPipelineFactory"
+  java_import "org.jboss.netty.channel.Channels"
+  java_import "org.jboss.netty.handler.codec.http.HttpRequestDecoder"
+  java_import "org.jboss.netty.handler.codec.http.HttpResponseEncoder"
+  java_import "org.jboss.netty.handler.execution.ExecutionHandler"
+  java_import "org.jboss.netty.handler.execution.OrderedMemoryAwareThreadPoolExecutor"
+  java_import "org.jboss.netty.handler.stream.ChunkedWriteHandler"
+
+  class PipeLineFactory
+
+    import ChannelPipelineFactory
+
+    def initialize app
+      @executor = OrderedMemoryAwareThreadPoolExecutor.new 16, 0, 0
+      @execution_handler = ExecutionHandler.new @executor
+      @app = app
+    end
+
+    def get_pipeline
+
+      handler = HttpHandler.new
+      handler.app = @app
+      
+      pipeline = Channels.pipeline
+
+      pipeline.addLast "decoder", HttpRequestDecoder.new
+      pipeline.addLast "encoder", HttpResponseEncoder.new
+
+      pipeline.addLast "executor", @execution_handler
+      pipeline.addLast "chunkedWriter", ChunkedWriteHandler.new
+      pipeline.addLast "handler", handler
+
+      pipeline
+
+    end
+
+    # getPipeline is not Ruby-friendly ... but it is required by Java interface
+    alias_method :getPipeline, :get_pipeline
+
+  end
+
+end

data/lib/wildnet-server/request.rb

@@ -0,0 +1,5 @@
+module Wildnet::Server
+  class Request < Hash
+    
+  end
+end

data/lib/wildnet-server.rb

@@ -0,0 +1,10 @@
+require "java"
+
+require File.expand_path("../version.rb", __FILE__)
+require File.expand_path("../wildnet-server/request.rb", __FILE__)
+require File.expand_path("../wildnet-server/http_response.rb", __FILE__)
+require File.expand_path("../wildnet-server/http_handler.rb", __FILE__)
+require File.expand_path("../wildnet-server/pipe_line_factory.rb", __FILE__)
+require File.expand_path("../wildnet-server/kernel.rb", __FILE__)
+
+Rack::Handler.register "wildnet", "Wildnet::Server::Kernel"

data/wildnet-server.gemspec

@@ -0,0 +1,45 @@
+
+require File.expand_path("../lib/version", __FILE__)
+
+Gem::Specification.new do |s|
+
+  s.name                      = "wildnet-server"
+  s.version                   = Wildnet::Server::VERSION
+  s.authors                   = ["Marek Jelen"]
+  s.summary                   = "Http server"
+  s.description               = "Http server on top of Netty library"
+  s.email                     = "marek@jelen.biz"
+  s.homepage                  = "http://github.com/marekjelen/wildnet-server"
+  s.licenses                  = ["MIT"]
+
+  s.platform                  = "java"
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.extra_rdoc_files          = [
+      "LICENSE.txt",
+      "README.rdoc"
+  ]
+
+  s.files                     = [
+      "LICENSE.txt",
+      "README.rdoc",
+      "lib/wildnet-server/http_handler.rb",
+      "lib/wildnet-server/http_response.rb",
+      "lib/wildnet-server/kernel.rb",
+      "lib/wildnet-server/pipe_line_factory.rb",
+      "lib/wildnet-server/request.rb",
+      "lib/wildnet-server.rb",
+      "lib/version.rb",
+      "wildnet-server.gemspec"
+  ]
+
+  s.require_paths             = ["lib"]
+
+  s.test_files                = [
+  ]
+
+  s.add_runtime_dependency("rack", ["> 1.0"])
+  s.add_runtime_dependency("wildnet-netty", ["> 1.0"])
+  
+end
+

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: wildnet-server
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 0
+    - 1
+  version: 0.0.1
+platform: java
+authors: 
+  - Marek Jelen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-21 00:00:00 +01:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rack
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">"
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 1
+              - 0
+            version: "1.0"
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: wildnet-netty
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">"
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 1
+              - 0
+            version: "1.0"
+    type: :runtime
+    version_requirements: *id002
+description: Http server on top of Netty library
+email: marek@jelen.biz
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - LICENSE.txt
+  - README.rdoc
+files: 
+  - LICENSE.txt
+  - README.rdoc
+  - lib/wildnet-server/http_handler.rb
+  - lib/wildnet-server/http_response.rb
+  - lib/wildnet-server/kernel.rb
+  - lib/wildnet-server/pipe_line_factory.rb
+  - lib/wildnet-server/request.rb
+  - lib/wildnet-server.rb
+  - lib/version.rb
+  - wildnet-server.gemspec
+has_rdoc: true
+homepage: http://github.com/marekjelen/wildnet-server
+licenses: 
+  - MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 1
+          - 3
+          - 6
+        version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Http server
+test_files: []
+