yarn 0.0.1

data/lib/yarn/parslet_parser.rb

@@ -0,0 +1,114 @@
+require 'rubygems'
+require 'parslet'
+
+module Parslet::Atoms::DSL; def once; repeat(1); end; end
+
+module Yarn
+  class ParsletParser < Parslet::Parser
+    
+    # general rules
+
+    rule(:crlf) { str("\r\n") | str("\n") }
+
+    rule(:space) { match('\s') }
+    
+    rule(:spaces) { match('\s+') }
+
+    # header rules
+
+    rule(:header_value) { match['^\r\n'].once }
+
+    rule(:header_name) { match['a-zA-Z\-'].once }
+
+    rule(:header) do 
+      header_name.as(:name) >> 
+      str(":") >> 
+      space.maybe >> 
+      header_value.as(:value).maybe >> 
+      crlf.maybe 
+    end
+    
+    # request-line rules
+
+    rule(:http_version) { match['HTTP\/\d\.\d'].once }
+
+    rule(:param_value) { match['^&\s+'].once }
+
+    rule(:param_name) { match['^=+'].once }
+
+    rule(:param) do
+      param_name.as(:name) >>
+      str("=") >>
+      param_value.as(:value) >>
+      str("&").maybe
+    end
+
+    rule(:query) do
+      match['\S+'].repeat(1)
+    end
+
+    rule(:path) do 
+      match['^\?'].repeat(1).as(:path) >> str("?") >> query.as(:query) | match['^\s'].once.as(:path)
+    end
+
+    rule(:port) { match['\d+'].repeat(1) }
+
+    rule(:host) { match['^\/:'].once }
+
+    rule(:absolute_uri) do
+      str("http://") >> 
+      host.as(:host) >> 
+      str(":").maybe >> 
+      port.as(:port).maybe >>
+      path
+    end
+
+    rule(:request_uri) { str('*') | absolute_uri | path }
+
+    rule(:spaces) { match('\s+') }
+
+    rule(:method) { match['OPTIONS|GET|HEAD|POST|PUT|DELETE|TRACE|CONNECT'].once }
+
+    # RFC2616: Method SP Request-URI SP HTTP-Version CRLF
+    rule(:request_line) do 
+      method.as(:method) >> 
+      space >> 
+      request_uri.as(:uri) >> 
+      space >> 
+      http_version.as(:version) >> 
+      crlf.maybe 
+    end
+
+    # RFC2616: Request-Line *(( header ) CRLF) CRLF [ message-body ]
+    rule(:request) do 
+      request_line >> 
+      header.repeat.as(:_process_headers).as(:headers) >> 
+      crlf.maybe
+    end
+
+    # starts parsing from the beginning using the :request rule
+    root(:request)
+
+    def run(input)
+      tree = parse input 
+      tree = ParamsTransformer.new.apply tree 
+      HeadersTransformer.new.apply tree 
+    end
+  end
+
+  class ParamsTransformer < Parslet::Transform
+    rule(:_process_params => subtree(:params)) do
+      hash = {}
+      params.each { |h| hash[h[:name].to_s] = h[:value] }
+      hash
+    end
+  end
+
+  class HeadersTransformer < Parslet::Transform
+    rule(:_process_headers => subtree(:headers)) do
+      hash = {}
+      headers.each { |h| hash[h[:name].to_s] = h[:value].to_s }
+      hash
+    end
+  end
+end

data/lib/yarn/rack_handler.rb

