pickles_http 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a286f482b6a031c86c1466c37d0e53a21440e54f9b74345bab2861bd276514bf
+  data.tar.gz: 14600496b57a31c095f916241e413d664b209d5d255f5990795ac2a537ebd67c
+SHA512:
+  metadata.gz: 334a300e1e486e682b8790bfbf7159b323ff3b6e2574839168adca3d067657c40527bc40be254c43a60119a48f1c98baf34b13966c971e9994f653e441e8e661
+  data.tar.gz: 945c6e86a17683f23e523dcf118f325bd7935fe2f56ac4edeefec45bb7070f78dd3e63df66164b71e38a3f5091c78b99c0d648cf77b08a5cd4b8927a02e25b20

data/lib/pickles_http/logger.rb

@@ -0,0 +1,35 @@
+require_relative 'utils'
+
+class PicklesHttpServer
+  class Logger
+    include PicklesHttpServer::Utils
+
+    def initialize(log_file, log_path: "./log.txt")
+      @log_file = File.open(log_path, 'a') if log_file
+    end
+
+    def set_log_path(new_path)
+      @log_file.close if @log_file if @log_file
+      @log_file = File.open(new_path, 'a') if @log_file
+    end
+
+    def log(message, severity = LogMode::INFO)
+      severity_level = LogMode::SEVERITIES[severity.upcase] || LogMode::SEVERITIES[LogMode::INFO]
+      log_entry(severity_level, message)
+    end
+
+    def close
+      @log_file.close if @log_file
+    end
+
+    private
+
+    def log_entry(level, message)
+      timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+      log_entry = "[#{timestamp}] [#{LogMode::SEVERITIES.keys[level]}] #{message}\n"
+      puts log_entry
+      @log_file.puts(log_entry) if @log_file
+      @log_file.flush if @log_file
+    end
+  end
+end

data/lib/pickles_http/router.rb

@@ -0,0 +1,23 @@
+class PicklesHttpServer
+  class Router
+    def initialize()
+      @routes = {}
+    end
+
+    def add_route(method, path, handler)
+      method = method.upcase
+      @routes[method] ||= {}
+      @routes[method][path] = handler
+    end
+
+    def route_request(method, path)
+      method = method.upcase
+      return nil unless @routes[method]
+
+      handler = @routes[method][path]
+      return nil unless handler
+
+      handler
+    end
+  end
+end

