cannon 0.0.2

data/lib/cannon/concerns/signature.rb

@@ -0,0 +1,14 @@
+require 'openssl'
+
+module Signature
+  class CookieSecretNotSet < StandardError; end
+
+  def signature(value)
+    raise CookieSecretNotSet, 'Set config.cookies.secret to use signed cookies' if Cannon.config.cookies.secret.nil?
+    OpenSSL::HMAC.hexdigest(digest, Cannon.config.cookies.secret, value)
+  end
+
+  def digest
+    @digest ||= OpenSSL::Digest.new('sha1')
+  end
+end

data/lib/cannon/config.rb

@@ -0,0 +1,58 @@
+module Cannon
+  class UnknownLogLevel < StandardError; end
+
+  class Config
+    attr_accessor :middleware, :public_path, :view_path, :reload_on_request, :benchmark_requests, :port, :ip_address
+    attr_reader :logger, :log_level
+
+    DEFAULT_MIDDLEWARE = %w{RequestLogger Files Cookies Router ContentType}
+
+    LOG_LEVELS = {
+      unknown: Logger::UNKNOWN,
+      fatal: Logger::FATAL,
+      error: Logger::ERROR,
+      warn: Logger::WARN,
+      info: Logger::INFO,
+      debug: Logger::DEBUG,
+    }
+
+    def initialize
+      self.ip_address = '127.0.0.1'
+      self.port = 5030
+      self.middleware = DEFAULT_MIDDLEWARE
+      self.public_path = 'public'
+      self.view_path = 'views'
+      self.reload_on_request = false
+      self.benchmark_requests = true
+      @log_level = :info
+      self.logger = Logger.new(STDOUT)
+    end
+
+    def logger=(value)
+      @logger = value
+      logger.datetime_format = '%Y-%m-%d %H:%M:%S'
+      logger.formatter = proc do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+      self.log_level = log_level
+    end
+
+    def log_level=(value)
+      raise UnknownLogLevel unless LOG_LEVELS.keys.include? value.to_sym
+      @log_level = value
+      logger.level = LOG_LEVELS[value.to_sym]
+    end
+
+    def cookies
+      @cookies ||= Cookies.new
+    end
+
+    class Cookies
+      attr_accessor :secret
+
+      def initialize
+        self.secret = nil
+      end
+    end
+  end
+end

data/lib/cannon/cookie_jar.rb

@@ -0,0 +1,99 @@
+require 'msgpack'
+
+module Cannon
+  class CookieJar
+    include Signature
+
+    class EndOfString < Exception; end
+
+    def initialize(http_cookie: nil, cookies: nil, signed: false)
+      @http_cookie = http_cookie
+      @cookies = cookies
+      @signed = signed
+
+      self.define_singleton_method(:signed) do
+        @signed_cookies ||= CookieJar.new(cookies: cookies_with_signatures, signed: true)
+      end if !@signed
+    end
+
+    def [](cookie_name)
+      cookie = cookies[cookie_name]
+      if cookie
+        @signed ? verified_signature(cookie_name, cookie) : cookie['value']
+      else
+        nil
+      end
+    end
+
+  private
+
+    def verified_signature(name, cookie)
+      return cookie['value'] if cookie['verified']
+
+      if cookie['signature'] == signature(cookie['value'])
+        cookie['verified'] = true
+        cookie['value']
+      else
+        cookies.delete(name)
+        nil
+      end
+    end
+
+    def cookies_with_signatures
+      cookies.select { |k, v| v.include? 'signature' }
+    end
+
+    def cookies
+      @cookies ||= parse_cookies
+    end
+
+    def parse_cookies
+      cookies = {}
+      return cookies if @http_cookie.nil? || @http_cookie == ''
+
+      begin
+        pos = 0
+        loop do
+          pos = read_whitespace(@http_cookie, pos)
+          name, pos = read_cookie_name(@http_cookie, pos)
+          value, pos = read_cookie_value(@http_cookie, pos)
+          begin
+            cookies[name.to_sym] = MessagePack.unpack(value)
+          rescue StandardError; end
+        end
+      rescue EndOfString
+      end
+
+      cookies
+    end
+
+    def read_whitespace(cookie, pos)
+      raise EndOfString if cookie[pos] == nil
+      pos = pos + 1 while cookie[pos] == ' ' && pos < cookie.length
+      pos
+    end
+
+    def read_cookie_name(cookie, pos)
+      start_pos = pos
+      pos = pos + 1 while !['=', nil].include?(cookie[pos])
+      return cookie[start_pos..(pos - 1)], pos + 1
+    end
+
+    def read_cookie_value(cookie, pos)
+      in_quotes = false
+      pos = pos + 1 and in_quotes = true if cookie[pos] == '"'
+      start_pos = pos
+
+      if in_quotes
+        pos = pos + 1 while pos < cookie.length && !(cookie[pos] == '"' && cookie[pos - 1] != '\\')
+        value = cookie[start_pos..(pos - 1)].gsub("\\\"", '"')
+        pos = pos + 1 while ![';', nil].include?(cookie[pos])
+      else
+        pos = pos + 1 while ![';', nil].include?(cookie[pos])
+        value = cookie[start_pos..(pos - 1)]
+      end
+
+      return value, pos + 1
+    end
+  end
+end