@@ -0,0 +1,42 @@
+require 'rack'
+require 'pry'
+
+module Yarn
+  class RackHandler < RequestHandler
+
+    def initialize(app, opts)
+      super(opts)
+      @host,@port = opts[:host], opts[:port]
+      @app = app
+    end
+
+    def prepare_response
+      begin
+        env = make_env
+        @response.content = @app.call(env)
+      rescue Exception => e
+        log e.message
+        log e.backtrace
+      end
+    end
+
+    def make_env
+      env = {
+        "REQUEST_METHOD"    => @request[:method].to_s,
+        "PATH_INFO"         => @request[:uri][:path].to_s,
+        "QUERY_STRING"      => @request[:uri][:query].to_s,
+        "SERVER_NAME"       => @host || @request[:uri][:host].to_s,
+        "SERVER_PORT"       => @port.to_s || @request[:uri][:port].to_s,
+        "SCRIPT_NAME"       => "",
+        "rack.input"        => StringIO.new("").set_encoding(Encoding::ASCII_8BIT),
+        "rack.version"      => Rack::VERSION,
+        "rack.errors"       => $output,
+        "rack.multithread"  => true,
+        "rack.multiprocess" => false,
+        "rack.run_once"     => false,
+        "rack.url_scheme"   => "http"
+      }
+    end
+
+  end
+end

data/lib/yarn/request_handler.rb

@@ -0,0 +1,202 @@
+require 'date'
+require 'rubygems'
+require 'parslet'
+
+module Yarn
+
+  class EmptyRequestError < StandardError; end
+  class ProcessingError < StandardError; end
+
+  class RequestHandler
+
+    include Logging
+    include ErrorPage
+
+    attr_accessor :session, :parser, :request, :response
+
+    def initialize(options={})
+      @parser = ParsletParser.new
+      @response = Response.new
+    end
+
+    def run(session)
+      @response = Response.new
+      set_common_headers
+      @session = session
+      begin
+        parse_request
+        prepare_response
+        return_response
+        log "Served (#{STATUS_CODES[@response.status]}) #{client_address} #{request_path}"
+      rescue EmptyRequestError
+        log "Empty request from #{client_address}"
+      ensure
+        close_connection
+      end
+    end
+
+    def parse_request
+      raw_request = read_request
+      raise EmptyRequestError if raw_request.empty?
+
+      begin
+        @request = @parser.run raw_request
+      rescue Parslet::ParseFailed => e
+        @response.status = 400
+        debug "Parse failed: #{@request}"
+      end
+    end
+
+    def prepare_response
+      path = extract_path
+
+      @response.headers["Content-Type"] = "text/html"
+
+      begin
+        if File.directory? path
+          serve_directory path
+        elsif File.exists?(path)
+          if path =~ /.*\.rb$/
+            @response.body << execute_script(path)
+            @response.status = 200
+          else
+            serve_file(path)
+          end
+        else
+          serve_404_page
+        end
+      rescue ProcessingError
+        log "An error occured processing #{path}"
+        serve_500_page
+      end
+    end
+
+    def execute_script(path)
+      response = `ruby #{path}`
+      if !! ($?.to_s =~ /1$/)
+        raise ProcessingError
+      else
+        response
+      end
+    end
+
+    def return_response
+      @session.puts "HTTP/1.1 #{@response.status} #{STATUS_CODES[@response.status]}"
+      @session.puts @response.headers.map { |k,v| "#{k}: #{v}" }
+      @session.puts ""
+
+      @response.body.each do |line|
+        @session.puts line
+      end
+    end
+
+    def close_connection
+      if @session #&& !persistent?
+        @session.close
+      else
+        # TODO: start some kind of timeout
+      end
+    end
+
+    def read_request
+      input = []
+      while (line = @session.gets) do
+        break if line.length <= 2
+        input << line
+      end
+      input.join
+    end
+
+    def persistent?
+      return @request[:headers]["Connection"] == "keep-alive"
+    end
+
+    def set_common_headers
+      @response.headers[:Server] = "Yarn webserver v#{VERSION}"
+
+      # HTTP date format: Fri, 31 Dec 1999 23:59:59 GMT
+      time = DateTime.now.new_offset(0)
+      @response.headers[:Date] = time.strftime("%a, %d %b %Y %H:%M:%S GMT")
+      # Close connection header ( until support for persistent connections )
+      @response.headers[:Connection] = "Close"
+    end
+
+    def serve_file(path)
+      @response.status = 200
+      @response.body << read_file(path)
+      @response.headers["Content-Type"] = get_mime_type path
+    end
+
+    def serve_directory(path)
+      @response.status = 200
+      if File.exists?("index.html") || File.exists?("/index.html")
+        @response.body = read_file "index.html"
+        @response.headers["Content-Type"] = "text/html"
+      else
+        @response.headers["Content-Type"] = "text/html"
+        directory_lister = DirectoryLister.new
+        @response.body << directory_lister.list(path)
+      end
+    end
+
+    def read_file(path)
+      file_contents = []
+
+      File.open(path, "r") do |file|
+        while (line = file.gets) do
+          file_contents << line
+        end
+      end
+
+      file_contents
+    end
+
+    def extract_path
+      path = @request[:uri][:path].to_s
+      if path[0] == "/" && path != "/"
+        path = path[1..-1] 
+      end
+      path.gsub(/%20/, " ").strip
+    end
+
+    def serve_directory(path)
+      @response.status = 200
+      if File.exists?("index.html")# || File.exists?("/index.html")
+        @response.body = read_file "index.html"
+        @response.headers["Content-Type"] = "text/html"
+      else
+        @response.headers["Content-Type"] = "text/html"
+        @response.body << DirectoryLister.list(path)
+      end
+    end
+
+    def get_mime_type(path)
+      return false unless path.include? '.'
+      filetype = path.split('.').last
+
+      return case
+    when ["html", "htm"].include?(filetype)
+      "text/html"
+    when "txt" == filetype 
+      "text/plain"
+    when "css" == filetype
+      "text/css"
+    when "js" == filetype
+      "text/javascript"
+    when ["png", "jpg", "jpeg", "gif", "tiff"].include?(filetype)
+      "image/#{filetype}"
+    when ["zip","pdf","postscript","x-tar","x-dvi"].include?(filetype)
+      "application/#{filetype}"
+    else false
+    end
+  end
+
+  def request_path
+    @request[:uri][:path] if @request
+  end
+
+  def client_address
+    @session.peeraddr(:numeric)[2] if @session
+  end
+end
+end

