spyder 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acf6ba3240fd34ee197d51298611eaf540b096593d135899c6776cd7378f2726
-  data.tar.gz: 0035fda272f0b56c184529166654daec8d3f8b0b6757bfda5e0cbc86d4010234
+  metadata.gz: 3417dd82aa219dd2526c0fb01be1f6e9c58723651bac784b2f082a4c8d3b5f20
+  data.tar.gz: eca6629c49c0048f7304da5c71f8701d38b1a24ef4a160f923bf5267d0cea628
 SHA512:
-  metadata.gz: 033d5355015791027499d3650cfdf94e0d3dd4db326a4cd7b461b939f73744ae461b57f5213790dd5874edbfe8bddef25cc4abf0b866e474e28a7bdb47943b19
-  data.tar.gz: 979996a1e7761986950816d84ca25b6dead8b5450736b1c2efb2aeddc17b8357028a12f9ec293488a0175a67cdd6c1d0ebb9ead0a4ac5301e3b76e02589c2fe5
+  metadata.gz: d97926b4bc3a3064d7e6224c0bbb61ec2a225207f766802be5821db8d9b092eba60e92aec37b5012843e073999aa057c79e946551503e680dcf7c2e327013f32
+  data.tar.gz: 51a1d5d5a6b4e8d7ba2598ddcf674e1acb224e35fa77a2c53f90a97f936709bc52274f9f92cef492d93f96ef3095758a7e946e63cc2db7720859a4c654096509

data/lib/examples/simplest_server/server.rb

@@ -0,0 +1,17 @@
+require 'spyder'
+
+server = Spyder::Server.new('0.0.0.0', 8080)
+
+server.router.add_route 'GET', '/hello-world' do |request, _|
+  which_world = request.query_params['world'] || 'Earth'
+
+  resp = Spyder::Response.new
+  resp.add_standard_headers
+  resp.set_header 'content-type', 'text/plain'
+  resp.body = "hello from #{which_world}!"
+
+  resp
+end
+
+puts "Now navigate to http://localhost:8080/?world=Mars"
+server.start

data/lib/spyder/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Spyder
+  class BaseError < ::StandardError
+  end
+end

data/lib/spyder/header_store.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module Spyder
+  class HeaderStore
+    class MissingHeaderError < ::Spyder::BaseError
+    end
+
+    # headers as they have been received. Untransformed and in order
+    attr_reader :ordered
+
+    # headers, indexed. All keys are lower case
+    attr_reader :dict
+
+    # either :request or :response
+    attr_accessor :kind
+
+    def initialize kind=nil
+      @kind = kind
+      @ordered = []
+      @dict = {}
+    end
+
+    def fetch key, default_value=nil
+      value = @dict.fetch(key.downcase, default_value)
+      return value unless value == nil
+      return yield(key) if block_given?
+      nil
+    end
+
+    def get! key
+      value = fetch key
+      raise MissingHeaderError.new(key) if value == nil
+      value
+    end
+
+    def add_header key, value
+      @ordered << [key, value]
+      @dict[key.downcase] = value
+    end
+
+    def set_header key, value
+      key_lower = key.downcase
+      if @kind == :response && key_lower == 'set-cookie'
+        add_header key_lower, value
+      else
+        @dict[key_lower] = value
+        oh_index = @ordered.find_index { |k, v| k.downcase == key_lower }
+        if oh_index
+          @ordered[oh_index][1] = value
+        else
+          @ordered << [key, value]
+        end
+      end
+    end
+  end
+end

data/lib/spyder/request.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Spyder
+  class Request
+    extend Forwardable
+
+    attr_accessor :verb
+    attr_accessor :path
+    attr_accessor :headers
+    attr_accessor :protocol, :remote_address
+    attr_accessor :io
+
+    def_delegators :@headers, :ordered, :dict, :add_header
+
+    def initialize
+      @headers = HeaderStore.new(:request)
+    end
+
+    def host_with_port
+      result = dict['host']&.split(':')
+      return nil if result == nil
+      result << 443 if result.length < 2
+      result
+    end
+
+    def host
+      h = host_with_port
+      return nil if h == nil
+      h[0]
+    end
+
+    def port
+      h = host_with_port
+      return nil if h == nil
+      h[1]
+    end
+
+    def path_info
+      separator = path.index '?'
+      return path if separator == nil
+      path[0...separator]
+    end
+
+    def query_string
+      separator = path.index '?'
+      return nil if separator == nil
+      path[separator+1..-1]
+    end
+
+    def query_params
+      return {} unless query_string
+      res = {}
+      query_string.split('&').each do |line|
+        name, value = line.split('=')
+        name = CGI.unescape(name)
+        value = CGI.unescape(value)
+
+        if name.end_with?('[]') && name.length > 2
+          name = name[..-3]
+          arr = res.fetch(name, [])
+          arr = (res[name] = [])
+          arr << value
+        else
+          res[name] = value
+        end
+      end
+
+      res
+    end
+
+    def read_full_body
+      len = dict['content-length']
+      len ? io.read(Integer(len)) : io.read # FIXME:
+    end
+
+    def has_body?
+      dict['transfer-encoding'] != nil || dict['content-length'] != nil
+    end
+
+    def verb_allows_body?
+      %w(POST PUT PATCH).include?(verb)
+    end
+  end
+end

