emmy-http-server 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 640f4d91ac5b7afc7d9c187c66a632698954576a
+  data.tar.gz: c96485fca03f0ad17ce33023b8a3d0e950aa7a8d
+SHA512:
+  metadata.gz: a4ed46332b0258af15ef204ad1ed57ea872763734944e1414aee2da43e04943d91f49530383bdb784d9a5f84e1589f8e7100f92023d1f37e5c36ab537508985c
+  data.tar.gz: 61f7f595899b0a7f53b5660e67889316453885cbef5a9638bd149fecb78fea09a42e720584070614dd284f45a5f3b8332a92924ad6b86cb841825724c30350d4

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+/examples/Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in emmy-http-server.gemspec
+gemspec

data/README.md

@@ -0,0 +1,41 @@
+# EmmyHttp::Server
+
+
+## Usage
+
+```ruby
+server do
+  connect do |req, res|
+    response.success()
+  end
+end
+
+bind *server
+```
+
+### Routing
+
+```ruby
+server do
+  get '/' do
+    #...
+  end
+end
+
+bind *server
+```
+
+### Rack support
+
+```ruby
+app do
+  use Rack::Logger
+
+  #run Sinatra::Application
+  get '/' do
+    #...
+  end
+end
+
+bind *app
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/emmy-http-server.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'emmy_http/server/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "emmy-http-server"
+  spec.version       = EmmyHttp::Server::VERSION
+  spec.authors       = ["inre"]
+  spec.email         = ["inre.storm@gmail.com"]
+
+  spec.summary       = %q{Emmy HTTP Server}
+  spec.description   = %q{Emmy HTTP Server}
+  #spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "http_parser.rb", "~> 0.6.0"
+  spec.add_dependency "addressable",    "~> 2.3.8"
+  spec.add_dependency "event_object",   "~> 0.9"
+  spec.add_dependency "fibre",          "~> 0.9"
+  spec.add_dependency "emmy-machine",   "~> 0.1"
+  spec.add_dependency "emmy-http",      "~> 0.2"
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake",    "~> 10.0"
+  spec.add_development_dependency "rspec",   "~> 3"
+end

data/examples/Gemfile

@@ -0,0 +1,5 @@
+
+gem 'sinatra'
+gem 'emmy'
+gem 'emmy-http-server', path: '../'
+gem 'emmy-http'

data/examples/app.rb

@@ -0,0 +1,5 @@
+require 'sinatra'
+
+get '/' do
+  'Hello world!'
+end

data/examples/simple.rb

@@ -0,0 +1,21 @@
+require 'bundler/setup'
+require 'emmy'
+require 'emmy_http/server'
+require './app'
+using EventObject
+
+Emmy.run do
+  app = EmmyHttp::Application.new do
+    run Sinatra::Application
+  end
+
+  server = EmmyHttp::Server::Server.new(Emmy::Runner.instance.config, app)
+
+  Emmy.bind(*server)
+  puts "Bind server on #{server.config.url}"
+
+  server.on :error do |err|
+    puts err.message
+    puts err.backtrace.join("\n")
+  end
+end

data/lib/emmy_http/server/parser.rb

@@ -0,0 +1,60 @@
+require 'http/parser'
+
+module EmmyHttp
+  class Server::Parser
+    using EventObject
+
+    events :head, :body, :complete
+
+    attr_accessor :http_parser
+    attr_accessor :stop
+    attr_accessor :no_body
+
+    def initialize
+      @http_parser = HTTP::Parser.new
+      @http_parser.header_value_type = :mixed
+      @http_parser.on_headers_complete = proc do
+        head!(http_parser.headers, http_parser)
+        stop ? :stop : (no_body ? :reset : nil)
+      end
+      @http_parser.on_body = proc do |chunk|
+        body!(chunk)
+      end
+      @http_parser.on_message_complete = proc do
+        complete!
+      end
+    end
+
+    def <<(data)
+      @http_parser << data
+    rescue HTTP::Parser::Error => e
+      raise EmmyHttp::ParserError, e.to_s
+    end
+
+    def status_code
+      @http_parser.status_code
+    end
+
+    def http_method
+      @http_parser.http_method
+    end
+
+    def headers
+      @http_parser.headers
+    end
+
+    def http_version
+      @http_parser.http_version
+    end
+
+    def request_url
+      @http_parser.request_url
+    end
+
+    def reset!
+      @http_parser.reset!
+    end
+
+    #<<<
+  end
+end

data/lib/emmy_http/server/request.rb

@@ -0,0 +1,153 @@
+module EmmyHttp
+  class Server::Request
+    include ModelPack::Document
+    using EventObject
+
+    attribute :http_version
+    attribute :http_method
+    attribute :url,
+          writer:    -> (v) { Addressable::URI.parse(v) },
+          serialize: -> (v) { v.to_s }
+    dictionary :headers
+    attribute :body
+    attribute :decoder
+    attribute :env
+    #attribute :upgrade_data
+
+    attr_reader :connection
+    attr_reader :parser
+    attr_reader :request
+    attr_reader :remote_address
+
+    events :data, :complete, :terminate
+
+    def initialize
+      @parser = Server::Parser.new
+      @body   = StringIO.new(Server::INITIAL_BODY.dup)
+      request = self
+
+      on :data do |chunk|
+        @body << chunk
+      end
+
+      parser.on :head do |headers|
+        request.http_version = parser.http_version
+        request.http_method  = parser.http_method
+        request.url     = parser.request_url
+        request.headers = parser.headers
+      end
+
+      parser.on :body do |chunk|
+        request.data!(request.decoder ? (request.decoder.decompress(chunk) || '') : chunk)
+      end
+
+      parser.on :complete do
+        conn = request.connection
+        dettach
+        complete!(request, conn)
+      end
+    end
+
+    def post_data(chunk)
+      #p chunk
+      parser << chunk
+
+      #if parser.upgrade?
+      #end
+    rescue EmmyHttp::ParserError => e
+      close(e.message)
+    end
+
+    def keep_alive?
+      #return false if terminate_connection?
+      case http_version
+      when [1,0] then
+        (headers['Connection'].downcase == 'keep-alive') rescue false
+      when [1,1] then
+        (headers['Connection'].downcase != 'close') rescue true
+      when [2,0] then
+        false
+      else
+        false
+      end
+    end
+
+    def prepare_env
+      @env = {}
+
+      # Server info
+
+      @env['rack.version']      = Server::RACK_VERSION_NUM
+      @env['rack.errors']       = STDERR
+      @env['rack.multithread']  = false
+      @env['rack.multiprocess'] = false
+      @env['rack.run_once']     = false
+      #env['rack.logger']       = logger
+
+      # HTTP headers
+
+      headers.each do |n, v|
+        @env['HTTP_' + n.gsub('-','_').upcase] = v
+      end
+
+      %w(CONTENT_TYPE CONTENT_LENGTH).each do |n|
+        @env[n] = @env.delete("HTTP_#{n}") if @env["HTTP_#{n}"]
+      end
+
+      @env['SERVER_NAME']       = 'localhost'
+      @env['SERVER_SOFTWARE']   = Server::SERVER_NAME
+
+      if @env['HTTP_HOST'] # FIXME
+        name, port = @env['HTTP_HOST'].split(':')
+        @env['SERVER_NAME'] = name if name
+        @env['SERVER_PORT'] = port if port
+      end
+
+      uri = URI(parser.request_url)
+
+      @env['HTTP_VERSION']    = "HTTP/#{http_version.join('.')}"
+      @env['REMOTE_ADDR']     = remote_address
+      @env['REQUEST_METHOD']  = http_method
+      @env['REQUEST_URI']     = url.to_s
+      @env['QUERY_STRING']    = url.query# || ""
+      @env['SCRIPT_NAME']     = ""
+      @env['REQUEST_PATH']    = url.path
+      @env['PATH_INFO']       = url.path
+      @env['FRAGMENT']        = url.fragment
+
+      # HTTP body
+
+      @env['rack.input'] = body
+    end
+
+    def close(reason=nil)
+      terminate!(reason, self, connection) if reason
+      dettach
+    end
+
+    def attach(conn)
+      @connection = conn
+      @remote_address = socket_address
+      listen conn, :data,  :post_data
+      listen conn, :close, :close
+    end
+
+    def dettach
+      if connection
+        stop_listen connection, :data
+        stop_listen connection, :close
+        @connection = nil
+      end
+    end
+
+    protected
+
+    def socket_address
+      Socket.unpack_sockaddr_in(connection.get_peername)[1]
+    rescue Exception
+      nil
+    end
+
+    #<<<
+  end
+end

data/lib/emmy_http/server/response.rb

@@ -0,0 +1,84 @@
+module EmmyHttp
+  class Server::Response
+    include ModelPack::Document
+    using EventObject
+
+    attribute :status, writer: -> (v) { v ? v.to_i : v }
+    dictionary :headers
+    attribute :body
+
+    events :terminate
+
+    attr_accessor :keep_alive
+    attr_accessor :connection
+    attr_writer :headers_sent
+    attr_writer :finished
+
+    def write_all
+      write_head unless headers_sent?
+      write_body unless finished?
+    end
+
+    def write_head
+      raise ResponseError, "Invalid HTTP status" unless Server::HTTP_STATUS_CODES.key?(status)
+
+      prepare_headers
+      head = "HTTP/1.1 #{status} #{Server::HTTP_STATUS_CODES[status.to_i]}\r\n"
+
+      headers.each do |n, v|
+        head += "#{n}: #{v}\r\n" if v
+      end
+
+      head += "\r\n"
+
+      connection.send_data(head)
+      @headers_sent = true
+    end
+
+    def write_body
+      if body.respond_to?(:each)
+        body.each { |chunk| connection.send_data(chunk) }
+      else
+        connection.send_data(body) if body
+      end
+      @finished = true
+    end
+
+    def close(reason=nil)
+      body.close if body.respond_to?(:close)
+      terminate!(reason, self, connection) if reason
+      dettach
+    end
+
+    def attach(conn)
+      @connection = conn
+      listen conn, :close, :close
+    end
+
+    def dettach
+      if connection
+        stop_listen connection, :close
+        @connection = nil
+      end
+    end
+
+    def headers_sent?
+      @headers_sent
+    end
+
+    def finished?
+      @finished
+    end
+
+    protected
+
+    def prepare_headers
+      headers['Server'] ||= Server::SERVER_NAME
+      headers['Date'] ||= Time.now.httpdate
+      headers['Connection'] = keep_alive ? 'keep-alive' : 'close'
+      #headers['Content-Length'] ||= "#{body.bytesize}" if body
+    end
+
+    #<<<
+  end
+end

data/lib/emmy_http/server/server.rb

@@ -0,0 +1,112 @@
+require "emmy_http/server/version"
+
+module EmmyHttp
+  class Server::Server
+    using EventObject
+
+    attr_accessor :config
+    attr_accessor :app
+    attr_accessor :connections
+    attr_accessor :parser
+
+    events :connect, :request, :error
+
+    def initialize(config, app=nil)
+      @config = config
+      @app = app
+      @connections = []
+
+      if app
+        on :request do |req, res|
+          req.prepare_env
+          res.status, res.headers, res.body = app.call(req.env)
+        end
+      else
+        on :request do |req, res|
+          error!('No app found', req, res)
+        end
+      end
+
+      on :error do |reason, req, res|
+        if res.headers_sent?
+          # big problems
+        else
+          body = reason ? reason.to_s : 'An error happened'
+          res.update_attributes(
+            status: 500,
+            headers: {
+              'Content-Type'   => 'text/plain',
+              'Content-Length' => body.bytesize
+            },
+            body: body
+          )
+        end
+      end
+    end
+
+    # initialize a new connection
+    def initialize_connection(conn)
+      conn.comm_inactivity_timeout = config.timeout.to_i
+      conn.start_tls(config.ssl ? config.ssl.serializable_hash : {}) if ssl?
+      # Create a new request
+      req = new_request(conn)
+      # Connected event
+      connect!(req, conn)
+    end
+
+    def new_request(conn)
+      req = Server::Request.new(
+        #decoder: config.decoding ? new_decoder_by_encoding(headers['Content-Encoding']) : nil
+      )
+
+      req.on :complete do |req, conn|
+        res = Server::Response.new
+        res.keep_alive = req.keep_alive?
+        res.attach(conn)
+
+        EmmyMachine.fiber_block do
+          # Process request event
+          begin
+            request!(req, res)
+          rescue StandardError => err
+            error!(err, req, res)
+          end
+
+          # Send response
+          res.write_all
+          # Close/Dettach response
+          res.close
+          # Disconnect after response
+          if res.keep_alive
+            new_request(conn)
+          else
+            conn.close_connection_after_writing
+          end
+        end
+      end
+
+      req.on :error do |reason, req, conn|
+        error!(reason)
+        conn.close_connection_after_writing rescue nil
+      end
+
+      req.attach(conn)
+      req
+    end
+
+    def ssl?
+      config.ssl || config.url.scheme == 'https' || config.url.port == 443
+    end
+
+    #def stop(reason=nil)
+    #  @stop_reason ||= reason
+    #  connection.close_connection if connection
+    #end
+
+    def to_a
+      [config.url, EmmyMachine::Connection, method(:initialize_connection)]
+    end
+
+    #<<<
+  end
+end

data/lib/emmy_http/server/version.rb

@@ -0,0 +1,5 @@
+module EmmyHttp
+  module Server
+    VERSION = "0.1.0"
+  end
+end

data/lib/emmy_http/server.rb

@@ -0,0 +1,55 @@
+require "emmy_http/server/version"
+require "emmy_http/server/parser"
+require "emmy_http/server/request"
+require "emmy_http/server/response"
+require "emmy_http/server/server"
+
+module EmmyHttp
+  module Server
+    INITIAL_BODY = ''
+    INITIAL_BODY.encode!(Encoding::ASCII_8BIT) if INITIAL_BODY.respond_to?(:encode)
+
+    SERVER_NAME         = 'Emmy'.freeze
+    RACK_VERSION_NUM    = [1, 0]
+
+    HTTP_STATUS_CODES = {
+      100 => 'Continue',
+      101 => 'Switching Protocols',
+      200 => 'OK',
+      201 => 'Created',
+      202 => 'Accepted',
+      203 => 'Non-Authoritative Information',
+      204 => 'No Content',
+      205 => 'Reset Content',
+      206 => 'Partial Content',
+      300 => 'Multiple Choices',
+      301 => 'Moved Permanently',
+      302 => 'Moved Temporarily',
+      303 => 'See Other',
+      304 => 'Not Modified',
+      305 => 'Use Proxy',
+      400 => 'Bad Request',
+      401 => 'Unauthorized',
+      402 => 'Payment Required',
+      403 => 'Forbidden',
+      404 => 'Not Found',
+      405 => 'Method Not Allowed',
+      406 => 'Not Acceptable',
+      407 => 'Proxy Authentication Required',
+      408 => 'Request Time-out',
+      409 => 'Conflict',
+      410 => 'Gone',
+      411 => 'Length Required',
+      412 => 'Precondition Failed',
+      413 => 'Request Entity Too Large',
+      414 => 'Request-URI Too Large',
+      415 => 'Unsupported Media Type',
+      500 => 'Internal Server Error',
+      501 => 'Not Implemented',
+      502 => 'Bad Gateway',
+      503 => 'Service Unavailable',
+      504 => 'Gateway Time-out',
+      505 => 'HTTP Version not supported'
+    }
+  end
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: emmy-http-server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- inre
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.8
+- !ruby/object:Gem::Dependency
+  name: event_object
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: fibre
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: emmy-machine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: emmy-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Emmy HTTP Server
+email:
+- inre.storm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- emmy-http-server.gemspec
+- examples/Gemfile
+- examples/app.rb
+- examples/simple.rb
+- lib/emmy_http/server.rb
+- lib/emmy_http/server/parser.rb
+- lib/emmy_http/server/request.rb
+- lib/emmy_http/server/response.rb
+- lib/emmy_http/server/server.rb
+- lib/emmy_http/server/version.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Emmy HTTP Server
+test_files: []