data/lib/cannon/handler.rb

@@ -0,0 +1,25 @@
+module Cannon
+  class Handler < EventMachine::Connection
+    include EventMachine::HttpServer
+
+    def app
+      # magically defined by Cannon::App
+      self.class.app
+    end
+
+    def process_http_request
+      request = Request.new(self, app)
+      response = Response.new(self, app)
+
+      app.reload_environment if app.config.reload_on_request
+
+      app.middleware_runner.run(request, response) if middleware?
+    end
+
+  private
+
+    def middleware?
+      app.config.middleware.size > 0
+    end
+  end
+end

data/lib/cannon/middleware.rb

@@ -0,0 +1,47 @@
+require 'cannon/middleware/flush_and_benchmark'
+require 'cannon/middleware/request_logger'
+require 'cannon/middleware/files'
+require 'cannon/middleware/router'
+require 'cannon/middleware/content_type'
+require 'cannon/middleware/cookies'
+
+module Cannon
+  class MiddlewareRunner
+    include EventMachine::Deferrable
+
+    def initialize(ware, callback:, app:)
+      @app = app
+      @ware, @callback = instantiate(ware), callback
+    end
+
+    def run(request, response)
+      next_proc = -> do
+        setup_callback
+        self.succeed(request, response)
+      end
+
+      result = @ware.run(request, response, next_proc)
+    end
+
+  private
+
+    def setup_callback
+      set_deferred_status nil
+      callback do |request, response|
+        @callback.run(request, response) unless @callback.nil?
+      end
+    end
+
+    def instantiate(ware)
+      if ware.is_a?(String)
+        begin
+          Object.const_get(ware).new(@app)
+        rescue NameError
+          Object.const_get("Cannon::Middleware::#{ware}").new(@app)
+        end
+      else
+        ware.new(@app)
+      end
+    end
+  end
+end

data/lib/cannon/middleware/content_type.rb

@@ -0,0 +1,15 @@
+module Cannon
+  module Middleware
+    class ContentType
+      def initialize(app)
+        @app = app
+      end
+
+      def run(request, response, next_proc)
+        return next_proc.call unless response.headers['Content-Type'].nil?
+        response.headers['Content-Type'] = 'text/plain; charset=us-ascii'
+        next_proc.call
+      end
+    end
+  end
+end

data/lib/cannon/middleware/cookies.rb

@@ -0,0 +1,18 @@
+module Cannon
+  module Middleware
+    class Cookies
+
+      def initialize(app)
+        @app = app
+      end
+
+      def run(request, response, next_proc)
+        request.define_singleton_method(:cookies) do
+          @cookie_jar ||= CookieJar.new(http_cookie: request.http_cookie)
+        end
+        
+        next_proc.call
+      end
+    end
+  end
+end

data/lib/cannon/middleware/files.rb