data/lib/pickles_http/server.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'http/parser'
+require 'concurrent'
+require_relative 'utils'
+require_relative 'router'
+require_relative 'logger'
+
+READ_CHUNK = 1024 * 4
+
+class PicklesHttpServer
+  class Server
+    include PicklesHttpServer::Utils
+
+    def initialize(port, log_file, host)
+      @port = port
+      @socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM)
+
+      addr = Socket.pack_sockaddr_in(port, '127.0.0.1')
+      @socket.bind(addr)
+      @socket.listen(Socket::SOMAXCONN)
+      @socket.setsockopt(:SOCKET, :REUSEADDR, true)
+
+      @router = Router.new
+      @logger = PicklesHttpServer::Logger.new(log_file)
+      @request_queue = SizedQueue.new(10)
+      @write_mutex = Mutex.new
+      @middlewares = []
+      @not_found_message = "404: Route not found"
+    end
+
+    def change_server_option(option, value)
+      @not_found_message = value if option == "set_default_not_found_message"
+    end
+
+    def add_route(method, path, handler)
+      @router.add_route(method, path, handler)
+    end
+
+    def use_middleware(middleware)
+      @middlewares << middleware
+    end
+
+    def start
+      puts "PicklesServer is running on http://localhost:#{@port} 🔥"
+      start_request_processing_thread
+      accept_and_process_requests
+    end
+
+    private
+
+    def start_request_processing_thread
+      Thread.new do
+        loop do
+          req_queue = @request_queue.pop
+          handle_request(req_queue)
+        end
+      end
+    end
+
+    def accept_and_process_requests
+      loop do
+        client, addrinfo = @socket.accept
+        begin
+          request = client.readpartial(READ_CHUNK)
+          @request_queue.push({ client: client, request: request })
+        rescue EOFError => e
+          puts "Client closed the connection: #{e.message}"
+          puts e.backtrace.join("\n")
+          client.close
+        rescue StandardError => e
+          puts "Error in accept_and_process_requests: #{e.message}"
+          puts e.backtrace
+        end
+      end
+    end
+
+    def handle_request(request_queue)
+      client = request_queue.fetch(:client)
+      request = request_queue.fetch(:request)
+
+      method, path, version = request.lines[0].split
+
+      headers = read_headers(request)
+      body = request.lines[10..-1].join
+
+      req_parsed = Utils.parse_request(client, body, headers)
+
+      handler = @router.route_request(method, path)
+      promises = []
+
+      promises << Concurrent::Promises.future do
+        @write_mutex.synchronize do
+          Middlewares.catcher.call(client, method, path, @logger)
+        end
+      end
+
+      @middlewares.each do |middleware|
+        promises << Concurrent::Promises.future do
+          @write_mutex.synchronize do
+            middleware.middleware.call(req_parsed, middleware.custom_headers)
+          end
+        end
+      end
+
+      Concurrent::Promises.zip(*promises).then do
+        handle_response(handler, req_parsed)
+      end.value!
+    rescue StandardError => e
+      handler_error(client, e)
+    end
+
+    def handle_response(handler, request)
+      if handler
+        if !request.client.closed?
+          handler.call(request)
+        else
+          Response.send_response(request.client, "Socket Closed", status: HttpStatusCodes::INTERNAL_SERVER_ERROR)
+        end
+      else
+        handle_unknown_request(request.client)
+      end
+    end
+
+    def handler_error(client, error)
+      @logger.log("Error handling request: #{error.message}", LogMode::ERROR)
+      Response.send_response(client, "Internal Server Error", status: HttpStatusCodes::INTERNAL_SERVER_ERROR) if !client.closed?
+    end
+
+    def read_headers(request)
+      headers = {}
+
+      request.lines[1..-1].each do |line|
+        return headers if line == "\r\n"
+
+        header, value = line.split
+        header = normalize(header)
+
+        headers[header] = value
+      end
+    end
+
+    def handle_unknown_request(client)
+      Response.send_response(client, @not_found_message, status: HttpStatusCodes::NOT_FOUND)
+    end
+
+    def normalize(header)
+      String(header).gsub(":", "").downcase.to_sym
+    end
+
+    def read_body(client, content_length)
+      content_length < 0 ? client.readpartial(READ_CHUNK) : ''
+    end
+  end
+end