data/lib/yarn/response.rb

@@ -0,0 +1,40 @@
+
+module Yarn
+  class Response
+
+    attr_accessor :content
+
+    def initialize
+      @content = [nil, {}, []]      
+    end
+  
+    def status=(status)
+      @content[0] = status
+    end
+
+    def status
+      @content[0]
+    end
+
+    def headers=(headers)
+      @content[1] = headers
+    end
+
+    def headers
+      @content[1]
+    end
+
+    def body=(body)
+      @content[2] = body
+    end
+
+    def body
+      @content[2]
+    end
+
+    def to_s
+      @content
+    end
+  
+  end
+end

data/lib/yarn/server.rb

@@ -0,0 +1,59 @@
+require 'socket'
+
+module Yarn
+  class Server
+
+    include Logging
+
+    attr_accessor :host, :port, :socket, :socket_listener
+
+    def initialize(app=nil,opts={})
+      # merge given options with default values
+      options = { 
+        output: $stdout, 
+        host: '127.0.0.1', 
+        port: 3000 
+      }.merge(opts)
+
+      @app = app
+      @host,@port,$output = options[:host], options[:port], options[:output]
+
+      @socket = TCPServer.new(@host, @port)
+
+      @handler = @app ? RackHandler.new(@app, options) : RequestHandler.new(options)
+
+      log "Yarn started #{"w/ Rack " if opts[:rackup_file]}and accepting requests on #{@host}:#{@port}"
+    end
+
+    def start
+      @socket_listener = Thread.new do
+        loop do
+          begin
+            session = @socket.accept
+            Thread.new { @handler.clone.run session }
+          rescue Exception => e
+            session.close
+            log e.message
+            log e.backtrace
+          end
+        end
+      end
+
+      begin
+        @socket_listener.join
+      rescue Interrupt => e
+        log "Caught interrupt, stopping..."
+      ensure
+        stop
+      end
+    end
+
+    def stop
+      @socket.close if @socket
+      @socket = nil
+      @socket_listener.kill if @socket_listener
+
+      log "Server stopped"
+    end
+  end
+end