@@ -0,0 +1,33 @@
+module Cannon
+  module Middleware
+    class Files
+      include PathCache
+
+      def initialize(app)
+        @app = app
+
+        self.cache = :files
+        self.base_path = build_base_path
+      end
+
+      def run(request, response, next_proc)
+        reload_cache if outdated_cache?
+
+        if path_array.include? request.path
+          file, content_type = *file_and_content_type("#{base_path}#{request.path}")
+          response.header('Content-Type', content_type)
+          response.send(file)
+          response.flush
+        else
+          next_proc.call
+        end
+      end
+
+    private
+
+      def build_base_path
+        @app.config.public_path =~ /^\// ? @app.config.public_path : "#{Cannon.root}/#{@app.config.public_path}"
+      end
+    end
+  end
+end

data/lib/cannon/middleware/flush_and_benchmark.rb

@@ -0,0 +1,20 @@
+module Cannon
+  module Middleware
+    class FlushAndBenchmark
+      def initialize(app)
+        @app = app
+      end
+
+      def run(request, response, next_proc)
+        response.flush unless response.flushed?
+        Cannon.logger.debug "Response took #{time_ago_in_ms(request.start_time)}ms" if @app.config.benchmark_requests
+      end
+
+    private
+
+      def time_ago_in_ms(time_ago)
+        Time.at((Time.now - time_ago)).strftime('%6N').to_i/1000.0
+      end
+    end
+  end
+end

data/lib/cannon/middleware/request_logger.rb

@@ -0,0 +1,13 @@
+module Cannon
+  module Middleware
+    class RequestLogger
+      def initialize(app)
+      end
+
+      def run(request, response, next_proc)
+        Cannon.logger.info "#{request.method} #{request.path}"
+        next_proc.call
+      end
+    end
+  end
+end

data/lib/cannon/middleware/router.rb

@@ -0,0 +1,19 @@
+module Cannon
+  module Middleware
+    class Router
+      def initialize(app)
+        @app = app
+      end
+
+      def run(request, response, next_proc)
+        matched_route = @app.routes.find { |route| route.matches? request }
+        if matched_route.nil?
+          response.not_found
+          next_proc.call
+        else
+          matched_route.handle(request, response, next_proc)
+        end
+      end
+    end
+  end
+end

data/lib/cannon/request.rb

@@ -0,0 +1,36 @@
+require 'cgi'
+
+module Cannon
+  class Request
+    attr_accessor :protocol, :method, :http_cookie, :content_type, :path, :uri, :query_string, :post_content, :headers,
+                  :start_time
+
+    def initialize(http_server, app)
+      self.protocol = http_server.instance_variable_get('@http_protocol')
+      self.method = http_server.instance_variable_get('@http_request_method')
+      self.http_cookie = http_server.instance_variable_get('@http_cookie')
+      self.content_type = http_server.instance_variable_get('@http_content_type')
+      self.path = http_server.instance_variable_get('@http_path_info')
+      self.uri = http_server.instance_variable_get('@http_request_uri')
+      self.query_string = http_server.instance_variable_get('@http_query_string')
+      self.post_content = http_server.instance_variable_get('@http_post_content')
+      self.headers = http_server.instance_variable_get('@http_headers')
+      self.start_time = Time.now
+    end
+
+    def params
+      @params ||= parse_params
+    end
+
+  private
+
+    def parse_params
+      case method.downcase
+      when 'get'
+        Hash[CGI::parse(query_string || '').map { |(k, v)| [k.to_sym, v.last] }]
+      else
+        Hash[CGI::parse(post_content || '').map { |(k, v)| [k.to_sym, v.count > 1 ? v : v.first] }]
+      end
+    end
+  end
+end

data/lib/cannon/response.rb