data/lib/spyder/response.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Spyder
+  class Response
+    attr_reader :code
+    attr_accessor :body
+    attr_reader :headers
+    attr_writer :reason_sentence
+
+    CODE_TO_REASON_SENTENCE = {
+      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 => 'Found',
+      303 => 'See Other',
+      304 => 'Not Modified',
+      305 => 'Use Proxy',
+      307 => 'Temporary Redirect',
+      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 Timeout',
+      409 => 'Conflict',
+      410 => 'Gone',
+      411 => 'Length Required',
+      412 => 'Precondition Failed',
+      413 => 'Payload Too Large',
+      414 => 'URI Too Long',
+      415 => 'Unsupported Media Type',
+      416 => 'Range Not Satisfiable',
+      417 => 'Expectation Failed',
+      418 => 'I\'m a teapot',
+      422 => 'Unprocessable Entity',
+      426 => 'Upgrade Required',
+      500 => 'Internal Server Error',
+      501 => 'Not Implemented',
+      502 => 'Bad Gateway',
+      503 => 'Service Unavailable',
+      504 => 'Gateway Timeout',
+      505 => 'HTTP Version Not Supported',
+    }.freeze
+
+    SYMBOL_TO_CODE = CODE_TO_REASON_SENTENCE.to_a.to_h do |code, name|
+      [
+        name.downcase.tr(' ', '_').tr("'", '').to_sym,
+        code
+      ]
+    end.freeze
+
+    def initialize
+      self.code = :ok
+      @headers = HeaderStore.new(:response)
+    end
+
+    def add_standard_headers
+      set_header 'date', Time.now.httpdate
+      set_header 'server', "spyder/#{::Spyder::VERSION}"
+    end
+
+    def nocache!
+      set_header 'expires', Time.at(0).httpdate
+      set_header 'cache-control', 'private, no-store, no-cache'
+    end
+
+    def code=(value)
+      @code = value.is_a?(Symbol) ? SYMBOL_TO_CODE.fetch(value) : value
+    end
+
+    def set_header(key, value)
+      @headers.set_header(key, value)
+    end
+
+    def reason_sentence
+      @reason_sentence || CODE_TO_REASON_SENTENCE[@code]
+    end
+
+    def self.make_generic(code, payload=nil)
+      new.tap do |r|
+        code = SYMBOL_TO_CODE.fetch(code, code)
+        r.body = (payload || "#{code} #{CODE_TO_REASON_SENTENCE[code]}")
+        r.code = code
+        r.add_standard_headers
+        r.nocache!
+      end
+    end
+  end
+end

data/lib/spyder/router.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Spyder
+  class Router
+    attr_accessor :fallback_route
+
+    def initialize
+      @routes = Hash.new { |k, v| k[v] = [] }
+    end
+
+    def add_route(verb, matcher, &handler)
+      matcher = Mustermann.new(matcher) if matcher.is_a?(String)
+
+      @routes[verb.to_s.upcase] << [matcher, handler]
+    end
+
+    def call(ctx, request)
+      only_path = request.path_info
+
+      handler, match_data = nil
+      @routes[request.verb].any? do |mt, h|
+        md = mt.match(only_path)
+        if md
+          handler = h
+          match_data = md
+        end
+      end
+
+      match_data ? handler.call(request, match_data) : Response.make_generic(:not_found)
+    end
+  end
+
+  class RouterApp
+    def initialize(router, _)
+      @router = router
+    end
+
+    def call(ctx, request)
+      @router.call(ctx, request)
+    end
+  end
+end