data/lib/pickles_http/utils.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'io/nonblock'
+require 'stringio'
+require 'fcntl'
+
+module HttpStatusCodes
+  OK = 200
+  NOT_FOUND = 404
+  INTERNAL_SERVER_ERROR = 500
+  BAD_REQUEST = 400
+end
+
+class SocketInterceptor
+  attr_reader :buffer
+
+  def initialize(socket)
+    @socket = socket
+    @buffer = ""
+  end
+
+  def puts(data)
+    @buffer += data + "\n"
+    @socket.puts(data)
+  end
+
+  def flush
+    @socket.flush
+  end
+end
+
+class Response
+  class << self
+    attr_accessor :cors_headers
+  end
+
+  self.cors_headers = {}
+
+  def self.send_response(client = nil, body = nil, version: '1.1', status: HttpStatusCodes::OK, content_type: ContentTypes::HTML, custom_headers: {})
+    return if client.closed?
+
+    begin
+      if (client.nil? && body.nil?)
+        raise StandardError, "Client and body not set"
+      end
+
+      merged_hash = custom_headers.merge(self.cors_headers)
+
+      set_headers(client, version, status, content_type, merged_hash)
+      set_body(client, body)
+      client.flush
+
+      # intercepted_data = {
+      #   version: version,
+      #   status: status,
+      #   content_type: content_type,
+      #   headers: merged_hash,
+      #   body: body,
+      # }
+
+      # puts intercepted_data
+    rescue Errno::EPIPE => e
+      puts "Error in send_response #{e.message}"
+    ensure
+      client.close unless client.closed?
+    end
+  end
+
+  def self.parse_request(client)
+    p client.recv(20)
+  end
+
+  def self.set_headers(client, version, status, content_type, custom_headers)
+    client.puts "HTTP/#{version} #{status}"
+    client.puts "Content-Type: #{content_type}"
+
+    custom_headers.each do |key, value|
+      client.puts "#{key}: #{value}"
+    end
+
+    client.puts
+  end
+
+  def self.set_body(client, body = nil)
+    return if body.nil?
+
+    begin
+      client.puts body
+    rescue IO::WaitReadable
+      IO.select([client])
+      retry
+    rescue EOFError, Errno::ECONNRESET
+      puts "Client Disconnected"
+    end
+  end
+end
+
+class Middlewares
+  class << self
+    attr_accessor :catcher, :cors, :default_cors_headers, :Middleware_Parser
+  end
+
+  self.Middleware_Parser = Struct.new(:middleware, :custom_headers)
+
+  self.catcher = lambda do |_, method, path, logger|
+    logger.log("[#{method}] - #{path}", LogMode::INFO)
+  end
+
+  self.default_cors_headers = {
+    'Access-Control-Allow-Origin' => '*',
+    'Access-Control-Allow-Methods' => 'GET, POST, PUT, DELETE, OPTIONS',
+    'Access-Control-Allow-Headers' => 'Content-Type, Authorization'
+  }
+
+  self.cors = lambda do |request, custom_cors_headers = {}|
+    begin
+      merged_headers = self.default_cors_headers.merge(custom_cors_headers)
+
+      merged_headers = Hash[merged_headers.to_a.uniq]
+
+      merged_headers.each do |key, value|
+        Response.cors_headers[key] = value
+      end
+
+      return if request.client.closed?
+      request.client.flush
+    rescue StandardError => e
+      p "Error on cors Middleware: #{e.message}"
+    end
+  end
+end
+
+module RequestMethods
+  GET = 'GET'
+  POST = 'POST'
+  DELETE = 'DELETE'
+  PUT = 'PUT'
+  OPTIONS = 'OPTIONS'
+end
+
+module ContentTypes
+  HTML = 'text/html'
+  JSON = 'application/json'
+  MJS = 'text/javascript'
+  MP3 = 'audio/mpeg'
+end
+
+
+module LogMode
+  DEBUG = 'DEBUG'
+  INFO = 'INFO'
+  WARN = 'WARN'
+  ERROR = 'ERROR'
+  FATAL = 'FATAL'
+
+  SEVERITIES = {
+    'DEBUG' => 0,
+    'INFO' => 1,
+    'WARN' => 2,
+    'ERROR' => 3,
+    'FATAL' => 4
+  }.freeze
+end
+
+class PicklesHttpServer
+  module Utils
+    include HttpStatusCodes
+    include ContentTypes
+    include LogMode
+    include RequestMethods
+
+    Request = Struct.new(:client, :body, :headers)
+
+    def self.parse_request(client, body, headers)
+      Request.new(client, body, headers)
+    end
+  end
+end

data/lib/pickles_http.rb

@@ -0,0 +1,29 @@
+require 'pickles_http/server'
+
+class PicklesHttpServer
+  def initialize(port: 8080, log_file: true, host: '127.0.0.1')
+    @socket = PicklesHttpServer::Server.new(port, log_file, host: host.to_s)
+  end
+
+  def start
+    begin
+      @socket.start()
+    rescue Interrupt
+      puts 'PicklesServer stopped by user, Bye 👋'
+    end
+  end
+
+  # Method to add new route to PiclesServer
+  def add_route(method, path, handler)
+    @socket.add_route(method, path, handler)
+  end
+
+  def use(middleware, custom_cors_headers = {})
+    middleware_parsed = Middlewares.Middleware_Parser.new(middleware, custom_cors_headers)
+    @socket.use_middleware(middleware_parsed)
+  end
+
+  def set_server_options(option, value)
+    @socket.change_server_option(option, value)
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: pickles_http
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Moisés Guerola
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-02-29 00:00:00.000000000 Z
+dependencies: []
+description: A simple Http Framework gem
+email: daw.moisesguerola@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pickles_http.rb
+- lib/pickles_http/logger.rb
+- lib/pickles_http/router.rb
+- lib/pickles_http/server.rb
+- lib/pickles_http/utils.rb
+homepage: https://rubygems.org/gems/pickles_http
+licenses:
+- MIT
+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: []
+rubygems_version: 3.5.6
+signing_key:
+specification_version: 4
+summary: Simple HTTP Framework
+test_files: []