@@ -0,0 +1,165 @@
+require 'msgpack'
+
+module Cannon
+  class Response
+    extend Forwardable
+    include Views
+    include Signature
+
+    attr_reader :delegated_response, :headers
+    attr_accessor :status
+
+    delegate :content => :delegated_response
+    delegate :content= => :delegated_response
+
+    HTTP_STATUS = {
+      continue:                      100,
+      switching_protocols:           101,
+      ok:                            200,
+      created:                       201,
+      accepted:                      202,
+      non_authoritative_information: 203,
+      no_content:                    204,
+      reset_content:                 205,
+      partial_content:               206,
+      multiple_choices:              300,
+      moved_permanently:             301,
+      found:                         302,
+      see_other:                     303,
+      not_modified:                  304,
+      use_proxy:                     305,
+      temporary_redirect:            307,
+      bad_request:                   400,
+      unauthorized:                  401,
+      payment_required:              402,
+      forbidden:                     403,
+      not_found:                     404,
+      method_not_allowed:            405,
+      not_acceptable:                406,
+      proxy_authentication_required: 407,
+      request_timeout:               408,
+      conflict:                      409,
+      gone:                          410,
+      length_required:               411,
+      precondition_failed:           412,
+      request_entity_too_large:      413,
+      request_uri_too_long:          414,
+      unsupported_media_type:        415,
+      requested_range_not_satisfied: 416,
+      expectation_failed:            417,
+      internal_server_error:         500,
+      not_implemented:               501,
+      bad_gateway:                   502,
+      service_unavailable:           503,
+      gateway_timeout:               504,
+      http_version_not_supported:    505,
+    }
+
+    def initialize(http_server, app)
+      @app = app
+      @delegated_response = EventMachine::DelegatedHttpResponse.new(http_server)
+      @flushed = false
+      @headers = {}
+      @cookies = {}
+
+      initialize_views
+
+      self.status = :ok
+    end
+
+    def flushed?
+      @flushed
+    end
+
+    def send(content, status: self.status)
+      self.content ||= ''
+      self.status = status
+      delegated_response.status = converted_status(status)
+      delegated_response.content += content
+    end
+
+    def flush
+      unless flushed?
+        set_cookie_headers
+        delegated_response.headers = self.headers
+        delegated_response.send_response
+        @flushed = true
+      end
+    end
+
+    def header(key, value)
+      headers[key] = value
+    end
+
+    def location_header(location)
+      header('Location', location)
+    end
+
+    def permanent_redirect(location)
+      location_header(location)
+      self.status = :moved_permanently
+      flush
+    end
+
+    def temporary_redirect(location)
+      location_header(location)
+      self.status = :found
+      flush
+    end
+
+    def not_found
+      send('Not Found', status: :not_found)
+    end
+
+    def internal_server_error(title:, content:)
+      html = "<html><head><title>Internal Server Error: #{title}</title></head><body><h1>#{title}</h1><p>#{content}</p></body></html>"
+      header('Content-Type', 'text/html')
+      send(html, status: :internal_server_error)
+    end
+
+    def cookie(cookie, value:, expires: nil, httponly: nil, signed: false)
+      cookie_options = {:value => value}
+      cookie_options[:expires] = expires unless expires.nil?
+      cookie_options[:httponly] = httponly unless httponly.nil?
+      cookie_options[:signed] = signed
+      @cookies[cookie] = cookie_options
+    end
+
+  private
+
+    def set_cookie_headers
+      cookie_headers = (headers['Set-Cookie'] = [])
+      @cookies.each do |cookie, cookie_options|
+        cookie_headers << build_cookie_value(cookie, cookie_options)
+      end
+    end
+
+    def build_cookie_value(name, options)
+      cookie = "#{name}=#{cookie_value(options[:value], signed: options[:signed])}"
+      cookie << "; Expires=#{options[:expires].httpdate}" if options.include?(:expires)
+      cookie << '; HttpOnly' if options[:httponly] == true
+      cookie
+    end
+
+    def converted_status(status)
+      if status.is_a?(Symbol)
+        HTTP_STATUS[status] || status.to_s
+      elsif status.is_a?(Fixnum)
+        status
+      else
+        status.to_s
+      end
+    end
+
+    def cookie_value(value, signed:)
+      cookie_hash = {'value' => value}
+      cookie_hash['signature'] = signature(value) if signed
+      escape_cookie_value(cookie_hash.to_msgpack)
+    end
+
+    def escape_cookie_value(value)
+      return value unless value.match(/([\x00-\x20\x7F",;\\])/)
+      "\"#{value.gsub(/([\\"])/, "\\\\\\1")}\""
+    end
+  end
+end