data/lib/spyder/server.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Spyder
+  class Server
+    attr_accessor :router
+
+    def initialize(bind, port, router: Router.new, max_threads: 4, tcp_backlog: 10)
+      @server = TCPServer.new(bind, port)
+      @tcp_backlog = tcp_backlog
+      @max_threads = max_threads
+      @middleware = []
+      @threads = []
+      @tp_sync = Mutex.new
+      @router = router
+    end
+
+    def add_middleware(callable, args)
+      @middleware << [callable, args]
+    end
+
+    def start
+      busy_threads = 0
+      @server.listen(@tcp_backlog)
+
+      loop do
+        time_start = Process.clock_gettime(:CLOCK_MONOTONIC, :float_second)
+        loop do
+          current_busy = @tp_sync.synchronize { busy_threads }
+          break if current_busy < @max_threads
+          sleep(0)
+          current_time = Process.clock_gettime(:CLOCK_MONOTONIC, :float_second)
+          if (current_time - time_start) > 1.0
+            # puts "Waiting a long time: #{(current_time - time_start)}"
+            sleep 0.2
+          end
+        end
+
+        client = @server.accept
+        @tp_sync.synchronize { busy_threads += 1 }
+
+        Thread.new do
+          begin
+            error = nil
+            begin
+              process_new_client(client)
+            rescue Exception => e
+              error = e
+            end
+
+            if error
+              puts error.full_message
+
+              response = Response.make_generic :internal_server_error
+              dispatch_response(client, response)
+            end
+
+            client.close rescue nil
+          ensure
+            @tp_sync.synchronize { busy_threads -= 1 }
+          end
+        end
+      end
+    end
+
+    def process_request(request)
+      mids = @middleware + [[RouterApp, @router]]
+      app = nil
+      loop do
+        klass, args = mids.pop
+        break unless klass
+        app = klass.new(args, app)
+      end
+
+      app.call({}, request)
+    end
+
+    def process_new_client(socket)
+      verb, path, protocol = read_line(socket).split(' ')
+      request = Request.new
+      request.path = path
+      request.verb = verb
+      request.io = socket
+
+      loop do
+        line = read_line(socket)
+        break if line == ''
+        sep = line.index(':')
+        name = line[0...sep].downcase
+        value = line[(sep + 2)..]
+        request.add_header(name, value)
+      end
+
+      response = process_request(request)
+
+      dispatch_response(socket, response)
+    end
+
+    def dispatch_response(socket, response)
+      content_length = response.headers.dict['content-length']
+      if !content_length && response.body && response.body.is_a?(String)
+        content_length = response.body.length
+      end
+
+      begin
+        socket.write("HTTP/1.1 #{response.code} #{response.reason_sentence.b}\r\n")
+        response.headers.ordered.each do |name, value|
+          socket.write("#{name.b}: #{value.b}\r\n")
+        end
+        socket.write("connection: close\r\n") # FIXME:
+        socket.write("content-length: #{content_length}\r\n") if content_length
+        socket.write("\r\n")
+
+        if response.body
+          Array(response.body).each do |part|
+            content = part.respond_to?(:call) ? part.call : part
+            socket.write(content.b)
+          end
+        end
+      rescue Errno::EPIPE
+        # socket closed. So what?
+        socket.close rescue nil
+      end
+    end
+
+    def read_line(socket)
+      line_limit = 1024 * 16
+      buffer = String.new(capacity: 128)
+      almost = false
+      loop do
+        line_limit -= 1
+        return false unless line_limit > 0
+
+        c = socket.readchar
+        if !almost && c == "\r"
+          almost = true
+        elsif almost
+          return false unless c == "\n"
+          return buffer
+        else
+          buffer += c
+        end
+      end
+    end
+  end
+end

data/lib/spyder/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Spyder
+  VERSION = '0.1.2'
+end

data/lib/spyder.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require 'mustermann'
+require 'date'
+require 'time'
+require 'forwardable'
+require 'socket'
+require 'cgi'
+
+require 'spyder/version'
+require 'spyder/error'
+require 'spyder/header_store'
+require 'spyder/request'
+require 'spyder/response'
+require 'spyder/router'
+require 'spyder/server'

metadata

@@ -1,43 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: spyder
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
-- André Piske
-autorequire: 
+- André D. Piske
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-17 00:00:00.000000000 Z
+date: 2024-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: mustermann
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.20.3
-  type: :development
+        version: '3.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.20.3
-description: Reserved for the future
-email: ''
-executables:
-- spyder
+        version: '3.0'
+description: Spyder Web
+email: andrepiske@gmail.com
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- bin/spyder
-homepage: https://rubygems.org/gems/spyder
+- lib/examples/simplest_server/server.rb
+- lib/spyder.rb
+- lib/spyder/error.rb
+- lib/spyder/header_store.rb
+- lib/spyder/request.rb
+- lib/spyder/response.rb
+- lib/spyder/router.rb
+- lib/spyder/server.rb
+- lib/spyder/version.rb
+homepage: https://github.com/andrepiske/spyder
 licenses:
 - MIT
-metadata:
-  source_code_uri: https://github.com/andrepiske/spydergem
-post_install_message: 
+metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -52,8 +58,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.5.6
+signing_key:
 specification_version: 4
-summary: Reserved for the future
+summary: Spyder
 test_files: []

data/bin/spyder

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-require "thor"
-puts("LOL, not using thor at all")